@expressive/mvc 0.27.0 → 0.29.0

package/lib/index.d.ts

@@ -16,22 +16,33 @@ declare function run<S>(action: Async<S>): typeof action & {
     active: boolean;
 };
 
-declare namespace Context {
-    type Inputs = {
-        [key: string | number]: Model | Model.New;
-    };
-}
-declare class Context {
-    key: string;
-    private table;
-    private layer;
-    private has;
-    get<T extends Model>(Type: Model.Type<T>): T | undefined;
-    include(inputs: Context.Inputs): Map<Model, boolean>;
-    add<T extends Model>(input: T | Model.New<T>, implicit?: boolean): T;
-    push(): this;
-    pop(): void;
-}
+/** Type may not be undefined - instead will be null.  */
+type NoVoid<T> = T extends undefined | void ? null : T;
+type ForceUpdate = {
+    /** Force an update in current component. */
+    (): void;
+    /**
+     * Force an update and again after promise either resolves or rejects.
+     * Will return a duplicate of given Promise, which resolves after refresh.
+     */
+    <T = void>(passthru: Promise<T>): Promise<T>;
+    /**
+     * Force a update while calling async function.
+     * A refresh will occur both before and after given function.
+     * Any actions performed before first `await` will occur before refresh!
+     */
+    <T = void>(invoke: () => Promise<T>): Promise<T>;
+};
+type Factory<T extends Model, R> = (this: T, current: T, update: ForceUpdate) => R;
+/** Fetch instance of this class from context. */
+declare function get$1<T extends Model>(this: Model.Type<T>, ignoreUpdates?: true): Model.Focus<T>;
+/** Fetch instance of this class optionally. May be undefined, but will never subscribe. */
+declare function get$1<T extends Model>(this: Model.Type<T>, required: boolean): Model.Focus<T> | undefined;
+declare function get$1<T extends Model, R>(this: Model.Type<T>, factory: Factory<T, (() => R) | R | Promise<R>>): NoVoid<R>;
+declare function get$1<T extends Model, R>(this: Model.Type<T>, factory: Factory<T, (() => R) | null>): NoVoid<R> | null;
+
+declare function use$1<T extends Model>(this: Model.New<T>, callback?: (instance: T) => void, repeat?: boolean): Model.Focus<T>;
+declare function use$1<T extends Model>(this: Model.New<T>, apply?: Model.Values<T>, repeat?: boolean): Model.Focus<T>;
 
 type Callback = () => void;
 
@@ -47,124 +58,21 @@ declare global {
   }
 }
 
