@expressive/mvc 0.53.3 → 0.53.6

package/dist/esm/index.js

@@ -0,0 +1,8 @@
+export { get } from './instruction/get';
+export { ref } from './instruction/ref';
+export { set } from './instruction/set';
+export { use } from './instruction/use';
+export { has } from './instruction/has';
+export { Model, Model as default } from './model';
+export { createEffect, createProxy, addListener } from './control';
+export { Context } from './context';

package/dist/esm/instruction/get.js

@@ -0,0 +1,87 @@
+import { Context } from '../context';
+import { createEffect } from '../control';
+import { fetch, METHOD, Model, PARENT, event, update } from '../model';
+import { use } from './use';
+const STALE = new WeakSet();
+function get(arg0, arg1) {
+    return use((key, subject, state) => {
+        if (typeof arg0 == "symbol")
+            throw new Error(`Attempted to use an instruction result (probably use or get) as computed source for ${subject}.${key}. This is not allowed.`);
+        if (Model.is(arg0)) {
+            const hasParent = PARENT.get(subject);
+            // TODO: notify on discovered context 
+            function assign(value) {
+                if (typeof arg1 == "function")
+                    value.get(x => arg1(x, key));
+                update(subject, key, value);
+            }
+            if (!hasParent) {
+                if (arg1 === true)
+                    throw new Error(`${subject} may only exist as a child of type ${arg0}.`);
+                Context.get(subject, (context) => {
+                    const model = context.get(arg0);
+                    if (model)
+                        assign(model);
+                    else if (arg1 !== false)
+                        throw new Error(`Required ${arg0} not found in context for ${subject}.`);
+                });
+            }
+            else if (!arg0 || hasParent instanceof arg0)
+                assign(hasParent);
+            else
+                throw new Error(`New ${subject} created as child of ${hasParent}, but must be instanceof ${arg0}.`);
+            return {
+                get: arg1 !== false
+            };
+        }
+        let from = subject;
+        if (arg0 instanceof Model) {
+            from = arg0;
+        }
+        else {
+            const fn = METHOD.get(arg0) || arg0;
+            arg1 = ((p, k) => fn.call(p, k, p));
+        }
+        const source = resolve => resolve(from);
+        const getter = arg1;
+        let reset;
+        let isAsync;
+        let proxy;
+        function connect(model) {
+            reset = createEffect(model, current => {
+                proxy = current;
+                if (!(key in state) || STALE.delete(compute))
+                    compute(!reset);
+                return (didUpdate) => {
+                    if (didUpdate) {
+                        STALE.add(compute);
+                        event(subject, key, true);
+                    }
+                };
+            }, false);
+        }
+        function compute(initial) {
+            let next;
+            try {
+                next = getter.call(proxy, proxy, key);
+            }
+            catch (err) {
+                console.warn(`An exception was thrown while ${initial ? "initializing" : "refreshing"} ${subject}.${key}.`);
+                if (initial)
+                    throw err;
+                console.error(err);
+            }
+            update(subject, key, next, !isAsync);
+        }
+        return () => {
+            if (!proxy) {
+                source(connect);
+                isAsync = true;
+            }
+            if (STALE.delete(compute))
+                compute();
+            return fetch(subject, key, !proxy);
+        };
+    });
+}
+export { get };