@expressive/mvc 1.0.0-beta.44 → 1.0.0-beta.45

package/lib/index.d.ts

@@ -18,6 +18,8 @@ declare function act<S>(action: Async<S>): typeof action & {
     active: boolean;
 };
 
+declare function array<T = any>(): T[];
+
 type Callback = () => void;
 type Class = new (...args: any[]) => any;
 type InstanceOf<T> = T extends { prototype: infer U } ? U : never;
@@ -34,7 +36,7 @@ declare class Subscriber<T extends Stateful = any> {
     commit: () => () => void;
     active: boolean;
     dependant: Set<Listener>;
-    watch: { [key in Model.Event<T, Model>]: true | Callback; };
+    watch: { [key in Model.Event<T, Model>]: boolean | Callback; };
     constructor(target: Controller<T> | T, onUpdate: Controller.OnEvent);
 }
 
@@ -200,43 +202,31 @@ declare class Controller<T extends Stateful = any> {
  * Property initializer, will run upon instance creation.
  * Optional returned callback will run when once upon first access.
  */
-type Instruction<T> = (this: Controller, key: string, thisArg: Controller) =>
-  | Instruction.Getter<T> 
-  | Instruction.ExplicitDescriptor
-  | Instruction.Descriptor<T>
-  | Instruction.RecursiveDescriptor<T>
-  | boolean
-  | void;
-
+declare type Instruction<T> = (this: Controller, key: string, thisArg: Controller) => Instruction.Getter<T> | Instruction.ExplicitDescriptor | Instruction.Descriptor<T> | Instruction.RecursiveDescriptor<T> | boolean | void;
 declare namespace Instruction {
-  type Getter<T> = (state: T, within?: Subscriber) => T;
-  type Setter<T> = (value: T, state: any) => boolean | void;
-
-  type Runner<T> = (this: Controller, key: string, on: Controller) => Instruction.Descriptor<T> | boolean | undefined;
-
-  interface Descriptor<T> {
-    configurable?: boolean;
-    enumerable?: boolean;
-    value?: T;
-    writable?: boolean;
-    get?: Getter<T>;
-    set?: Setter<T> | false;
-    suspense?: boolean;
-  }
-
-  interface ExplicitDescriptor extends PropertyDescriptor {
-    explicit: true;
-  }
-
-  interface RecursiveDescriptor<T> {
-    recursive: true;
-    enumerable?: boolean;
-    value?: T;
-    set?: Setter<T> | false;
-    suspense?: boolean;
-  }
+    type Getter<T> = (state: T, within?: Subscriber) => T;
+    type Setter<T> = (value: T, state: any) => boolean | void;
+    type Runner<T> = (this: Controller, key: string, on: Controller) => Instruction.Descriptor<T> | boolean | undefined;
+    interface Descriptor<T> {
+        configurable?: boolean;
+        enumerable?: boolean;
+        value?: T;
+        writable?: boolean;
+        get?: Getter<T>;
+        set?: Setter<T> | false;
+        suspense?: boolean;
+    }
+    interface ExplicitDescriptor extends PropertyDescriptor {
+        explicit: true;
+    }
+    interface RecursiveDescriptor<T> {
+        recursive: true;
+        enumerable?: boolean;
+        value?: T;
+        set?: Setter<T> | false;
+        suspense?: boolean;
+    }
 }
-
 /**
  * Run instruction as controller sets itself up.
  * This will specialize the behavior of a given property.
@@ -607,4 +597,4 @@ declare function useTap<T extends Stateful, K extends Model.Field<T>>(source: T
 declare function useTap<T extends Stateful, R>(source: T | (() => T) | useTap.Tappable, compute: (this: T, from: T) => R, expect: true): Exclude<R, undefined>;
 declare function useTap<T extends Stateful, R>(source: T | (() => T) | useTap.Tappable, compute: (this: T, from: T) => R, expect?: boolean): R;
 
-export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, Stateful, WHY, act, apply, MVC as default, from, parent, ref, set, tap, use, useFrom, useInContext, useModel, useTap };
+export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, Stateful, WHY, act, apply, array, MVC as default, from, parent, ref, set, tap, use, useFrom, useInContext, useModel, useTap };

package/lib/index.esm.js

@@ -93,6 +93,149 @@ function applyUpdate(subject, keys) {
     };
 }
 
+const CONTROL = Symbol("CONTROL");
+const WHY = Symbol("UPDATE");
+const LOCAL = Symbol("LOCAL");
+const STATE = Symbol("STATE");
+class Model {
+    constructor() {
+        define(this, CONTROL, new Controller(this));
+        define(this, "get", this);
+        define(this, "set", this);
+    }
+    get [STATE]() {
+        return this[CONTROL].state;
+    }
+    get [WHY]() {
+        return UPDATE.get(this);
+    }
+    on(select, handler, squash, once) {
+        return control(this, control => {
+            if (typeof select == "function")
+                return control.addListener(select);
+            const keys = typeof select == "string" ? [select] :
+                !select.length ? getOwnPropertyNames(control.state) :
+                    select;
+            ensure(control, keys);
+            const callback = squash
+                ? handler.bind(this)
+                : frame => frame
+                    .filter(k => keys.includes(k))
+                    .forEach(k => handler.call(this, control.state[k], k));
+            const trigger = once
+                ? frame => { remove(); callback(frame); }
+                : callback;
+            const remove = control.addListener(key => {
+                if (keys.includes(key))
+                    return trigger;
+            });
+            return remove;
+        });
+    }
+    once(select, callback, squash) {
+        if (callback)
+            return this.on(select, callback, squash, true);
+        return new Promise(resolve => {
+            this.on(select, resolve, true, true);
+        });
+    }
+    effect(callback, select) {
+        const effect = createEffect(callback);
+        return control(this, control => {
+            if (!select) {
+                const sub = new Subscriber(control, () => invoke);
+                const invoke = () => {
+                    const x = sub.proxy;
+                    effect.call(x, x);
+                };
+                invoke();
+                return sub.commit();
+            }
+            const invoke = () => {
+                effect.call(this.get, this.get);
+            };
+            invoke();
+            if (!select.length) {
+                control.onDestroy.add(invoke);
+                return () => {
+                    control.onDestroy.delete(invoke);
+                };
+            }
+            return control.addListener(key => {
+                if (select.includes(key))
+                    return invoke;
+            });
+        });
+    }
+    // TODO: account for exotic properties
+    import(source, select) {
+        const { subject } = control(this);
+        if (!select)
+            select = getOwnPropertyNames(subject);
+        for (const key of select)
+            if (key in source)
+                this[key] = source[key];
+    }
+    export(subset) {
+        const { state } = control(this);
+        const output = {};
+        if (!subset)
+            subset = getOwnPropertyNames(state);
+        for (const key of subset)
+            output[key] = state[key];
+        return output;
+    }
+    update(arg, tag) {
+        const target = control(this);
+        if (typeof arg == "string") {
+            target.update(arg);
+            if (1 in arguments && arg in this) {
+                const method = this[arg];
+                if (typeof method == "function")
+                    if (typeof tag != "boolean")
+                        method.call(this, tag);
+                    else if (tag)
+                        method.call(this);
+            }
+            arg = undefined;
+        }
+        return target.requestUpdate(arg);
+    }
+    /**
+     * Mark this instance for garbage-collection and send `willDestroy` event to all listeners.
+     */
+    destroy() {
+        control(this).stop();
+    }
+    toString() {
+        return this.constructor.name;
+    }
+    /**
+     * Creates a new instance of this controller.
+     *
+     * Beyond `new this(...)`, method will activate managed-state.
+     *
+     * @param args - arguments sent to constructor
+     */
+    static create(...args) {
+        const instance = new this(...args);
+        control(instance);
+        return instance;
+    }
+    /**
+     * Static equivalent of `x instanceof this`.
+     *
+     * Will determine if provided class is a subtype of this one.
+     */
+    static isTypeof(maybe) {
+        return (typeof maybe == "function" &&
+            maybe.prototype instanceof this);
+    }
+}
+defineLazy(Model, CONTROL, function () {
+    return new Controller(this);
+});
+
 class Subscriber {
     constructor(target, onUpdate) {
         this.onUpdate = onUpdate;
@@ -304,6 +447,7 @@ const Oops$9 = issues({
     StrictUpdate: () => `Strict update() did not find pending updates.`,
     NoChaining: () => `Then called with undefined; update promise will never catch nor supports chaining.`
 });
+const PENDING = new Map();
 const READY = new WeakSet();
 class Controller {
     constructor(subject) {
@@ -329,52 +473,28 @@ class Controller {
         const { value: entry } = getOwnPropertyDescriptor(subject, key);
         if (typeof entry == "function")
             return;
-        let onGet;
-        let onSet;
-        let set;
-        let enumerable;
-        let suspense;
-        const instruction = Pending.get(entry);
-        if (instruction) {
-            Pending.delete(entry);
-            delete subject[key];
-            const desc = instruction.call(this, key, this);
-            if (desc === false)
-                return;
-            if (typeof desc == "object") {
-                if ("value" in desc)
-                    state[key] = desc.value;
-                onSet = desc.set;
-                onGet = desc.get;
-                suspense = desc.suspense;
-                enumerable = desc.enumerable;
-            }
+        if (typeof entry == "symbol") {
+            const instruction = PENDING.get(entry);
+            if (instruction)
+                instruction.call(this, key, this);
+            return;
         }
-        else
-            state[key] = entry;
-        if (onSet !== false)
-            set = this.ref(key, onSet);
-        const get = (local) => {
-            if (!(key in state) && suspense)
-                throw suspend(this, key);
-            const value = state[key];
-            if (onGet)
-                return local
-                    ? onGet(value, local)
-                    : onGet(value);
-            return value;
-        };
+        state[key] = entry;
+        const set = this.ref(key);
         defineProperty(subject, key, {
-            enumerable, set, get
+            enumerable: false,
+            get: () => state[key],
+            set
         });
         defineProperty(proxy, key, {
-            enumerable, set,
+            enumerable: false,
             get() {
                 const local = this[LOCAL];
                 if (local && !local.watch[key])
                     local.watch[key] = true;
-                return get(local);
-            }
+                return state[key];
+            },
+            set
         });
     }
     ref(key, handler) {
@@ -473,179 +593,55 @@ function control(subject, cb) {
     return cb(control);
 }
 
-const CONTROL = Symbol("CONTROL");
-const WHY = Symbol("UPDATE");
-const LOCAL = Symbol("LOCAL");
-const STATE = Symbol("STATE");
-class Model {
-    constructor() {
-        define(this, CONTROL, new Controller(this));
-        define(this, "get", this);
-        define(this, "set", this);
-    }
-    get [STATE]() {
-        return this[CONTROL].state;
-    }
-    get [WHY]() {
-        return UPDATE.get(this);
-    }
-    on(select, handler, squash, once) {
-        return control(this, control => {
-            if (typeof select == "function")
-                return control.addListener(select);
-            const keys = typeof select == "string" ? [select] :
-                !select.length ? getOwnPropertyNames(control.state) :
-                    select;
-            ensure(control, keys);
-            const callback = squash
-                ? handler.bind(this)
-                : frame => frame
-                    .filter(k => keys.includes(k))
-                    .forEach(k => handler.call(this, control.state[k], k));
-            const trigger = once
-                ? frame => { remove(); callback(frame); }
-                : callback;
-            const remove = control.addListener(key => {
-                if (keys.includes(key))
-                    return trigger;
-            });
-            return remove;
-        });
-    }
-    once(select, callback, squash) {
-        if (callback)
-            return this.on(select, callback, squash, true);
-        return new Promise(resolve => {
-            this.on(select, resolve, true, true);
-        });
-    }
-    effect(callback, select) {
-        const effect = createEffect(callback);
-        return control(this, control => {
-            if (!select) {
-                const sub = new Subscriber(control, () => invoke);
-                const invoke = () => {
-                    const x = sub.proxy;
-                    effect.call(x, x);
-                };
-                invoke();
-                return sub.commit();
-            }
-            const invoke = () => {
-                effect.call(this.get, this.get);
-            };
-            invoke();
-            if (!select.length) {
-                control.onDestroy.add(invoke);
-                return () => {
-                    control.onDestroy.delete(invoke);
-                };
-            }
-            return control.addListener(key => {
-                if (select.includes(key))
-                    return invoke;
-            });
-        });
-    }
-    // TODO: account for exotic properties
-    import(source, select) {
-        const { subject } = control(this);
-        if (!select)
-            select = getOwnPropertyNames(subject);
-        for (const key of select)
-            if (key in source)
-                this[key] = source[key];
-    }
-    export(subset) {
-        const { state } = control(this);
-        const output = {};
-        if (!subset)
-            subset = getOwnPropertyNames(state);
-        for (const key of subset)
-            output[key] = state[key];
-        return output;
-    }
-    update(arg, tag) {
-        const target = control(this);
-        if (typeof arg == "string") {
-            target.update(arg);
-            if (1 in arguments && arg in this) {
-                const method = this[arg];
-                if (typeof method == "function")
-                    if (typeof tag != "boolean")
-                        method.call(this, tag);
-                    else if (tag)
-                        method.call(this);
-            }
-            arg = undefined;
-        }
-        return target.requestUpdate(arg);
-    }
-    /**
-     * Mark this instance for garbage-collection and send `willDestroy` event to all listeners.
-     */
-    destroy() {
-        control(this).stop();
-    }
-    toString() {
-        return this.constructor.name;
-    }
-    /**
-     * Creates a new instance of this controller.
-     *
-     * Beyond `new this(...)`, method will activate managed-state.
-     *
-     * @param args - arguments sent to constructor
-     */
-    static create(...args) {
-        const instance = new this(...args);
-        control(instance);
-        return instance;
-    }
-    /**
-     * Static equivalent of `x instanceof this`.
-     *
-     * Will determine if provided class is a subtype of this one.
-     */
-    static isTypeof(maybe) {
-        return (typeof maybe == "function" &&
-            maybe.prototype instanceof this);
-    }
-}
-defineLazy(Model, CONTROL, function () {
-    return new Controller(this);
-});
-
-const Pending = new Map();
 function apply(fn, label) {
     const name = label || fn.name || "pending";
     const placeholder = Symbol(`${name} instruction`);
     function setup(key) {
+        const { proxy, state, subject } = this;
+        const control = this;
+        PENDING.delete(placeholder);
+        delete subject[key];
         let output = fn.call(this, key, this);
-        switch (typeof output) {
-            case "function":
-                return { get: output };
-            case "object": {
-                if ("explicit" in output && output.explicit) {
-                    defineProperty(this.subject, key, output);
-                    return false;
-                }
-                if ("recursive" in output && output.recursive)
-                    return Object.assign(Object.assign({}, output), { get: recursive(this, key) });
-            }
-            case "boolean":
-                return output;
+        if (typeof output == "function")
+            output = { get: output };
+        if (typeof output != "object")
+            return;
+        if ("explicit" in output && output.explicit) {
+            defineProperty(subject, key, output);
+            return false;
         }
-        return;
+        if ("recursive" in output && output.recursive)
+            output = Object.assign(Object.assign({}, output), { get: recursive(this, key) });
+        const desc = output;
+        if ("value" in desc)
+            state[key] = desc.value;
+        const { get: onGet, set: onSet, enumerable, suspense } = desc;
+        let set = onSet === false
+            ? undefined
+            : this.ref(key, onSet);
+        function get() {
+            if (!(key in state) && suspense)
+                throw suspend(control, key);
+            const local = this[LOCAL];
+            if (local && !(key in local.watch))
+                local.watch[key] = true;
+            const value = state[key];
+            if (!onGet)
+                return value;
+            return local
+                ? onGet(value, local)
+                : onGet(value);
+        }
+        for (const x of [subject, proxy])
+            defineProperty(x, key, { enumerable, get, set });
     }
-    Pending.set(placeholder, setup);
+    PENDING.set(placeholder, setup);
     return placeholder;
 }
 function recursive(source, key) {
-    const context = new WeakMap();
-    const subscribe = (parent) => {
+    return forSubscriber((parent, context) => {
         let child;
-        const init = () => {
+        function init() {
             if (child) {
                 child.release();
                 parent.dependant.delete(child);
@@ -660,15 +656,23 @@ function recursive(source, key) {
                 parent.dependant.add(child);
                 context.set(parent, child.proxy);
             }
-        };
+        }
         init();
         parent.watch[key] = init;
-    };
+    });
+}
+function forSubscriber(fn) {
+    const context = new WeakMap();
     return (value, local) => {
         if (!local)
             return value;
-        if (!context.has(local))
-            subscribe(local);
+        if (!context.has(local)) {
+            const output = fn(local, context);
+            if (output) {
+                context.set(local, output);
+                return output;
+            }
+        }
         return context.get(local);
     };
 }
@@ -702,6 +706,65 @@ function act(task) {
     });
 }
 
+class Managed extends Array {
+    constructor(onUpdate) {
+        super();
+        this.lastUpdate = [0, 0];
+        this.update = (from, to) => {
+            this.lastUpdate = [from, to];
+            onUpdate();
+        };
+    }
+    push(...items) {
+        const length = this.length;
+        const end = super.push(...items);
+        this.update(length, end);
+        return end;
+    }
+    unshift(...items) {
+        const end = super.push(...items);
+        this.update(0, end);
+        return end;
+    }
+    splice(start, deleteCount, ...rest) {
+        this.update(start, deleteCount !== rest.length ? Infinity : deleteCount);
+        return super.splice(start, deleteCount, ...rest);
+    }
+}
+function array() {
+    return apply(function array(key) {
+        const array = new Managed(() => this.update(key));
+        const access = forSubscriber(context => {
+            const local = Object.create(array);
+            const update = context.onUpdate(key, this);
+            let rangeA = 0;
+            let rangeB = 0;
+            function onUpdate() {
+                const [lastA, lastB] = array.lastUpdate;
+                if (rangeA <= lastB && rangeB >= lastA)
+                    return update;
+            }
+            function listen(eventA, eventB) {
+                if (context.active)
+                    return;
+                context.watch[key] = onUpdate;
+                rangeA = Math.min(rangeA, eventA);
+                rangeB = Math.max(rangeB, eventB);
+            }
+            local[Symbol.iterator] = () => {
+                listen(0, Infinity);
+                return array[Symbol.iterator]();
+            };
+            return local;
+        });
+        return {
+            get: access,
+            set: false,
+            value: array
+        };
+    });
+}
+
 function ref(arg) {
     return apply(function ref(key) {
         let value = {};
@@ -1287,5 +1350,5 @@ class Global extends MVC {
     }
 }
 
-export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, WHY, act, apply, MVC as default, from, parent, ref, set, tap, use$1 as use, useFrom, useInContext, useModel, useTap };
+export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, WHY, act, apply, array, MVC as default, from, parent, ref, set, tap, use$1 as use, useFrom, useInContext, useModel, useTap };
 //# sourceMappingURL=index.esm.js.map