-type Observer<T extends Model = any> = (key: Model.Event<T> | null | undefined, source: Control) => Callback | null | void;
-declare namespace Control {
-    /**
-     * Property initializer, will run upon instance creation.
-     * Optional returned callback will run when once upon first access.
-     */
-    type Instruction<T> = (this: Control, key: string, thisArg: Control) => PropertyDescriptor<T> | Getter<T> | void;
-    type Getter<T> = (source: Model) => T;
-    type Setter<T> = (value: T) => boolean | void;
-    type PropertyDescriptor<T = any> = {
-        get?: Getter<T>;
-        set?: Setter<T> | false;
-        enumerable?: boolean;
-        value?: T;
-    };
-    type Callback = (control: Control) => void;
-    /**
-     * Callback for Controller.for() static method.
-     * Returned callback is forwarded.
-     */
-    type OnReady<T extends {}> = (control: Control<T>) => (() => void) | void;
-    type RequestRefresh = (update: (tick: number) => number) => void;
-    type GetContext = (target: Model) => (callback: (got: Context) => void) => void;
-    type GetAdapter<T> = (refresh: RequestRefresh, context: Context) => {
-        mount: () => (() => void) | void;
-        render: () => T;
-    } | void;
-    type GetHook = <T>(adapter: GetAdapter<T>) => T | null;
-    type UseAdapter<T extends Model, R> = (refresh: RequestRefresh) => {
-        instance: T;
-        mount: () => (() => void) | void;
-        render: R;
-    };
-    type UseHook = <T extends Model, R>(adapter: UseAdapter<T, R>) => R;
-}
-declare class Control<T extends {} = any> {
-    static ready: Set<Control.Callback>;
-    static after: Set<Callback>;
-    static before: Set<Callback>;
-    static pending: Set<Callback>;
-    static get: Control.GetHook;
-    static use: Control.UseHook;
-    static has: Control.GetContext;
-    static for: typeof control;
-    static apply: typeof apply;
-    static watch: typeof watch;
-    id: string | number;
-    subject: T;
-    state: {
-        [key: string]: any;
-    };
-    latest?: Model.Event<T>[];
-    frame: Set<string>;
-    followers: Set<Observer<any>>;
-    observers: Map<string, Set<Observer<any>>>;
-    constructor(subject: T, id?: string | number);
-    add(key: Extract<keyof T, string>): void;
-    watch(key: Extract<keyof T, string>, output: Control.PropertyDescriptor<any>): void;
-    ref<K extends Model.Key<T>>(key: K, callback?: (this: T, value: T[K]) => boolean | void): (value: any) => void;
-    update(key: string): void;
-    addListener(fn: Observer): () => boolean;
-    clear(): void;
+type OnValue<T, P extends Model.Key<T>> = (this: T, value: T[P], updated: Model.Event<T>[]) => void;
+type OnValues<T, P extends Model.Key<T>> = (this: T, value: Model.Export<T, P>, updated: Model.Event<T>[]) => void;
+interface Observable {
+    get(): Model.Export<this>;
+    get(effect: Model.Effect<this>): Callback;
+    get<P extends Model.Key<this>>(select: P): this[P];
+    get<P extends Model.Key<this>>(select: P, onUpdate: OnValue<this, P>, once?: boolean): Callback;
+    get<P extends Model.Key<this>>(select: P[]): Model.Export<this, P>;
+    get<P extends Model.Key<this>>(select: P[], onUpdate: OnValues<this, P>, once?: boolean): Callback;
+    set(): Promise<Model.Event<this>[]>;
+    set(timeout: number): Promise<Model.Event<this>[] | false>;
+    set<T extends Model.Values<this>>(source: T, only?: (keyof T)[]): Promise<Model.Event<T>[] | false>;
+    set<K extends Model.Key<this>>(key: K, value: Model.Value<this[K]>): Promise<Model.Event<this>[] | false>;
+    set<K extends Model.Event<this>>(key: K): Promise<Model.Event<this>[] | false>;
 }
-declare function control<T extends Model>(subject: T, ready: Control.OnReady<T>): Callback;
-declare function control<T extends Model>(subject: T, ready?: boolean): Control<T>;
-declare function watch<T extends {}>(on: T, cb: Observer): T;
-declare function apply<T = any>(instruction: Control.Instruction<T>): T;
-
-declare const STATE = "__state";
-declare const UPDATE = "__update";
-declare const CONTROL = "__control";
-declare const PARENT = "__parent";
-declare const Debug: {
-    /** Use to access snapshot of Model's current state. */
-    STATE: "__state";
-    /**
-     * Use to access snapshot of Model's latest update.
-     */
-    UPDATE: "__update";
-    /** Use to access a Model's controller. */
-    CONTROL: "__control";
-    /** Use to access a Model's parent, if exists. */
-    PARENT: "__parent";
-};
-/**
- * Generic will declare debug properties on a given Model.
- *
- * These properties always exist at runtime, however are hidden unless you cast your Model as `Debug<T>`.
- */
-type Debug<T extends Model = Model> = T & {
-    /** Controller for this instance. */
-    [CONTROL]?: Control<T>;
-    /** Current state of this instance. */
-    [STATE]?: Model.Export<T>;
-    /**
-     * Last update causing a refresh to subscribers.
-     *
-     * If accessed directly, will contain all keys from last push.
-     * If within a subscribed function, will contain only keys which explicitly caused a refresh.
-     */
-    [UPDATE]?: readonly Model.Event<T>[];
-    /**
-     * Parent currently assigned to parent. Usually the model which this one is a property of.
-     */
-    [PARENT]?: Model;
-};
-
-/** Type may not be undefined - instead will be null.  */
-type NoVoid<T> = T extends undefined | void ? null : T;
-/** Fetch instance of this class from context. */
-declare function get$1<T extends Model>(this: Model.Type<T>, ignoreUpdates?: true): T;
-/** Fetch instance of this class optionally. May be undefined, but will never subscribe. */
-declare function get$1<T extends Model>(this: Model.Type<T>, required: boolean): T | undefined;
-declare function get$1<T extends Model, R>(this: Model.Type<T>, factory: Model.GetCallback<T, (() => R) | R | Promise<R>>): NoVoid<R>;
-declare function get$1<T extends Model, R>(this: Model.Type<T>, factory: Model.GetCallback<T, (() => R) | null>): NoVoid<R> | null;
-
-declare function use$1<T extends Model>(this: Model.New<T>, callback?: (instance: T) => void, repeat?: boolean): T;
-declare function use$1<T extends Model>(this: Model.New<T>, apply?: Model.Compat<T>, repeat?: boolean): T;
 
 type InstanceOf<T> = T extends {
     prototype: infer U;
@@ -183,71 +91,37 @@ declare namespace Model {
     /**
      * Subset of `keyof T` which are not methods or defined by base Model U.
      **/
-    type Key<T, U = Model> = Extract<Exclude<keyof T, keyof U | keyof Debug>, string>;
+    type Key<T, U = Model> = Extract<Exclude<keyof T, keyof U>, string>;
     /** Including but not limited to `keyof T` which are not methods or defined by base Model. */
     type Event<T> = Key<T> | (string & {});
     /** Actual value stored in state. */
-    type Value<R> = R extends Ref<infer T> ? T : R;
-    /** Actual value belonging to a managed property. */
-    type ValueOf<T extends {}, K> = K extends keyof T ? Value<T[K]> : undefined;
-    type Export<T> = {
-        [P in Key<T>]: Value<T[P]>;
-    };
-    /** Object containing managed entries found in T. */
-    type Entries<T> = {
-        [K in Key<T>]: T[K];
-    };
+    type Value<R> = R extends Ref<infer T> ? T : R extends Observable ? Export<R> : R;
     /** Object comperable to data found in T. */
-    type Compat<T> = {
-        [K in Key<T>]?: T[K];
+    type Values<T> = {
+        [P in Key<T>]?: Value<T[P]>;
     };
     /**
      * Values from current state of given controller.
      *
      * Differs from `Entries` as values here will drill into "real" values held by exotics like ref.
      */
-    type Get<T, K extends Key<T> = Key<T>> = {
+    type Export<T, K extends Key<T> = Key<T>> = {
         [P in K]: Value<T[P]>;
     };
     /** Promise thrown by something which is not yet ready. */
     type Suspense = Promise<void> & Error;
-    type OnCallback<T extends Model> = (this: T, keys: Model.Event<T>[] | null) => void;
-    type GetCallback<T extends Model, R> = (this: T, model: T, update: ForceUpdate) => R;
-    type ForceUpdate = {
-        /** Force an update in current component. */
-        (): void;
-        /**
-         * Force an update and again after promise either resolves or rejects.
-         * Will return a duplicate of given Promise, which resolves after refresh.
-         */
-        <T = void>(passthru: Promise<T>): Promise<T>;
-        /**
-         * Force a update while calling async function.
-         * A refresh will occur both before and after given function.
-         * Any actions performed before first `await` will occur before refresh!
-         */
-        <T = void>(invoke: () => Promise<T>): Promise<T>;
-    };
-}
-declare class Model {
-    constructor(id?: string | number);
     /**
      * Reference to `this` without a subscription.
      * Use to obtain full reference from a destructure.
      */
-    get is(): this;
-    on(): Promise<Model.Event<this>[]>;
-    on(timeout?: number): Promise<Model.Event<this>[] | false>;
-    on<P extends Model.Event<this>>(keys?: P | P[], timeout?: number): Promise<P[] | false>;
-    on<P extends Model.Event<this>>(keys: P | P[], listener: Model.OnCallback<this>, once?: boolean): Callback;
-    on(effect: Model.Effect<this>): Callback;
-    get(): Model.Export<this>;
-    get<P extends Model.Key<this>>(select: P): this[P];
-    get<P extends Model.Key<this>>(select: Iterable<P>): Model.Get<this, P>;
-    get<P extends Model.Key<this>>(select: P, listener: (this: this, value: this[P]) => void): Callback;
-    get<P extends Model.Key<this>>(select: Iterable<P>, listener: (this: this, value: Model.Get<this, P>) => void): Callback;
-    set<T extends Model.Compat<this>>(source: T, only?: (keyof T)[]): Promise<Model.Key<T>[]>;
-    set<K extends Model.Event<this>>(key: K, value?: Model.ValueOf<this, K>): Promise<Model.Event<this>[] | false>;
+    type Focus<T> = T & {
+        is: T;
+    };
+}
+interface Model extends Observable {
+}
+declare class Model {
+    constructor(id?: string | number);
     /** Mark this instance for garbage collection. */
     null(): void;
     static get: typeof get$1;
@@ -265,7 +139,7 @@ declare class Model {
      *
      * Will determine if provided class is a subtype of this one.
      */
-    static isTypeof<T extends Model.Type>(this: T, maybe: any): maybe is T;
+    static is<T extends Model.Type>(this: T, maybe: any): maybe is T;
 }
 
 declare namespace get {
@@ -376,27 +250,10 @@ declare function set<T>(value: T, onUpdate: set.Callback<T>): T;
 
 type Empty = Record<string, never>;
 declare namespace use {
-    type Key<T extends {}> = Extract<keyof T, string>;
-    /**
-     * Assign value to observable property.
-     *
-     * If property is not already observed, it will become so.
-     */
-    type SetValue<T extends {}> = <K extends Key<T>>(property: K, value: T[K]) => void;
-    /**
-     * Observe property for updates.
-     *
-     * If property is not already observed, it will become so.
-     */
-    type OnUpdate<T extends {}> = <K extends Key<T>>(property: K, callback: (value: T[K], key: K) => void) => () => void;
-    export type Observable<T extends {}> = T & {
-        set: SetValue<T>;
-        on: OnUpdate<T>;
-    };
-    export type Collection<T> = Observable<{
+    type Record<T> = {
         [key: string | number]: T;
-    }>;
-    export {};
+    } & Observable;
+    type Object<T extends {}> = T & Observable;
 }
 /** Create a placeholder for specified Model type. */
 declare function use<T extends Model>(): T | undefined;
@@ -412,8 +269,135 @@ declare function use<T extends Model>(Type: Model.New<T>, ready?: (i: T) => void
  **/
 declare function use<T extends Model>(model: T, ready?: (i: T) => void): T;
 /** Create a managed record with observable entries. */
-declare function use<T = any, C = use.Collection<T>>(record: Empty, ready?: (object: C) => void): C;
+declare function use<T = any, C = use.Record<T>>(record: Empty, ready?: (object: C) => void): C;
 /** Create a managed object with observable entries. */
-declare function use<T extends {}, O = use.Observable<T>>(data: T, ready?: (object: O) => void): O;
+declare function use<T extends {}, O = use.Object<T>>(data: T, ready?: (object: O) => void): O;
+
+declare namespace Context {
+    type Inputs = {
+        [key: string | number]: Model | Model.New;
+    };
+}
+declare class Context {
+    key: string;
+    private table;
+    private layer;
+    private has;
+    get<T extends Model>(Type: Model.Type<T>): T | undefined;
+    include(inputs: Context.Inputs): Map<Model, boolean>;
+    add<T extends Model>(input: T | Model.New<T>, implicit?: boolean): T;
+    push(): this;
+    pop(): void;
+}
+
+type Observer<T extends Model = any> = (key: Model.Event<T> | null | undefined, source: Control) => Callback | null | void;
+declare namespace Control {
+    /**
+     * Property initializer, will run upon instance creation.
+     * Optional returned callback will run when once upon first access.
+     */
+    type Instruction<T> = (this: Control, key: string, thisArg: Control) => PropertyDescriptor<T> | Getter<T> | void;
+    type Getter<T> = (source: Model) => T;
+    type Setter<T> = (value: T) => boolean | void;
+    type PropertyDescriptor<T = any> = {
+        get?: Getter<T>;
+        set?: Setter<T> | false;
+        enumerable?: boolean;
+        value?: T;
+    };
+    type Callback = (control: Control) => void;
+    /**
+     * Callback for Controller.for() static method.
+     * Returned callback is forwarded.
+     */
+    type OnReady<T extends {}> = (control: Control<T>) => (() => void) | void;
+    type RequestRefresh = (update: (tick: number) => number) => void;
+    type GetContext = (target: Model) => (callback: (got: Context) => void) => void;
+    type GetAdapter<T> = (refresh: RequestRefresh, context: Context) => {
+        mount: () => (() => void) | void;
+        render: () => T;
+    } | void;
+    type GetHook = <T>(adapter: GetAdapter<T>) => T | null;
+    type UseAdapter<T extends Model, R> = (refresh: RequestRefresh) => {
+        instance: T;
+        mount: () => (() => void) | void;
+        render: R;
+    };
+    type UseHook = <T extends Model, R>(adapter: UseAdapter<T, R>) => R;
+}
+declare class Control<T extends {} = any> {
+    static ready: Set<Control.Callback>;
+    static after: Set<Callback>;
+    static before: Set<Callback>;
+    static pending: Set<Callback>;
+    static get: Control.GetHook;
+    static use: Control.UseHook;
+    static has: Control.GetContext;
+    static for: typeof control;
+    static apply: typeof apply;
+    static watch: typeof watch;
+    id?: string | number;
+    subject: T;
+    state: {
+        [key: string]: any;
+    };
+    latest?: Model.Event<T>[];
+    frame: Set<string>;
+    followers: Set<Observer<any>>;
+    observers: Map<string, Set<Observer<any>>>;
+    constructor(subject: T, id?: string | number | false);
+    add(key: Extract<keyof T, string>): void;
+    watch(key: string, output: Control.PropertyDescriptor<any>): void;
+    ref<K extends Model.Key<T>>(key: K, callback?: (this: T, value: T[K]) => boolean | void): (value: any) => void;
+    update(key: string): void;
+    addListener(fn: Observer): () => boolean;
+    clear(): void;
+}
+declare function control<T extends Model>(subject: T, ready: Control.OnReady<T>): Callback;
+declare function control<T extends Model>(subject: T, ready?: boolean): Control<T>;
+type Focus<T extends {}> = T & {
+    is: T;
+};
+declare function watch<T extends {}>(value: T, cb: Observer): Focus<T>;
+declare function apply<T = any>(instruction: Control.Instruction<T>): T;
+
+declare const STATE = "__state";
+declare const UPDATE = "__update";
+declare const CONTROL = "__control";
+declare const PARENT = "__parent";
+declare const Debug: {
+    /** Use to access snapshot of Model's current state. */
+    STATE: "__state";
+    /**
+     * Use to access snapshot of Model's latest update.
+     */
+    UPDATE: "__update";
+    /** Use to access a Model's controller. */
+    CONTROL: "__control";
+    /** Use to access a Model's parent, if exists. */
+    PARENT: "__parent";
+};
+/**
+ * Generic will declare debug properties on a given Model.
+ *
+ * These properties always exist at runtime, however are hidden unless you cast your Model as `Debug<T>`.
+ */
+type Debug<T extends Model = Model> = T & {
+    /** Controller for this instance. */
+    [CONTROL]?: Control<T>;
+    /** Current state of this instance. */
+    [STATE]?: Model.Export<T>;
+    /**
+     * Last update causing a refresh to subscribers.
+     *
+     * If accessed directly, will contain all keys from last push.
+     * If within a subscribed function, will contain only keys which explicitly caused a refresh.
+     */
+    [UPDATE]?: readonly Model.Event<T>[];
+    /**
+     * Parent currently assigned to parent. Usually the model which this one is a property of.
+     */
+    [PARENT]?: Model;
+};
 
 export { Context, Control, Debug, Model, Model as default, get, ref, run, set, use };