@expressive/mvc 0.72.0 → 0.73.1

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+//#region src/observable.d.ts
 /**
  * Update callback function.
  *
@@ -12,15 +13,16 @@ type Notify<T extends Observable = any> = (this: T, key: Event, source: T) => ((
 type Effect<T extends Observable> = (proxy: T) => ((update: boolean | null) => void) | Promise<void> | null | void;
 type Event = number | string | null | boolean | symbol;
 type PromiseLite<T = void> = {
-    then: (callback: () => T) => T;
+  then: (callback: () => T) => T;
 };
 declare namespace Observable {
-    type Callback = () => void | PromiseLite;
+  type Callback = () => void | PromiseLite;
 }
 interface Observable {
-    [Observable](callback: Observable.Callback, required?: boolean): this | void;
+  [Observable](callback: Observable.Callback, required?: boolean): this | void;
 }
 declare const Observable: unique symbol;
+/** Update register. */
 declare function addListener<T extends Observable>(subject: T, callback: Notify<T>, select?: Event | Set<Event>): () => boolean;
 declare function event(subject: Observable, key?: string | number | symbol | null, silent?: boolean): void;
 /**
@@ -31,264 +33,252 @@ declare function event(subject: Observable, key?: string | number | symbol | nul
  * @param callback - Function to invoke when values change.
  * @param requireValues - If `true` will throw if accessing a value which is `undefined`.
  */
