@expressive/mvc 0.48.0 → 0.50.0

package/dist/index.d.ts

@@ -61,21 +61,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 {
     /**
@@ -309,7 +307,7 @@ declare function ref<T = HTMLElement>(callback: ref.Callback<T | null>, ignoreNu
 
 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.
@@ -348,31 +346,42 @@ declare function use<T extends Model>(Type: Model.Type<T>, required: false): T |
 declare function use<T extends Model>(Type: Model.Type<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;
+/**
+ * Create a side-effect which will update whenever values accessed change.
+ * Callback is called immediately and if ever values are stale.
+ *
+ * @param target - Instance of Model to observe.
+ * @param callback - Function to invoke when values change.
+ * @param requireValues - If `true` will throw if accessing a value which is `undefined`.
+ */
+declare function effect<T extends {}>(target: T, callback: Effect<Required<T>>, requireValues: true): () => void;
+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 Expect = (model: Model) => (() => void) | void;
 }
 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.Type<T>, implicit?: boolean): T;
+    protected has<T extends Model>(type: Model.Type<T>, model: T): void;
+    protected put<T extends Model>(T: Model.Type<T>, I: T | ((model: T) => void), implicit?: boolean): void;
 }
 
 declare global {
@@ -392,4 +401,4 @@ declare global {
     }
 }
 
-export { Context, Model, Model as default, get, has, ref, set, use };
+export { Context, Model, Model as default, effect, get, has, ref, set, use };