goog-enums-to-cljs.cljs

(defn obj->enums
  "Takes a js object and returns all keys that map to a string or a number (thus constant)"
  [obj]
  (sort
    (mapv first
          (js->clj
            (goog.object/filter
              obj
              (fn [v k]
                ((some-fn number? string?) v)))))))
#_(obj->enums goog.events.KeyCodes)

(defn gen-def-cont-str
  [gns]
  (with-out-str
    (doseq [k (obj->enums (js/eval (str gns)))]
      (let [sym (symbol k)]
        (binding [*print-meta* true]
          (prn `(def ~(with-meta sym {:const true}) ~(symbol (str gns "." sym)))))))))
#_ (gen-def-cont-str 'goog.events.KeyCodes)

(defn gns->cljsns
  [base gsym]
  (let [gstr (str gsym)
        [_ & r] (js->clj (.split gstr "."))
        lastns (goog.string.toSelectorCase (last r))
        lastns (cond-> lastns (clojure.string/starts-with? lastns "-") (subs 1))
        path (clojure.string/join \. (concat [base] (butlast r) [lastns]))]
    path))
#_(gns->cljsns "gconst" 'goog.events.KeyCodes)


(defn gen-gconst-ns
  [gsym]
  (let [out-ns (gns->cljsns "gconst" gsym)]
    (str
      "(ns " out-ns "\n  (:require [" gsym "]))\n\n"
      (gen-def-cont-str gsym))))
#_(gen-gconst-ns 'goog.events.KeyCodes)

Problem:

In cljs you can't switch-case on goog enums:

(case xyz
   KeyCodes/A :foo)

Usually people end up using condp for this, but a case would be the better/cleaner solution.

Synopsis:

Generate your namespaced keywords with gen-gcons-ns and put the output in the according cljs file. Example usage in the #_ comment.

Why?

Because then you can do (case pressedkey (DOWN DASH F1) (doit)) which you can't unless the vars are declares as ^:const.

Example:

(gen-gconst-ns 'goog.events.KeyCodes)

;; OUTPUT

(ns gconst.events.key-codes
  (:require [goog.events.KeyCodes]))

(def ^{:const true} A goog.events.KeyCodes.A)
(def ^{:const true} ALT goog.events.KeyCodes.ALT)
(def ^{:const true} APOSTROPHE goog.events.KeyCodes.APOSTROPHE)
(def ^{:const true} AT_SIGN goog.events.KeyCodes.AT_SIGN)
(def ^{:const true} B goog.events.KeyCodes.B)
(def ^{:const true} BACKSLASH goog.events.KeyCodes.BACKSLASH)
(def ^{:const true} BACKSPACE goog.events.KeyCodes.BACKSPACE)
(def ^{:const true} C goog.events.KeyCodes.C)
(def ^{:const true} CAPS_LOCK goog.events.KeyCodes.CAPS_LOCK)
(def ^{:const true} CLOSE_SQUARE_BRACKET goog.events.KeyCodes.CLOSE_SQUARE_BRACKET)
(def ^{:const true} COMMA goog.events.KeyCodes.COMMA)
(def ^{:const true} CONTEXT_MENU goog.events.KeyCodes.CONTEXT_MENU)
(def ^{:const true} CTRL goog.events.KeyCodes.CTRL)
(def ^{:const true} D goog.events.KeyCodes.D)
(def ^{:const true} DASH goog.events.KeyCodes.DASH)
(def ^{:const true} DELETE goog.events.KeyCodes.DELETE)
(def ^{:const true} DOWN goog.events.KeyCodes.DOWN)
(def ^{:const true} E goog.events.KeyCodes.E)
(def ^{:const true} EIGHT goog.events.KeyCodes.EIGHT)
(def ^{:const true} END goog.events.KeyCodes.END)
(def ^{:const true} ENTER goog.events.KeyCodes.ENTER)
(def ^{:const true} EQUALS goog.events.KeyCodes.EQUALS)
(def ^{:const true} ESC goog.events.KeyCodes.ESC)
(def ^{:const true} F goog.events.KeyCodes.F)
(def ^{:const true} F1 goog.events.KeyCodes.F1)
(def ^{:const true} F10 goog.events.KeyCodes.F10)
(def ^{:const true} F11 goog.events.KeyCodes.F11)
(def ^{:const true} F12 goog.events.KeyCodes.F12)
(def ^{:const true} F2 goog.events.KeyCodes.F2)
(def ^{:const true} F3 goog.events.KeyCodes.F3)
(def ^{:const true} F4 goog.events.KeyCodes.F4)
(def ^{:const true} F5 goog.events.KeyCodes.F5)
(def ^{:const true} F6 goog.events.KeyCodes.F6)
(def ^{:const true} F7 goog.events.KeyCodes.F7)
(def ^{:const true} F8 goog.events.KeyCodes.F8)
(def ^{:const true} F9 goog.events.KeyCodes.F9)
(def ^{:const true} FF_DASH goog.events.KeyCodes.FF_DASH)
(def ^{:const true} FF_EQUALS goog.events.KeyCodes.FF_EQUALS)
(def ^{:const true} FF_SEMICOLON goog.events.KeyCodes.FF_SEMICOLON)
(def ^{:const true} FIRST_MEDIA_KEY goog.events.KeyCodes.FIRST_MEDIA_KEY)
(def ^{:const true} FIVE goog.events.KeyCodes.FIVE)
(def ^{:const true} FOUR goog.events.KeyCodes.FOUR)
(def ^{:const true} G goog.events.KeyCodes.G)
(def ^{:const true} H goog.events.KeyCodes.H)
(def ^{:const true} HOME goog.events.KeyCodes.HOME)
(def ^{:const true} I goog.events.KeyCodes.I)
(def ^{:const true} INSERT goog.events.KeyCodes.INSERT)
(def ^{:const true} J goog.events.KeyCodes.J)
(def ^{:const true} K goog.events.KeyCodes.K)
(def ^{:const true} L goog.events.KeyCodes.L)
(def ^{:const true} LAST_MEDIA_KEY goog.events.KeyCodes.LAST_MEDIA_KEY)
(def ^{:const true} LEFT goog.events.KeyCodes.LEFT)
(def ^{:const true} M goog.events.KeyCodes.M)
(def ^{:const true} MAC_ENTER goog.events.KeyCodes.MAC_ENTER)
(def ^{:const true} MAC_FF_META goog.events.KeyCodes.MAC_FF_META)
(def ^{:const true} MAC_WK_CMD_LEFT goog.events.KeyCodes.MAC_WK_CMD_LEFT)
(def ^{:const true} MAC_WK_CMD_RIGHT goog.events.KeyCodes.MAC_WK_CMD_RIGHT)
(def ^{:const true} META goog.events.KeyCodes.META)
(def ^{:const true} N goog.events.KeyCodes.N)
(def ^{:const true} NINE goog.events.KeyCodes.NINE)
(def ^{:const true} NUMLOCK goog.events.KeyCodes.NUMLOCK)
(def ^{:const true} NUM_CENTER goog.events.KeyCodes.NUM_CENTER)
(def ^{:const true} NUM_DIVISION goog.events.KeyCodes.NUM_DIVISION)
(def ^{:const true} NUM_EIGHT goog.events.KeyCodes.NUM_EIGHT)
(def ^{:const true} NUM_FIVE goog.events.KeyCodes.NUM_FIVE)
(def ^{:const true} NUM_FOUR goog.events.KeyCodes.NUM_FOUR)
(def ^{:const true} NUM_MINUS goog.events.KeyCodes.NUM_MINUS)
(def ^{:const true} NUM_MULTIPLY goog.events.KeyCodes.NUM_MULTIPLY)
(def ^{:const true} NUM_NINE goog.events.KeyCodes.NUM_NINE)
(def ^{:const true} NUM_ONE goog.events.KeyCodes.NUM_ONE)
(def ^{:const true} NUM_PERIOD goog.events.KeyCodes.NUM_PERIOD)
(def ^{:const true} NUM_PLUS goog.events.KeyCodes.NUM_PLUS)
(def ^{:const true} NUM_SEVEN goog.events.KeyCodes.NUM_SEVEN)
(def ^{:const true} NUM_SIX goog.events.KeyCodes.NUM_SIX)
(def ^{:const true} NUM_THREE goog.events.KeyCodes.NUM_THREE)
(def ^{:const true} NUM_TWO goog.events.KeyCodes.NUM_TWO)
(def ^{:const true} NUM_ZERO goog.events.KeyCodes.NUM_ZERO)
(def ^{:const true} O goog.events.KeyCodes.O)
(def ^{:const true} ONE goog.events.KeyCodes.ONE)
(def ^{:const true} OPEN_SQUARE_BRACKET goog.events.KeyCodes.OPEN_SQUARE_BRACKET)
(def ^{:const true} P goog.events.KeyCodes.P)
(def ^{:const true} PAGE_DOWN goog.events.KeyCodes.PAGE_DOWN)
(def ^{:const true} PAGE_UP goog.events.KeyCodes.PAGE_UP)
(def ^{:const true} PAUSE goog.events.KeyCodes.PAUSE)
(def ^{:const true} PERIOD goog.events.KeyCodes.PERIOD)
(def ^{:const true} PHANTOM goog.events.KeyCodes.PHANTOM)
(def ^{:const true} PLUS_SIGN goog.events.KeyCodes.PLUS_SIGN)
(def ^{:const true} PRINT_SCREEN goog.events.KeyCodes.PRINT_SCREEN)
(def ^{:const true} Q goog.events.KeyCodes.Q)
(def ^{:const true} QUESTION_MARK goog.events.KeyCodes.QUESTION_MARK)
(def ^{:const true} R goog.events.KeyCodes.R)
(def ^{:const true} RIGHT goog.events.KeyCodes.RIGHT)
(def ^{:const true} S goog.events.KeyCodes.S)
(def ^{:const true} SCROLL_LOCK goog.events.KeyCodes.SCROLL_LOCK)
(def ^{:const true} SEMICOLON goog.events.KeyCodes.SEMICOLON)
(def ^{:const true} SEVEN goog.events.KeyCodes.SEVEN)
(def ^{:const true} SHIFT goog.events.KeyCodes.SHIFT)
(def ^{:const true} SINGLE_QUOTE goog.events.KeyCodes.SINGLE_QUOTE)
(def ^{:const true} SIX goog.events.KeyCodes.SIX)
(def ^{:const true} SLASH goog.events.KeyCodes.SLASH)
(def ^{:const true} SPACE goog.events.KeyCodes.SPACE)
(def ^{:const true} T goog.events.KeyCodes.T)
(def ^{:const true} TAB goog.events.KeyCodes.TAB)
(def ^{:const true} THREE goog.events.KeyCodes.THREE)
(def ^{:const true} TILDE goog.events.KeyCodes.TILDE)
(def ^{:const true} TWO goog.events.KeyCodes.TWO)
(def ^{:const true} U goog.events.KeyCodes.U)
(def ^{:const true} UP goog.events.KeyCodes.UP)
(def ^{:const true} V goog.events.KeyCodes.V)
(def ^{:const true} VK_NONAME goog.events.KeyCodes.VK_NONAME)
(def ^{:const true} W goog.events.KeyCodes.W)
(def ^{:const true} WIN_IME goog.events.KeyCodes.WIN_IME)
(def ^{:const true} WIN_KEY goog.events.KeyCodes.WIN_KEY)
(def ^{:const true} WIN_KEY_FF_LINUX goog.events.KeyCodes.WIN_KEY_FF_LINUX)
(def ^{:const true} WIN_KEY_RIGHT goog.events.KeyCodes.WIN_KEY_RIGHT)
(def ^{:const true} X goog.events.KeyCodes.X)
(def ^{:const true} Y goog.events.KeyCodes.Y)
(def ^{:const true} Z goog.events.KeyCodes.Z)
(def ^{:const true} ZERO goog.events.KeyCodes.ZERO)