@expressive/mvc 0.49.0 → 0.50.1

package/dist/index.d.ts

@@ -2,6 +2,8 @@ type MaybeAsync<T> = T | Promise<T>;
 declare namespace Model {
     /** Any type of Model, using own class constructor as its identifier. */
     type Type<T extends Model = Model> = (abstract new (...args: any[]) => T) & typeof Model;
+    /** A Model constructor, but which is not abstract. */
+    type Init<T extends Model = Model> = (new (...args: Model.Args<T>) => T) & Omit<typeof Model, never>;
     /**
      * Model constructor callback - is called when Model finishes intializing.
      * Returned function will call when model is destroyed.
@@ -61,21 +63,19 @@ declare namespace Model {
      * @param update - `true` if update is pending, `false` effect has been cancelled, `null` if controller is destroyed.
      */
     type EffectCallback = ((update: boolean | null) => void);
-    namespace Instruction {
-        type Getter<T> = (source: Model) => T;
-        type Setter<T> = (value: T, previous: T) => boolean | void | (() => T);
-        type Descriptor<T = any> = {
-            get?: Getter<T> | boolean;
-            set?: Setter<T> | false;
-            enumerable?: boolean;
-            value?: T;
-        };
-    }
     /**
      * Property initializer, will run upon instance creation.
      * Optional returned callback will run when once upon first access.
      */
-    type Instruction<T = any, M extends Model = any> = (this: M, key: Field<M> & string, thisArg: M, state: State<M>) => Instruction.Descriptor<T> | Instruction.Getter<T> | void;
+    type Instruction<T = any, M extends Model = any> = (this: M, key: Field<M> & string, thisArg: M, state: State<M>) => Descriptor<T> | Getter<T> | void;
+    type Getter<T> = (source: Model) => T;
+    type Setter<T> = (value: T, previous: T) => boolean | void | (() => T);
+    type Descriptor<T = any> = {
+        get?: Getter<T> | boolean;
+        set?: Setter<T> | false;
+        enumerable?: boolean;
+        value?: T;
+    };
 }
 interface Model {
     /**
@@ -84,7 +84,7 @@ interface Model {
      **/
     is: this;
 }
