Improved reference handling

src/pluto/js.cljs

@@ -22,4 +22,4 @@
                                                                   :suggestions? :view}]}}}}})
 
 (defn ^:export parse [m]
-  (reader/parse ctx (:data m)))
+  (reader/parse ctx (:data m)))

src/pluto/reader/errors.cljc

@@ -16,6 +16,7 @@
                    ::invalid-destructuring-format
                    ::missing-keys
                    ::unknown-reference
+                   ::unknown-reference-type
                    ::unknown-component
                    ::unknown-component-property
                    ::invalid-view

src/pluto/reader/reference.cljc

@@ -14,21 +14,31 @@
   "Return the symbol pointed by the reference
 
    ```clojure
-   (= 'some.ref (reference->symbol ['views/some.ref]))
+   (= 'some.ref (reference->symbol ['some.ref]))
    ```"
   [o]
   (when (reference? o)
     (first o)))
 
+(def type->ns {:view "views" :query "queries" :event "events"})
+
+(defn- resolve-symbol
+  "Resolve a symbol first via the extension definition then via the host ctx."
+  [ctx ext ns s]
+  (or (get ext (symbol ns (name s)))
+      (get-in ctx [:capacities :components s :value])))
+
 (defn resolve
   "Resolve a reference defined by a hook
 
    ```clojure
-   (= {:data \"view\"} (resolve {'views/id \"view\"} ['views/id]))
+   (= {:data \"view\"} (resolve {'views/id \"view\"} :view ['id]))
    ```"
-  [ext value]
+  [ctx ext type value]
   (if-let [s (reference->symbol value)]
-    (if-let [o (get ext s)]
-      {:data o}
-      {:errors [(errors/error ::errors/unknown-reference {:value s})]})
+    (if-let [ns (get type->ns type)]
+      (if-let [o (resolve-symbol ctx ext ns s)]
+        {:data o}
+        {:errors [(errors/error ::errors/unknown-reference {:value s})]})
+      {:errors [(errors/error ::errors/unknown-reference-type {:value type})]})
     {:errors [(errors/error ::errors/invalid-reference {:value value})]}))

src/pluto/reader/views.cljc

@@ -129,7 +129,7 @@
     h))
 
 (defmethod types/resolve :view [ctx ext type value]
-  (let [{:keys [data errors]} (reference/resolve ext value)]
+  (let [{:keys [data errors]} (reference/resolve ctx ext type value)]
     (if data
       (let [{:keys [data errors]} (parse ctx ext data)]
         ;; TODO Might fail at runtime if destructuring is incorrect

test/pluto/reader/reference_test.cljc

@@ -19,10 +19,15 @@
 
 (deftest resolve
   (is (= {:errors [{::errors/type  ::errors/unknown-reference
-                    ::errors/value {:value 'views/id}}]}
-         (reference/resolve {} ['views/id])))
+                    ::errors/value {:value 'id}}]}
+         (reference/resolve {} {} :view ['id])))
   (is (= {:errors [{::errors/type  ::errors/invalid-reference
                     ::errors/value {:value ""}}]}
-         (reference/resolve {'views/id "view"} "")))
+         (reference/resolve {} {'views/id "view"} :view "")))
+  (is (= {:errors [{::errors/type  ::errors/unknown-reference-type
+                    ::errors/value {:value :unknown}}]}
+         (reference/resolve {} {'views/id "view"} :unknown ['id])))
   (is (= {:data "view"}
-         (reference/resolve {'views/id "view"} ['views/id]))))
+         (reference/resolve {} {'views/id "view"} :view ['id])))
+  (is (= {:data :div}
+         (reference/resolve {:capacities {:components {'component {:value :div}}}} {} :view ['component]))))