@expressive/mvc 0.4.7 → 0.5.0

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,6 +210,24 @@ 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>;
@@ -357,12 +346,19 @@ 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> = T & {
+    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.
  */
@@ -393,8 +389,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 +625,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, put, ref, set, tap, use, useFrom, useLocal, useModel, useTap };