-declare class Model {
+declare abstract class Model {
     constructor(...args: Model.Args);
     /** Pull current values from state. Flattens all models and exotic values recursively. */
     get(): Model.State<this>;
@@ -186,14 +186,14 @@ declare class Model {
      *
      * @param args - arguments sent to constructor
      */
-    static new<T extends Model>(this: Model.Type<T>, ...args: Model.Args<T>): T;
+    static new<T extends Model>(this: Model.Init<T>, ...args: Model.Args<T>): T;
     /**
      * Static equivalent of `x instanceof this`.
      * Determines if provided class is a subtype of this one.
      * If so, language server will make available all static
      * methods and properties of this class.
      */
-    static is<T extends Model.Type>(this: T, maybe: any): maybe is T;
+    static is<T extends Model.Type>(this: T, maybe: unknown): maybe is T;
     /**
      * Register a callback to run when any instance of this Model is updated.
      */
@@ -295,7 +295,7 @@ declare function ref<O extends Model, R>(target: O, mapper: (key: Model.Field<O>
  *
  * @param callback - Optional callback to synchronously fire when reference is first set or does update.
  */
-declare function ref<T = HTMLElement>(callback?: ref.Callback<T>): ref.Object<T>;
+declare function ref<T>(callback?: ref.Callback<T>): ref.Object<T>;
 /**
  * Creates a ref-compatible property.
  * Will persist value, and updates to this are made part of controller event-stream.
@@ -305,11 +305,11 @@ declare function ref<T = HTMLElement>(callback?: ref.Callback<T>): ref.Object<T>
  * @param callback - Optional callback to synchronously fire when reference is first set or does update.
  * @param ignoreNull - Default `true`. If `false`, will still callback with `null`.
  */
-declare function ref<T = HTMLElement>(callback: ref.Callback<T | null>, ignoreNull: boolean): ref.Object<T>;
+declare function ref<T>(callback: ref.Callback<T | null>, ignoreNull: boolean): ref.Object<T>;
 
 declare namespace set {
     type Callback<T, S = any> = (this: S, next: T, previous: T) => ((next: T) => void) | Promise<any> | void | boolean;
-    type Factory<T, S = any> = (this: S, key: string, thisArg: S) => Promise<T> | T;
+    type Factory<T, S = any> = (this: S, key: string) => Promise<T> | T;
 }
 /**
  * Set property with a placeholder.
@@ -344,15 +344,14 @@ declare function set<T>(factory: set.Factory<T> | Promise<T>, required?: boolean
 declare function set<T>(value: T | undefined, onUpdate: set.Callback<T>): T;
 
 declare function use<T = any>(instruction: Model.Instruction): T;
-declare function use<T extends Model>(Type: Model.Type<T>, required: false): T | undefined;
-declare function use<T extends Model>(Type: Model.Type<T>, ready?: (i: T) => void): T;
+declare function use<T extends Model>(Type: Model.Init<T>, required: false): T | undefined;
+declare function use<T extends Model>(Type: Model.Init<T>, ready?: (i: T) => void): T;
 
 declare namespace has {
-    type Callback<T = any> = (model: T) => void | boolean | (() => void);
+    type Callback<T = any> = (model: T, recipient: Model) => void | boolean | (() => void);
 }
-declare function has<T extends Model>(type: Model.Type<T>, one: true): T;
-declare function has<T extends Model>(type: Model.Type<T>, required: boolean): T | undefined;
-declare function has<T extends Model>(type: Model.Type<T>, arg?: has.Callback<T>): Set<T>;
+declare function has<T extends Model>(type: Model.Type<T>, callback?: has.Callback<T>): readonly T[];
+declare function has(callback?: has.Callback): readonly Model[];
 
 type Effect<T extends {}> = (this: T, argument: T) => ((update: boolean | null) => void) | Promise<void> | null | void;
 /**
@@ -367,24 +366,25 @@ declare function effect<T extends {}>(target: T, callback: Effect<Required<T>>,
 declare function effect<T extends {}>(target: T, callback: Effect<T>, requireValues?: boolean): () => void;
 
 declare namespace Context {
-    type Input = Record<string | number, Model | Model.Type<Model>>;
+    type Input = Record<string | number, Model | Model.Init>;
+    type Expect = (model: Model) => (() => void) | void;
+}
+interface Context {
+    [key: symbol]: Model | Context.Expect | null | undefined;
 }
 declare class Context {
     static get<T extends Model>(on: Model, callback: ((got: Context) => void)): void;
     static get<T extends Model>(on: Model): Context | undefined;
     id: string;
-    protected downstream: WeakMap<Model.Type<Model>, symbol>;
-    protected upstream: WeakMap<Model.Type<Model>, symbol>;
     protected layer: Map<string | number, Model | Model.Type<Model>>;
+    protected cleanup: Set<() => void>;
     constructor(inputs?: Context.Input);
-    key(T: Model.Type, upstream?: boolean): keyof this;
-    has(model: Model): (() => void) | undefined;
     get<T extends Model>(Type: Model.Type<T>): T | undefined;
-    include(inputs: Context.Input, forEach?: (added: Model, explicit: boolean) => void): void;
-    put<T extends Model>(T: Model.Type<T>, I: T | ((model: T) => void), implicit?: boolean, writable?: boolean): void;
-    add<T extends Model>(input: T | Model.Type<T>, implicit?: boolean): T;
+    get<T extends Model>(Type: Model.Type<T>, callback: (model: T) => void): void;
     push(inputs?: Context.Input): this;
     pop(): void;
+    include(inputs: Context.Input, forEach?: (added: Model, explicit: boolean) => void): void;
+    protected add<T extends Model>(input: T | Model.Init<T>, implicit?: boolean): T;
 }
 
 declare global {