-declare function watch<T extends State>(target: T, callback: Effect<Required<T>>, requireValues: true): () => void;
-declare function watch<T extends State>(target: T, callback: Effect<T>, recursive?: boolean): () => void;
-
+declare function watch<T extends Observable>(target: T, callback: Effect<Required<T>>, requireValues: true): () => void;
+declare function watch<T extends Observable>(target: T, callback: Effect<T>, recursive?: boolean): () => void;
+//#endregion
+//#region src/state.d.ts
 /** Reference bound instance methods to real ones. */
 declare const METHOD: WeakMap<any, any>;
 declare namespace State {
-    /**
-     * State which is valid to create.
-     *
-     * This interface may be augmented to add dditional
-     * constraints on states, such as special hooks or properties,
-     * to interact with environment or helper frameworks.
-     **/
-    interface Valid extends State {
-        'new'?(): void | (() => void);
-    }
-    /**
-     * A State class which is valid and may be instantiated.
-     */
-    type New<T extends State> = State.Class<T & Valid>;
-    /** Any type of State, using own class constructor as its identifier. */
-    type Extends<T extends State = State> = (abstract new (...args: any[]) => T) & typeof State;
-    /** A State constructor which is not abstract. */
-    type Class<T extends State = State> = (new (...args: State.Args<T>) => T) & Omit<typeof State, never>;
-    /** State constructor arguments */
-    type Args<T extends State = any> = (Args<T> | Init<T> | Assign<T> | string | void)[];
-    /**
-     * State constructor callback - is called when State finishes intializing.
-     * Returned function will run when state is destroyed.
-     */
-    type Init<T extends State = State> = (this: T, thisArg: T) => Promise<void> | (() => void) | Args<T> | Assign<T> | void;
-    /** Object overlay to override values and methods on a state. */
-    type Assign<T> = Record<string, unknown> & {
-        [K in Field<T>]?: T[K] extends (...args: infer A) => infer R ? (this: T, ...args: A) => R : T[K];
-    };
-    /** Subset of `keyof T` which are not methods or defined by base State U. **/
-    type Field<T> = Exclude<keyof T, keyof State>;
-    /** Any valid key for state, including but not limited to Field<T>. */
-    type Event<T> = Field<T> | number | symbol | (string & {});
-    /** Export/Import compatible value for a given property in a State. */
-    type Export<R> = R extends {
-        get(): infer T;
-    } ? T : R;
-    /** Value for a property managed by a state. */
-    type Value<T extends State, K extends Event<T>> = K extends keyof T ? Export<T[K]> : unknown;
-    type Setter<T> = (value: T, previous: T) => boolean | void | (() => T);
-    type OnEvent<T extends State> = (this: T, key: unknown, source: T) => void | (() => void) | null;
-    type OnUpdate<T extends State, K extends Event<T>> = (this: T, key: K, thisArg: K) => void;
-    /**
-     * Values from current state of given state.
-     * Differs from `Values` as values here will drill
-     * into "real" values held by exotics like ref.Object.
-     */
-    type Values<T> = {
-        [P in Field<T>]: Export<T[P]>;
-    };
-    /** Object comperable to data found in T. */
-    type Partial<T> = {
-        [P in Field<T>]?: Export<T[P]>;
-    };
-    /** Exotic value, where actual value is contained within. */
-    type Ref<T = any> = {
-        (next: T): void;
-        current: T | null;
-    };
-    /**
-     * A callback function which is subscribed to parent and updates when accessed properties change.
-     *
-     * @param current - Current state of this state. This is a proxy which detects properties which
-     * where accessed, and thus depended upon to stay current.
-     *
-     * @param update - Set of properties which have changed, and events fired, since last update.
-     *
-     * @returns A callback function which will be called when this effect is stale.
-     */
-    type Effect<T> = (this: T, current: T, update: Set<Event<T>>) => EffectCallback | Promise<void> | null | void;
-    /**
-     * A callback function returned by effect. Will be called when effect is stale.
-     *
-     * @param update - `true` if update is pending, `false` effect has been cancelled, `null` if state is destroyed.
-     */
-    type EffectCallback = (update: boolean | null) => void;
+  /** Any type of State, using own class constructor as its identifier. */
+  type Extends<T extends State = State> = (abstract new (...args: any[]) => T) & typeof State;
+  /** A State constructor which may be instanciated. */
+  type Type<T extends State = State> = (new (...args: State.Args<T>) => T) & Omit<typeof State, never>;
+  /** State constructor arguments */
+  type Args<T extends State = any> = (Args<T> | Init<T> | Assign<T> | string | void)[];
+  /**
+   * State constructor callback - is called when State finishes intializing.
+   * Returned function will run when state is destroyed.
+   */
+  type Init<T extends State = State> = (this: T, thisArg: T) => Promise<void> | (() => void) | Args<T> | Assign<T> | void;
+  /** Object overlay to override values and methods on a state. */
+  type Assign<T> = Record<string, unknown> & { [K in Field<T>]?: T[K] extends ((...args: infer A) => infer R) ? (this: T, ...args: A) => R : T[K] };
+  /** Subset of `keyof T` which are not methods or defined by base State U. **/
+  type Field<T> = Exclude<keyof T, keyof State>;
+  /** Any valid key for state, including but not limited to Field<T>. */
+  type Event<T> = Field<T> | number | symbol | (string & {});
+  /** Export/Import compatible value for a given property in a State. */
+  type Export<R> = R extends {
+    get(): infer T;
+  } ? T : R;
+  /** Value for a property managed by a state. */
+  type Value<T extends State, K extends State.Event<T>> = K extends keyof T ? Export<T[K]> : unknown;
+  type Setter<T> = (value: T, previous: T) => boolean | void | (() => T);
+  type OnEvent<T extends State> = (this: T, key: unknown, source: T) => void | (() => void) | null;
+  type OnUpdate<T extends State, K extends State.Event<T>> = (this: T, key: K, thisArg: K) => void;
+  /**
+   * Values from current state of given state.
+   * Differs from `Values` as values here will drill
+   * into "real" values held by exotics like ref.Object.
+   */
+  type Values<T> = { [P in Field<T>]: Export<T[P]> };
+  /** Object comperable to data found in T. */
+  type Partial<T> = { [P in Field<T>]?: Export<T[P]> };
+  /** Exotic value, where actual value is contained within. */
+  type Ref<T = any> = {
+    (next: T): void;
+    current: T | null;
+  };
+  /**
+   * A callback function which is subscribed to parent and updates when accessed properties change.
+   *
+   * @param current - Current state of this state. This is a proxy which detects properties which
+   * where accessed, and thus depended upon to stay current.
+   *
+   * @param update - Set of properties which have changed, and events fired, since last update.
+   *
+   * @returns A callback function which will be called when this effect is stale.
+   */
+  type Effect<T> = (this: T, current: T, update: Set<State.Event<T>>) => EffectCallback | Promise<void> | null | void;
+  /**
+   * A callback function returned by effect. Will be called when effect is stale.
+   *
+   * @param update - `true` if update is pending, `false` effect has been cancelled, `null` if state is destroyed.
+   */
+  type EffectCallback = (update: boolean | null) => void;
 }
 interface State {
-    /**
-     * Loopback to instance of this state. This is useful when in a subscribed context,
-     * to keep write access to `this` after a destructure. You can use it to read variables silently as well.
-     **/
-    is: this;
+  /**
+   * Loopback to instance of this state. This is useful when in a subscribed context,
+   * to keep write access to `this` after a destructure. You can use it to read variables silently as well.
+   **/
+  is: this;
 }
 declare abstract class State implements Observable {
-    constructor(...args: State.Args);
-    [Observable](callback: Observable.Callback, required?: boolean): this;
-    /**
-     * Pull current values from state. Flattens all states and exotic values recursively.
-     *
-     * @returns Object with all values from this state.
-     **/
-    get(): State.Values<this>;
-    /**
-     * Run a function which will run automatically when accessed values change.
-     *
-     * @param effect Function to run, and again whenever accessed values change.
-     *               If effect returns a function, it will be called when a change occurs (syncronously),
-     *               effect is cancelled, or parent state is destroyed.
-     * @returns Function to cancel listener.
-     */
-    get(effect: State.Effect<this>): () => void;
-    /**
-     * Get value of a property.
-     *
-     * @param key - Property to get value of.
-     * @param required - If true, will throw an error if property is not available.
-     * @returns Value of property.
-     */
-    get<T extends State.Event<this>>(key: T, required?: boolean): State.Value<this, T>;
-    /**
-     * Run a function when a property is updated.
-     *
-     * @param key - Property to watch for updates.
-     * @param callback - Function to call when property is updated.
-     * @returns Function to cancel listener.
-     */
-    get<T extends State.Event<this>>(key: T, callback: State.OnUpdate<this, T>): () => void;
-    /**
-     * Check if state is expired.
-     *
-     * @param status - `null` to check if state is expired.
-     * @returns `true` if state is expired, `false` otherwise.
-     */
-    get(status: null): boolean;
-    /**
-     * Callback when state is to be destroyed.
-     *
-     * @param callback - Function to call when state is destroyed.
-     * @returns Function to cancel listener.
-     */
-    get(status: null, callback: () => void): () => void;
-    /**
-     * Get update in progress.
-     *
-     * @returns Promise which resolves object with updated values, `undefined` if there no update is pending.
-     **/
-    set(): PromiseLike<State.Event<this>[]> | undefined;
-    /**
-     * Update mulitple properties at once. Merges argument with current state.
-     * Properties which are not managed by this state will be ignored.
-     *
-     * @param assign - Object with properties to update.
-     * @param silent - If an update does occur, listeners will not be refreshed automatically.
-     * @returns Promise resolving an array of keys updated, `undefined` (immediately) if a noop.
-     */
-    set(assign?: State.Assign<this>, silent?: boolean): PromiseLike<State.Event<this>[]> | undefined;
-    /**
-     * Push an update. This will not change the value of associated property.
-     *
-     * Useful where a property value internally has changed, but the object is the same.
-     * For example: An array has pushed a new value, or a nested property is updated.
-     *
-     * You can also use this to dispatch arbitrary events.
-     * Symbols are recommended as non-property events, however you can use any string.
-     * If doing so, be sure to avoid collisions with property names! An easy way to do this is
-     * to prefix an event with "!" and/or use dash-case. e.g. `set("!event")` or `set("my-event")`.
-     *
-     * @param key - Property or event to dispatch.
-     * @returns Promise resolves an array of keys updated.
-     */
-    set(key: State.Event<this>): PromiseLike<State.Event<this>[]>;
-    /**
-     * Set a value for a property. This will update the value and notify listeners.
-     *
-     * **Use with caution!** Key nor value are checked for validity.
-     *
-     * This is meant for assigning values programmatically,
-     * where simple assignment is not practicable.
-     *
-     * For example: `(this as any)[myProperty] = value;`
-     *
-     * @param key - Property to set value for.
-     * @param value - Value to set for property.
-     * @param init - If true, state will begin to manage the property if it is not already.
-     * @returns Promise resolves an array of keys updated.
-     */
-    set(key: State.Event<this>, value: unknown, init?: boolean): PromiseLike<State.Event<this>[]>;
-    /**
-     * Call a function when update occurs.
-     *
-     * Given function is called for every assignment (which changes value) or explicit `set`.
-     *
-     * To run logic on final value only, callback may return a function. Using the same
-     * function for one or more events will ensure it is called only when events are settled.
-     *
-     * @param callback - Function to call when update occurs.
-     * @returns Function to remove listener. Will return `true` if removed, `false` if inactive already.
-     *
-     */
-    set(callback: State.OnEvent<this>): () => boolean;
-    /**
-     * Call a function when a property is updated.
-     * Unlike `get`, this calls synchronously and will fire as many times as the property is updated.
-     *
-     * @param callback - Function to call when property is updated.
-     * @param event - Property to watch for updates.
-     */
-    set(callback: State.OnEvent<this>, event: State.Event<this> | null): () => boolean;
-    /**
-     * Declare an end to updates. This event is final and will freeze state.
-     * This event can be watched for as well, to run cleanup logic and internally will remove all listeners.
-     *
-     * @param status - `null` to end updates.
-     */
-    set(status: null): void;
-    /**
-     * Iterate over managed properties in this instance of State.
-     * Yeilds the key and current value for each property.
-     */
-    [Symbol.iterator](): Iterator<[string, unknown]>;
-    /**
-     * Create and activate a new instance of this state.
-     *
-     * **Important** - Unlike `new this(...)` - this method also activates state.
-     *
-     * @param args - arguments sent to constructor
-     */
-    static new<T extends State>(this: State.New<T>, ...args: State.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 State.Extends>(this: T, maybe: unknown): maybe is T;
-    /**
-     * Register a callback to run when any instance of this State is updated.
-     */
-    static on<T extends State>(this: State.Extends<T>, listener: State.OnEvent<T>): () => boolean;
+  constructor(...args: State.Args);
+  [Observable](callback: Observable.Callback, required?: boolean): this;
+  /**
+   * Optional lifecycle hook called during State initialization.
+   * Can return a cleanup function to run when state is destroyed.
+   */
+  protected new?(): void | (() => void);
+  /**
+   * Pull current values from state. Flattens all states and exotic values recursively.
+   *
+   * @returns Object with all values from this state.
+   **/
+  get(): State.Values<this>;
+  /**
+   * Run a function which will run automatically when accessed values change.
+   *
+   * @param effect Function to run, and again whenever accessed values change.
+   *               If effect returns a function, it will be called when a change occurs (syncronously),
+   *               effect is cancelled, or parent state is destroyed.
+   * @returns Function to cancel listener.
+   */
+  get(effect: State.Effect<this>): () => void;
+  /**
+   * Get value of a property.
+   *
+   * @param key - Property to get value of.
+   * @param required - If true, will throw an error if property is not available.
+   * @returns Value of property.
+   */
+  get<T extends State.Event<this>>(key: T, required?: boolean): State.Value<this, T>;
+  /**
+   * Run a function when a property is updated.
+   *
+   * @param key - Property to watch for updates.
+   * @param callback - Function to call when property is updated.
+   * @returns Function to cancel listener.
+   */
+  get<T extends State.Event<this>>(key: T, callback: State.OnUpdate<this, T>): () => void;
+  /**
+   * Check if state is expired.
+   *
+   * @param status - `null` to check if state is expired.
+   * @returns `true` if state is expired, `false` otherwise.
+   */
+  get(status: null): boolean;
+  /**
+   * Callback when state is to be destroyed.
+   *
+   * @param callback - Function to call when state is destroyed.
+   * @returns Function to cancel listener.
+   */
+  get(status: null, callback: () => void): () => void;
+  /**
+   * Get update in progress.
+   *
+   * @returns Promise which resolves object with updated values, `undefined` if there no update is pending.
+   **/
+  set(): PromiseLike<State.Event<this>[]> | undefined;
+  /**
+   * Update mulitple properties at once. Merges argument with current state.
+   * Properties which are not managed by this state will be ignored.
+   *
+   * @param assign - Object with properties to update.
+   * @param silent - If an update does occur, listeners will not be refreshed automatically.
+   * @returns Promise resolving an array of keys updated, `undefined` (immediately) if a noop.
+   */
+  set(assign?: State.Assign<this>, silent?: boolean): PromiseLike<State.Event<this>[]> | undefined;
+  /**
+   * Push an update. This will not change the value of associated property.
+   *
+   * Useful where a property value internally has changed, but the object is the same.
+   * For example: An array has pushed a new value, or a nested property is updated.
+   *
+   * You can also use this to dispatch arbitrary events.
+   * Symbols are recommended as non-property events, however you can use any string.
+   * If doing so, be sure to avoid collisions with property names! An easy way to do this is
+   * to prefix an event with "!" and/or use dash-case. e.g. `set("!event")` or `set("my-event")`.
+   *
+   * @param key - Property or event to dispatch.
+   * @returns Promise resolves an array of keys updated.
+   */
+  set(key: State.Event<this>): PromiseLike<State.Event<this>[]>;
+  /**
+   * Set a value for a property. This will update the value and notify listeners.
+   *
+   * **Use with caution!** Key nor value are checked for validity.
+   *
+   * This is meant for assigning values programmatically,
+   * where simple assignment is not practicable.
+   *
+   * For example: `(this as any)[myProperty] = value;`
+   *
+   * @param key - Property to set value for.
+   * @param value - Value to set for property.
+   * @param init - If true, state will begin to manage the property if it is not already.
+   * @returns Promise resolves an array of keys updated.
+   */
+  set(key: State.Event<this>, value: unknown, init?: boolean): PromiseLike<State.Event<this>[]>;
+  /**
+   * Call a function when update occurs.
+   *
+   * Given function is called for every assignment (which changes value) or explicit `set`.
+   *
+   * To run logic on final value only, callback may return a function. Using the same
+   * function for one or more events will ensure it is called only when events are settled.
+   *
+   * @param callback - Function to call when update occurs.
+   * @returns Function to remove listener. Will return `true` if removed, `false` if inactive already.
+   *
+   */
+  set(callback: State.OnEvent<this>): () => boolean;
+  /**
+   * Call a function when a property is updated.
+   * Unlike `get`, this calls synchronously and will fire as many times as the property is updated.
+   *
+   * @param callback - Function to call when property is updated.
+   * @param event - Property to watch for updates.
+   */
+  set(callback: State.OnEvent<this>, event: State.Event<this> | null): () => boolean;
+  /**
+   * Declare an end to updates. This event is final and will freeze state.
+   * This event can be watched for as well, to run cleanup logic and internally will remove all listeners.
+   *
+   * @param status - `null` to end updates.
+   */
+  set(status: null): void;
+  /**
+   * Iterate over managed properties in this instance of State.
+   * Yeilds the key and current value for each property.
+   */
+  [Symbol.iterator](): Iterator<[string, unknown]>;
+  /**
+   * Create and activate a new instance of this state.
+   *
+   * **Important** - Unlike `new this(...)` - this method also activates state.
+   *
+   * @param args - arguments sent to constructor
+   */
+  static new<T extends State>(this: State.Type<T>, ...args: State.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 State.Extends>(this: T, maybe: unknown): maybe is T;
+  /**
+   * Register a callback to run when any instance of this State is updated.
+   */
+  static on<T extends State>(this: State.Extends<T>, listener: State.OnEvent<T>): () => boolean;
 }
-
+//#endregion
+//#region src/instruction/use.d.ts
 /**
  * Property initializer, will run upon instance creation.
  * Optional returned callback will run when once upon first access.
  */
 type Instruction<T = any, M extends State = any> = (this: M, key: Extract<State.Field<M>, string>, thisArg: M, state: State.Values<M>) => Instruction.Descriptor<T> | ((source: M) => T) | void;
 declare namespace Instruction {
-    type Getter<T> = (source: State) => T;
-    type Descriptor<T = any> = {
-        get?: Getter<T> | boolean;
-        set?: State.Setter<T> | boolean;
-        enumerable?: boolean;
-        value?: T;
-    };
+  type Getter<T> = (source: State) => T;
+  type Descriptor<T = any> = {
+    get?: Getter<T> | boolean;
+    set?: State.Setter<T> | boolean;
+    enumerable?: boolean;
+    value?: T;
+  };
 }
 declare function use<T>(instruction: Instruction<T>): T extends void ? unknown : T;
-declare function use<T extends State>(Type: State.New<T>, required: false): T | undefined;
-declare function use<T extends State>(Type: State.New<T>, ready?: (i: T) => void): T;
-
+declare function use<T extends State>(Type: State.Type<T>, required: false): T | undefined;
+declare function use<T extends State>(Type: State.Type<T>, ready?: (i: T) => void): T;
+//#endregion
+//#region src/instruction/get.d.ts
 declare namespace get {
-    type Callback<T = any> = (state: T, subject: State) => void | boolean | (() => void);
+  type Callback<T = any> = (state: T, subject: State) => void | boolean | (() => void);
 }
 /**
  * Fetches upstream State from context with optional lifecycle callback.
@@ -317,11 +307,12 @@ declare function get<T extends State>(Type: State.Extends<T>, required: false):
  * @param callback - Optional lifecycle callback, receives (state, subject). May return false to prevent registration.
  */
 declare function get<T extends State>(Type: State.Extends<T>, downstream: true, callback?: get.Callback<T>): readonly T[];
-
+//#endregion
+//#region src/instruction/set.d.ts
 declare namespace set {
-    type Callback<T, S = any> = (this: S, next: T, previous: T) => ((next: T) => void) | Promise<any> | void | boolean;
-    type Compute<T, S = any> = (on: S, key: string) => T;
-    type Factory<T, S = any> = (this: S, key: string) => Promise<T> | T;
+  type Callback<T, S = any> = (this: S, next: T, previous: T) => ((next: T) => void) | Promise<any> | void | boolean;
+  type Compute<T, S = any> = (on: S, key: string) => T;
+  type Factory<T, S = any> = (this: S, key: string) => Promise<T> | T;
 }
 /**
  * Set property as `undefined` but required.
@@ -381,38 +372,35 @@ declare function set<R, T = any>(reactiveToThis: true, method: set.Compute<R, T>
  * @param compute - Compute function. Bound to a subscriber-proxy of source, returns output value. Will update automatically as input values change.
  */
 declare function set<R, T extends State>(reactiveTo: T, compute: set.Compute<R, T>): R;
-
+//#endregion
+//#region src/instruction/ref.d.ts
 declare namespace ref {
-    type Callback<T> = (argument: T) => ((next: T | null) => void) | Promise<void> | void | boolean;
-    interface Object<T = any> {
-        /** Current value held by this reference. */
-        current: T;
-        /** State instance this reference belongs to. */
-        is: State;
-        /** Key of property on state this reference belongs to. */
-        key: string;
-        /**
-         * Subscribe to changes of this reference.
-         *
-         * @param callback - Callback to invoke with the current value when it changes.
-         * @returns Unsubscribe function to stop listening to changes.
-         */
-        get(callback: (value: T) => void): () => void;
-        /** Retrieve current value. */
-        get(): T | null;
-    }
-    /** Object with references to all managed values of `T`. */
-    /** Object with references to all managed values of `T`. */
-    type Proxy<T extends State> = {
-        [P in State.Field<T>]-?: Object<T[P]>;
-    } & {
-        get(): T;
-    };
-    type CustomProxy<T extends State, R> = {
-        [P in State.Field<T>]-?: R;
-    } & {
-        get(): T;
-    };
+  type Callback<T> = (argument: T) => ((next: T | null) => void) | Promise<void> | void | boolean;
+  interface Object<T = any> {
+    /** Current value held by this reference. */
+    current: T;
+    /** State instance this reference belongs to. */
+    is: State;
+    /** Key of property on state this reference belongs to. */
+    key: string;
+    /**
+     * Subscribe to changes of this reference.
+     *
+     * @param callback - Callback to invoke with the current value when it changes.
+     * @returns Unsubscribe function to stop listening to changes.
+     */
+    get(callback: (value: T) => void): () => void;
+    /** Retrieve current value. */
+    get(): T | null;
+  }
+  /** Object with references to all managed values of `T`. */
+  /** Object with references to all managed values of `T`. */
+  type Proxy<T extends State> = { [P in State.Field<T>]-?: Object<T[P]> } & {
+    get(): T;
+  };
+  type CustomProxy<T extends State, R> = { [P in State.Field<T>]-?: R } & {
+    get(): T;
+  };
 }
 /**
  * Creates an object with references to all managed values.
@@ -451,62 +439,64 @@ declare function ref<T>(callback?: ref.Callback<T>): ref.Object<T>;
  * @param ignoreNull - Default `true`. If `false`, will still callback with `null`.
  */
 declare function ref<T>(callback: ref.Callback<T | null>, ignoreNull: boolean): ref.Object<T>;
-
+//#endregion
+//#region src/context.d.ts
 declare namespace Context {
-    type Multiple<T extends State> = {
-        [key: string | number]: State.Class<T> | T;
-    };
-    type Accept<T extends State = State> = T | State.Class<T> | Multiple<T>;
-    type Expect<T extends State = State> = (state: T) => (() => void) | void;
+  type Multiple<T extends State> = {
+    [key: string | number]: State.Type<T> | T;
+  };
+  type Accept<T extends State = State> = T | State.Type<T> | Multiple<T>;
+  type Expect<T extends State = State> = (state: T) => (() => void) | void;
 }
 interface Context {
-    [key: symbol]: State | Context.Expect | null | undefined;
+  [key: symbol]: State | Context.Expect | null | undefined;
 }
 declare class Context {
-    /**
-     * Get the context for a specified State. If a callback is provided, it will be run when
-     * the context becomes available.
-     */
-    static get<T extends State>(on: State, callback: (got: Context) => void): void;
-    /**
-     * Get the context for a specified State. Returns undefined if none are found.
-     */
-    static get<T extends State>(on: State): Context | undefined;
-    id: string;
-    protected inputs: Record<string | number, State | State.Extends>;
-    protected cleanup: Set<() => void>;
-    constructor(inputs?: Context.Accept);
-    /** Find specified type registered to a parent context. Throws if none are found. */
-    get<T extends State>(Type: State.Extends<T>, require: true): T;
-    /** Find specified type registered to a parent context. Returns undefined if none are found. */
-    get<T extends State>(Type: State.Extends<T>, require?: boolean): T | undefined;
-    /** Run callback when a specified type is registered in context downstream. */
-    get<T extends State>(Type: State.Extends<T>, callback: (state: T) => void): () => void;
-    /**
-     * Adds a State to this context.
-     */
-    protected add<T extends State>(input: T | State.Class<T>, implicit?: boolean): T;
-    /**
-     * Register one or more States to this context.
-     *
-     * Context will add or remove States as needed to keep with provided input.
-     *
-     * @param inputs State, State class, or map of States / State classes to register.
-     * @param forEach Optional callback to run for each State registered.
-     */
-    use<T extends State>(inputs: Context.Accept<T>, forEach?: Context.Expect<T>): void;
-    /**
-     * Create a child context, optionally registering one or more States to it.
-     *
-     * @param inputs State, State class, or map of States / State classes to register.
-     */
-    push(inputs?: Context.Accept): this;
-    /**
-     * Remove all States from this context.
-     *
-     * Will also run any cleanup callbacks registered when States were added.
-     */
-    pop(): void;
+  /**
+   * Get the context for a specified State. If a callback is provided, it will be run when
+   * the context becomes available.
+   */
+  static get<T extends State>(on: State, callback: (got: Context) => void): void;
+  /**
+   * Get the context for a specified State. Returns undefined if none are found.
+   */
+  static get<T extends State>(on: State): Context | undefined;
+  id: string;
+  protected inputs: Record<string | number, State | State.Extends>;
+  protected cleanup: Set<() => void>;
+  constructor(inputs?: Context.Accept);
+  /** Find specified type registered to a parent context. Throws if none are found. */
+  get<T extends State>(Type: State.Extends<T>, require: true): T;
+  /** Find specified type registered to a parent context. Returns undefined if none are found. */
+  get<T extends State>(Type: State.Extends<T>, require?: boolean): T | undefined;
+  /** Run callback when a specified type is registered in context downstream. */
+  get<T extends State>(Type: State.Extends<T>, callback: (state: T) => void): () => void;
+  /**
+   * Adds a State to this context.
+   */
+  protected add<T extends State>(input: T | State.Type<T>, implicit?: boolean): T;
+  /**
+   * Register one or more States to this context.
+   *
+   * Context will add or remove States as needed to keep with provided input.
+   *
+   * @param inputs State, State class, or map of States / State classes to register.
+   * @param forEach Optional callback to run for each State registered.
+   */
+  use<T extends State>(inputs: Context.Accept<T>, forEach?: Context.Expect<T>): void;
+  /**
+   * Create a child context, optionally registering one or more States to it.
+   *
+   * @param inputs State, State class, or map of States / State classes to register.
+   */
+  push(inputs?: Context.Accept): this;
+  /**
+   * Remove all States from this context.
+   *
+   * Will also run any cleanup callbacks registered when States were added.
+   */
+  pop(): void;
 }
-
-export { Context, Instruction, METHOD, Observable, State, addListener, State as default, event, get, ref, set, use, watch };
+//#endregion
+export { Context, type Instruction, METHOD, Observable, State, State as default, addListener, event, get, ref, set, use, watch };
+//# sourceMappingURL=index.d.ts.map