@expressive/mvc 0.33.0 → 0.35.0-alpha.0

package/lib/index.d.ts

@@ -1,411 +0,0 @@
-type Async<T = any> = (...args: any[]) => Promise<T>;
-/**
- * Sets an exotic method with managed ready-state. Property accepts an async function.
- *
- * When a run-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 run(action: Async): typeof action & {
-    active: boolean;
-};
-declare function run<S>(action: Async<S>): typeof action & {
-    active: boolean;
-};
-
-/** 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;
-
-declare global {
-  namespace jest {
-    interface Matchers<R> {
-      /** Assert model does have one or more updates pending. */
-      toUpdate(): Promise<R>;
-
-      /** Assert model did update with keys specified. */
-      toHaveUpdated<R>(keys: string[]): Promise<R>; 
-    }
-  }
-}
-
-type SelectOne<T, K extends Model.Key<T>> = K;
-type SelectFew<T, K extends Model.Key<T>> = K[];
-type Select<T, K extends Model.Key<T> = Model.Key<T>> = K | K[];
-type Export<T, S> = S extends SelectOne<T, infer P> ? T[P] : S extends SelectFew<T, infer P> ? Model.Export<T, P> : never;
-type OnUpdate<T, S> = (this: T, value: Export<T, S>, updated: Model.Event<T>[]) => void;
-interface Observable {
-    get(): Model.Export<this>;
-    get<P extends Select<this>>(select: P): Export<this, P>;
-    get<P extends Select<this>>(select: P, onUpdate: OnUpdate<this, P>, once?: true): Callback;
-    get<P extends Select<this>>(select: P, onUpdate: OnUpdate<this, P>, initial?: false): Callback;
-    get(effect: Model.Effect<this>): Callback;
-    set(): Promise<Model.Event<this>[]>;
-    set(timeout: number): Promise<Model.Event<this>[] | false>;
-    set<T extends Model.Values<this>>(from: 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>;
-}
-
-type InstanceOf<T> = T extends {
-    prototype: infer U;
-} ? U : never;
-declare namespace Model {
-    /** Any typeof Model, using class constructor as the reference. */
-    type Type<T extends Model = Model> = abstract new (...args: any[]) => T;
-    /** A typeof Model, specifically one which can be created without any arguments. */
-    type New<T extends Model = Model> = (new () => T) & typeof Model;
-    /** A callback function which is subscribed to parent and updates when values change. */
-    type Effect<T> = (this: T, argument: T) => Callback | Promise<void> | void;
-    /** Subset of `keyof T` which are not methods or defined by base Model U. **/
-    type Key<T, U = Observable> = 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 & {});
-    /** Object comperable to data found in T. */
-    type Values<T> = {
-        [P in Key<T>]?: Value<T[P]>;
-    };
-    /**
-     * Values from current state of given controller.
-     * Differs from `Values` as values here will drill into "real" values held by exotics like ref.
-     */
-    type Export<T, K extends Key<T> = Key<T>> = {
-        [P in K]: Value<T[P]>;
-    };
-    /**
-     * Reference to `this` without a subscription.
-     * Use to obtain full reference from a destructure.
-     */
-    type Focus<T> = T & {
-        is: T;
-    };
-    /** Exotic value, actual value is contained. */
-    type Ref<T = any> = {
-        (next: T): void;
-        current: T | null;
-    };
-    /** Actual value stored in state. */
-    type Value<R> = R extends Ref<infer T> ? T : R extends Observable ? Export<R> : R;
-}
-interface Model extends Observable {
-}
-declare class Model {
-    constructor(id?: string | number);
-    /** Mark this instance for garbage collection. */
-    null(): void;
-    static get: typeof get$1;
-    static use: typeof use$1;
-    /**
-     * Creates a new instance of this controller.
-     *
-     * Beyond `new this(...)`, method will activate managed-state.
-     *
-     * @param args - arguments sent to constructor
-     */
-    static new<T extends new (...args: any[]) => any>(this: T, ...args: ConstructorParameters<T>): InstanceOf<T>;
-    /**
-     * Static equivalent of `x instanceof this`.
-     *
-     * Will determine if provided class is a subtype of this one.
-     */
-    static is<T extends Model.Type>(this: T, maybe: any): maybe is T;
-}
-
-declare namespace get {
-    type Function<T, S = any> = (this: S, on: S) => T;
-    type Factory<R, T> = (this: T, property: string, on: T) => Function<R, T>;
-    type Source<T extends Model = Model> = (callback: (x: T) => void) => void;
-}
-/**
- * Fetches and assigns the controller which spawned this host.
- * When parent assigns an instance via `use()` directive, it
- * will be made available to child upon this request.
- *
- * @param Type - Type of controller compatible with this class.
- * @param required - Throw if controller is created independantly.
- */
-declare function get<T extends Model>(Type: Model.Type<T>, required?: true): T;
-declare function get<T extends Model>(Type: Model.Type<T>, required: boolean): T | undefined;
-declare function get<R, T extends Model>(Type: Model.Type<T>, compute: (this: T, on: T) => R): Exclude<R, undefined>;
-declare function get<R, T extends Model>(Type: Model.Type<T>, compute: (this: T, on: T) => R): R;
-/**
- * Implement a computed value; output will be generated by provided function.
- *
- * @param source - Source model from which computed value will be a subscriber.
- * @param compute - Compute function. Bound to a subscriber-proxy of source, returns output value. Will update automatically as input values change.
- */
-declare function get<R, T extends Model>(source: T, compute: (this: T, on: T) => R): Exclude<R, undefined>;
-declare function get<R, T extends Model>(source: T, compute: (this: T, on: T) => R): R;
-/**
- * Implement a computed value; output is returned by function from provided factory.
- *
- * @param compute - Factory function to generate a getter to subscribe dependancies.
- */
-declare function get<R, T>(compute: (property: string, on: T) => (this: T, state: T) => R): Exclude<R, undefined>;
-declare function get<R, T>(compute: (property: string, on: T) => (this: T, state: T) => R): R;
-
-declare namespace ref {
-    type Callback<T> = (argument: T) => ((next: T | null) => void) | Promise<void> | void | boolean;
-    interface Object<T = any> {
-        (next: T | null): void;
-        current: T | null;
-    }
-    /** Object with references to all managed values of `T`. */
-    type Proxy<T extends Model> = {
-        [P in Model.Key<T>]-?: Model.Ref<T[P]>;
-    };
-    type CustomProxy<T extends Model, R> = {
-        [P in Model.Key<T>]-?: R;
-    };
-}
-/**
- * Creates an object with references to all managed values.
- * Each property is a function to set value in state when invoked.
- *
- * *Properties are simultaneously a ref-function and ref-object, use as needed.*
- *
- * @param target - Source model from which to reference values.
- */
-declare function ref<T extends Model>(target: T): ref.Proxy<T>;
-/**
- * Creates an object with values based on managed values.
- * Each property will invoke mapper function on first access supply
- * the its return value going forward.
- *
- * @param target - Source model from which to reference values.
- * @param mapper - Function producing the placeholder value for any given property.
- */
-declare function ref<O extends Model, R>(target: O, mapper: (key: Model.Key<O>) => R): ref.CustomProxy<O, R>;
-/**
- * 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>;
-/**
- * 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.
- * @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 namespace set {
-    type Callback<T, S = any> = (this: S, argument: T) => ((next: T) => void) | Promise<any> | void | boolean;
-    type Factory<T, S = any> = (this: S, key: string, thisArg: S) => Promise<T> | T;
-}
-/**
- * Set property with a placeholder.
- *
- * Property cannot be accessed until it is defined. If accessed while undefined, a hybrid
- * `Promise`/`Error` (ala: [Suspense](https://reactjs.org/docs/concurrent-mode-suspense.html)) will be thrown.
- */
-declare function set<T = any>(): T;
-/**
- * Set property with a factory function.
- *
- * If async, poperty cannot be accessed until resolves, yeilding a result.
- * If accessed while still processing, React Suspense will be thrown.
- *
- * - `required: true` (default) -
- *      Run factory immediately upon creation of model instance.
- * - `required: false` -
- *      Run factory only if/when accessed.
- *      Value will always throw suspense at least once - use with caution.
- *
- * @param factory - Callback run to derrive property value.
- * @param required - (default: true) Run factory immediately on creation, otherwise on access.
- */
-declare function set<T>(factory: set.Factory<T> | Promise<T>, required: false): T | undefined;
-declare function set<T>(factory: set.Factory<T> | Promise<T>, required?: boolean): T;
-declare function set<T>(value: undefined, onUpdate: set.Callback<T>): T;
-declare function set<T>(value: T, onUpdate: set.Callback<T>): T;
-
-type Empty = Record<string, never>;
-declare namespace use {
-    type Record<T> = {
-        [key: string | number]: T;
-    } & Observable;
-    type Object<T extends {}> = T & Observable;
-}
-/** Create a placeholder for specified Model type. */
-declare function use<T extends Model>(): T | undefined;
-/** Create a new child instance of model. */
-declare function use<T extends Model>(Type: Model.New<T>, ready?: (i: T) => void): T;
-/**
- * Use existing model as a child of model assigned to.
- *
- * Note: If `peer` is not already initialized before parent is
- * (created with `new` as opposed to create method), that model will
- * attach this via `parent()` instruction. It will not, however, if
- * already active.
- **/
-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.Record<T>>(record: Empty, ready?: (object: C) => void): C;
-/** Create a managed object with observable entries. */
-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 | false;
-    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: 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 };