@expressive/mvc 0.4.7 → 0.6.1

package/lib/index.d.ts

@@ -1,25 +1,5 @@
 import React from 'react';
 
-declare type Async<T = any> = (...args: any[]) => Promise<T>;
-/**
- * Sets an exotic method with managed ready-state. Property accepts an async function.
- *
- * When an act-method is invoked, its `active` property to true for duration of call.
- * This is emitted as an update to property, both when called and after returns (or throws).
- *
- * **Note:** Subsequent calls will immediately throw if one is still pending.
- *
- * @param action - Action to fire when resulting property is invoked.
- */
-declare function act(action: Async): typeof action & {
-    active: boolean;
-};
-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;
@@ -39,13 +19,12 @@ declare class Subscriber<T extends Stateful = any> {
     constructor(parent: Controller<T>, onUpdate: Controller.OnEvent);
 }
 
-declare const CONTROL: unique symbol;
 declare const WHY: unique symbol;
 declare const LOCAL: unique symbol;
 declare const STATE: unique symbol;
 interface Stateful {
     /** Controller for this instance. */
-    [CONTROL]: Controller;
+    [CONTROL]?: Controller;
     /** Current subscriber (if present) while used in a live context (e.g. hook or effect). */
     [LOCAL]?: Subscriber;
     /** Current state of this instance. */
@@ -107,14 +86,6 @@ declare namespace Model {
     };
 }
 interface Model extends Stateful {
-    /**
-     * Circular reference to `this` controller.
-     *
-     * Useful to obtain full reference where one has already destructured.
-     *
-     * @deprecated will be removed in favor of `is`
-     */
-    get: this;
     /**
      * Circular reference to `this` controller.
      *
@@ -130,7 +101,6 @@ interface Model extends Stateful {
     set: Model.Refs<this>;
 }
 declare class Model {
-    static [CONTROL]: Controller;
     static [WHY]: readonly string[];
     constructor();
     get [STATE](): Model.Values<this, Exclude<keyof this & string, keyof Model>>;
@@ -184,6 +154,7 @@ declare class Model {
     static isTypeof<T extends new () => Model>(this: T, maybe: any): maybe is T;
 }
 
+declare const CONTROL: unique symbol;
 declare namespace Controller {
     type OnValue<T = any> = (this: T, value: any) => boolean | void;
     type OnEvent<T = any> = (key: Model.Event<T> | null, source: Controller) => Callback | void;
@@ -239,10 +210,27 @@ declare namespace Instruction {
  */
 declare function apply<T = any>(instruction: Instruction<T>, name?: string): T;
 
+declare type Async<T = any> = (...args: any[]) => Promise<T>;
+/**
+ * Sets an exotic method with managed ready-state. Property accepts an async function.
+ *
+ * When an act-method is invoked, its `active` property to true for duration of call.
+ * This is emitted as an update to property, both when called and after returns (or throws).
+ *
+ * **Note:** Subsequent calls will immediately throw if one is still pending.
+ *
+ * @param action - Action to fire when resulting property is invoked.
+ */
+declare function act(action: Async): typeof action & {
+    active: boolean;
+};
+declare function act<S>(action: Async<S>): typeof action & {
+    active: boolean;
+};
+
 declare namespace get {
-    type Function<T, O = any> = (this: O, on: O) => T;
-    type Factory<T, O = any> = (key: string) => Function<T, O>;
-    type Getter = (controller: Controller, key: string) => any;
+    type Function<T, S = any> = (this: S, on: S) => T;
+    type Factory<T, S = unknown> = (this: S, key: string, thisArg: S) => T;
 }
 /**
  * Implement a computed value; output will be generated by provided function.
@@ -259,35 +247,8 @@ declare function get<R, T>(source: T, compute: (this: T, on: T) => R, suspend?:
  * @param compute - Factory function to generate a getter to subscribe dependancies.
  * @param suspend - Value will throw suspense when evaulating to undefined.
  */
-declare function get<R, T>(compute: (property: string) => (this: T, state: T) => R, suspend: true): Exclude<R, undefined>;
-declare function get<R, T>(compute: (property: string) => (this: T, state: T) => R, suspend?: boolean): R;
-
-declare namespace ref {
-    type Callback<T, S = any> = (this: S, argument: T) => ((next: T) => void) | Promise<void> | void | boolean;
-    interface Object<T = any> {
-        (next: T): void;
-        current: T | null;
-    }
-    /** Object with references to all managed values of `T`. */
-    type Proxy<T extends Model> = {
-        [P in Model.Field<T>]: Model.Ref<T[P]>;
-    };
-}
-/**
- * Creates a ref-compatible property.
- * Will persist value, and updates to this are made part of controller event-stream.
- *
- * *Output is simultaneously a ref-function and ref-object, use as needed.*
- *
- * @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, S>(callback?: ref.Callback<T, S>): ref.Object<T>;
-
-declare namespace set$1 {
-    type Factory<T, S = unknown> = (this: S, key: string, subject: S) => T;
-    type Callback<T, S = any> = (this: S, argument: T) => ((next: T) => void) | Promise<any> | void | boolean;
-}
+declare function get<R, T>(compute: (property: string, on: T) => (this: T, state: T) => R, suspend: true): Exclude<R, undefined>;
+declare function get<R, T>(compute: (property: string, on: T) => (this: T, state: T) => R, suspend?: boolean): R;
 /**
  * Set property with an async function.
  *
@@ -303,12 +264,10 @@ declare namespace set$1 {
  * @param factory - Callback run to derrive property value.
  * @param required - (default: true) Run factory immediately on creation, otherwise on access.
  */
-declare function put<T>(factory: set$1.Factory<Promise<T>>, required: false): T | undefined;
-declare function put<T, S>(factory: set$1.Factory<Promise<T>, S>, required: false): T | undefined;
-declare function put<T>(factory: set$1.Factory<Promise<T>>, required?: boolean): T;
-declare function put<T, S>(factory: set$1.Factory<Promise<T>, S>, required?: boolean): T;
-declare function put<T>(value: set$1.Factory<Promise<T>>, onUpdate: set$1.Callback<T>): T;
-declare function put<T, S>(value: set$1.Factory<Promise<T>, S>, onUpdate: set$1.Callback<T, S>): T;
+declare function get<T>(factory: get.Factory<Promise<T>>, required: false): T | undefined;
+declare function get<T, S>(factory: get.Factory<Promise<T>, S>, required: false): T | undefined;
+declare function get<T>(factory: get.Factory<Promise<T>>, required?: boolean): T;
+declare function get<T, S>(factory: get.Factory<Promise<T>, S>, required?: boolean): T;
 /**
  * Set property with a factory function.
  *
@@ -321,24 +280,37 @@ declare function put<T, S>(value: set$1.Factory<Promise<T>, S>, onUpdate: set$1.
  * @param factory - Callback run to derrive property value.
  * @param required - (default: true) Run factory immediately on creation, otherwise on access.
  */
-declare function put<T>(factory: set$1.Factory<T>, required: false): T | undefined;
-declare function put<T, S>(factory: set$1.Factory<T, S>, required: false): T | undefined;
-declare function put<T>(factory: set$1.Factory<T>, required?: boolean): T;
-declare function put<T, S>(factory: set$1.Factory<T, S>, required?: boolean): T;
-declare function put<T>(value: set$1.Factory<T>, onUpdate: set$1.Callback<T>): T;
-declare function put<T, S>(value: set$1.Factory<T, S>, onUpdate: set$1.Callback<T, S>): T;
+declare function get<T>(factory: get.Factory<T>, required: false): T | undefined;
+declare function get<T, S>(factory: get.Factory<T, S>, required: false): T | undefined;
+declare function get<T>(factory: get.Factory<T>, required?: boolean): T;
+declare function get<T, S>(factory: get.Factory<T, S>, required?: boolean): T;
 /**
  * Assign a property with result of a promise.
  */
-declare function put<T>(factory: Promise<T>, required: false): T | undefined;
-declare function put<T>(factory: Promise<T>, required?: boolean): T;
-declare function put<T>(value: Promise<T>, onUpdate: set$1.Callback<T>): T;
+declare function get<T>(factory: Promise<T>, required: false): T | undefined;
+declare function get<T>(factory: Promise<T>, required?: boolean): T;
+
+declare namespace ref {
+    type Callback<T, S = any> = (this: S, argument: T) => ((next: T) => void) | Promise<void> | void | boolean;
+    interface Object<T = any> {
+        (next: T): void;
+        current: T | null;
+    }
+    /** Object with references to all managed values of `T`. */
+    type Proxy<T extends Model> = {
+        [P in Model.Field<T>]: Model.Ref<T[P]>;
+    };
+}
 /**
- * Assign a property.
+ * Creates a ref-compatible property.
+ * Will persist value, and updates to this are made part of controller event-stream.
+ *
+ * *Output is simultaneously a ref-function and ref-object, use as needed.*
+ *
+ * @param callback - Optional callback to synchronously fire when reference is first set or does update.
  */
-declare function put<T>(factory: T, required: false): T | undefined;
-declare function put<T>(factory: T, required?: boolean): T;
-declare function put<T>(value: T, onUpdate: set$1.Callback<T>): T;
+declare function ref<T = HTMLElement>(callback?: ref.Callback<T>): ref.Object<T>;
+declare function ref<T, S>(callback?: ref.Callback<T, S>): ref.Object<T>;
 
 declare namespace set {
     type Callback<T, S = any> = (this: S, argument: T) => ((next: T) => void) | Promise<any> | void | boolean;
@@ -357,16 +329,26 @@ declare function set<T, S>(value: undefined, onUpdate: set.Callback<T, S>): T;
 declare function set<T>(value: T, onUpdate: set.Callback<T>): T;
 declare function set<T, S>(value: T, onUpdate: set.Callback<T, S>): T;
 
-declare function use<K = any>(initial: SetConstructor): Set<K>;
-declare function use<K = any, V = any>(initial: MapConstructor): Map<K, V>;
-declare function use(initial: Set<unknown>): Set<any>;
-declare function use(initial: Map<unknown, unknown>): Map<any, any>;
-declare function use(from: () => Set<unknown>): Set<any>;
-declare function use(from: () => Map<unknown, unknown>): Map<any, any>;
+declare type MapFunction<T, R> = T extends Map<infer K, infer V> ? (value: V, key: K, map: T) => R | void : T extends Set<infer K> ? (value: K, key: K, set: T) => R | void : never;
+declare type Managed<T> = Exclude<T, "forEach"> & {
+    from?: T;
+    forEach<R>(mapFunction: MapFunction<T, R>, thisArg?: any): Exclude<R, undefined>[] | void;
+};
+
+declare function use<K = any>(initial: SetConstructor): Managed<Set<K>>;
+declare function use<K = any, V = any>(initial: MapConstructor): Managed<Map<K, V>>;
+declare function use(initial: Set<unknown>): Managed<Set<any>>;
+declare function use(initial: Map<unknown, unknown>): Managed<Map<any, any>>;
+declare function use(from: () => Set<unknown>): Managed<Set<any>>;
+declare function use(from: () => Map<unknown, unknown>): Managed<Map<any, any>>;
+declare function use<T extends Set<any> | Map<any, any>>(initial: T): Managed<T>;
+declare function use<T extends Set<any> | Map<any, any>>(from: () => T): Managed<T>;
 /**
  * Create a placeholder for specified Model type.
  */
 declare function use<T extends Model>(): T | undefined;
+declare function use<T extends Model>(from: () => T, required: false): T | undefined;
+declare function use<T extends Model>(from: () => T, required: boolean): T;
 /**
  * Create a new child instance of model.
  */
@@ -374,6 +356,9 @@ declare function use<T extends Class>(Type: T, callback?: (i: InstanceOf<T>) =>
 /**
  * Create a managed child from factory function.
  */
+declare function use<T extends {}>(from: () => Promise<T>, required: false): T | undefined;
+declare function use<T extends {}>(from: () => Promise<T>, required: boolean): T;
+declare function use<T extends {}>(from: () => Promise<T>, callback?: (i: T) => void): T;
 declare function use<T extends {}>(from: () => T, callback?: (i: T) => void): T;
 /**
  * Create child-instance relationship with provided model.
@@ -393,8 +378,8 @@ declare function use<T extends {}>(peer: T, callback?: (i: T) => void): T;
  * @param Expects - Type of controller compatible with this class.
  * @param required - Throw if controller is created independantly.
  */
-declare function parent<T extends typeof Model>(Expects: T, required: false): InstanceOf<T> | undefined;
-declare function parent<T extends typeof Model>(Expects: T, required?: true): InstanceOf<T>;
+declare function has<T extends typeof Model>(Expects: T, required: false): InstanceOf<T> | undefined;
+declare function has<T extends typeof Model>(Expects: T, required?: true): InstanceOf<T>;
 
 declare class MVC extends Model {
     static [CONTROL]: Controller;
@@ -629,4 +614,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, array, MVC as default, get as from, get, parent, put, ref, set, tap, use, useFrom, useLocal, useModel, useTap };
+export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, Stateful, WHY, act, apply, MVC as default, get, has, ref, set, tap, use, useFrom, useLocal, useModel, useTap };