@expressive/mvc 0.73.0 → 0.78.0

package/dist/field/set.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"set.js","names":[],"sources":["../../src/field/set.ts"],"sourcesContent":["import { listener, capture } from '../observable';\nimport { access, event, State, update } from '../state';\nimport { def } from './def';\n\ndeclare namespace set {\n  type Callback<T, S = any> = (\n    this: S,\n    next: T,\n    previous: T\n  ) => ((next: T) => void) | Promise<any> | void | boolean;\n\n  type Factory<T, S = any> = (this: S, property: string) => Promise<T> | T;\n}\n\n/**\n * Set a property as a placeholder, initially `undefined` but required.\n *\n * Property cannot be accessed until it is defined. If accessed while undefined, a hybrid\n * `Promise`/`Error` (aka: [Suspense](https://reactjs.org/docs/concurrent-mode-suspense.html)) will be thrown.\n *\n * Non-enumerable; writable only if `onUpdate` callback is provided.\n *\n * @param value - Starting value (undefined for suspense placeholder).\n * @param onUpdate - Callback run when property is set.\n */\nfunction set<T>(value?: undefined, onUpdate?: set.Callback<T>): T;\n\n/**\n * Set property with an async factory function.\n * If required is not defined, factory runs lazily on first access.\n * If async, or returns a promise, suspense is thrown upon access until resolved.\n *\n * Non-enumerable and read-only.\n *\n * @param factory - Zero-arg async callback to produce property value.\n * @param required - Pass `true` to run factory immediately and require value.\n */\nfunction set<T>(factory: () => T | Promise<T>, required?: true): T;\n\n/**\n * Set property with a lazy factory, no suspense.\n *\n * Non-enumerable and read-only.\n *\n * @param factory - Zero-arg callback to produce property value.\n * @param required - Pass `false` to allow undefined while pending.\n */\nfunction set<T>(\n  factory: () => T | Promise<T>,\n  required: boolean\n): T | undefined;\n\n/**\n * Set property with a factory and update callback.\n *\n * Non-enumerable but writable via the callback.\n *\n * @param factory - Callback to produce initial value.\n * @param onUpdate - Callback run when property is updated.\n */\nfunction set<T>(factory: () => T | Promise<T>, onUpdate: set.Callback<T>): T;\n\n/**\n * Set a property with a non-function, non-Promise value.\n *\n * Non-enumerable but writable. Unlike plain assignment (`= value`), this\n * property is excluded from snapshots and `ref(this)`.\n *\n * @param value - Starting value for property.\n * @param onUpdate - Optional callback run when property is set.\n */\n// TODO: if onUpdate is not defined, should this have behavior unique to simple assignment?\n// I'm thinking default behavior should be to assign value directly to property, without triggering any additional updates.\n// All this requires is a default callback which throws true, silent updates are already implemented.\nfunction set<T>(\n  value: T extends Promise<any> ? never : T,\n  onUpdate?: set.Callback<T>\n): T;\n\nfunction set<T = any>(value?: unknown, argument?: unknown): any {\n  return def<T>((key, subject) => {\n    if (value instanceof Promise)\n      throw new TypeError(\n        `Direct promises are not supported in set(${subject}.${key}). Use set(() => promise) instead.`\n      );\n\n    const config: State.Apply = {\n      enumerable: false,\n      set: false\n    };\n\n    let computed = false;\n\n    // One-shot factory\n    if (typeof value == 'function') {\n      const factory = value.bind(subject, key)\n      computed = true;\n\n      function init() {\n        let output: unknown;\n\n        try {\n          output = attempt(factory);\n        } catch (err) {\n          console.warn(\n            `Generating initial value for ${subject}.${key} failed.`\n          );\n          throw err;\n        }\n\n        config.get = argument !== false;\n\n        function assign(next: any, silent?: boolean) {\n          if (typeof argument == 'function') subject[key] = next;\n          else update(subject, key, next, silent);\n        }\n\n        if (output instanceof Promise)\n          output.then(assign, (error) => {\n            event(subject, key);\n            config.get = () => {\n              throw error;\n            };\n          });\n        else assign(output, true);\n\n        if (argument) return null;\n\n        if (output instanceof Promise && argument !== false)\n          return access(subject, key, true);\n\n        return subject[key];\n      }\n\n      if (argument) {\n        listener(subject, () => {\n          init();\n          return null;\n        });\n      } else {\n        config.get = init;\n      }\n    } else if (value !== undefined) {\n      config.value = value;\n    }\n\n    if (typeof argument == 'function') {\n      let unset: ((next: T) => void) | undefined;\n\n      config.set = function (this: any, value: any, previous: any) {\n        capture((release) => {\n          const returns = argument.call(this, value, previous);\n\n          if (unset) unset(value);\n\n          unset = (next: T) => {\n            if (typeof returns == 'function') returns(next);\n            release();\n          };\n        });\n      };\n    } else if (!computed)\n      config.set = () => {\n        config.get = undefined;\n        config.set = undefined;\n      };\n\n    return config;\n  });\n}\n\nfunction attempt(fn: () => any): any {\n  function retry(err: unknown) {\n    if (err instanceof Promise) return err.then(compute);\n    else throw err;\n  }\n\n  function compute(): any {\n    try {\n      const output = fn();\n\n      return output instanceof Promise ? output.catch(retry) : output;\n    } catch (err) {\n      return retry(err);\n    }\n  }\n\n  return compute();\n}\n\nexport { set };\n"],"mappings":";;;;;AA+EA,SAAS,IAAa,OAAiB,UAAyB;AAC9D,QAAO,KAAQ,KAAK,YAAY;AAC9B,MAAI,iBAAiB,QACnB,OAAM,IAAI,UACR,4CAA4C,QAAQ,GAAG,IAAI,oCAC5D;EAEH,MAAM,SAAsB;GAC1B,YAAY;GACZ,KAAK;GACN;EAED,IAAI,WAAW;AAGf,MAAI,OAAO,SAAS,YAAY;GAC9B,MAAM,UAAU,MAAM,KAAK,SAAS,IAAI;AACxC,cAAW;GAEX,SAAS,OAAO;IACd,IAAI;AAEJ,QAAI;AACF,cAAS,QAAQ,QAAQ;aAClB,KAAK;AACZ,aAAQ,KACN,gCAAgC,QAAQ,GAAG,IAAI,UAChD;AACD,WAAM;;AAGR,WAAO,MAAM,aAAa;IAE1B,SAAS,OAAO,MAAW,QAAkB;AAC3C,SAAI,OAAO,YAAY,WAAY,SAAQ,OAAO;SAC7C,QAAO,SAAS,KAAK,MAAM,OAAO;;AAGzC,QAAI,kBAAkB,QACpB,QAAO,KAAK,SAAS,UAAU;AAC7B,WAAM,SAAS,IAAI;AACnB,YAAO,YAAY;AACjB,YAAM;;MAER;QACC,QAAO,QAAQ,KAAK;AAEzB,QAAI,SAAU,QAAO;AAErB,QAAI,kBAAkB,WAAW,aAAa,MAC5C,QAAO,OAAO,SAAS,KAAK,KAAK;AAEnC,WAAO,QAAQ;;AAGjB,OAAI,SACF,UAAS,eAAe;AACtB,UAAM;AACN,WAAO;KACP;OAEF,QAAO,MAAM;aAEN,UAAU,OACnB,QAAO,QAAQ;AAGjB,MAAI,OAAO,YAAY,YAAY;GACjC,IAAI;AAEJ,UAAO,MAAM,SAAqB,OAAY,UAAe;AAC3D,aAAS,YAAY;KACnB,MAAM,UAAU,SAAS,KAAK,MAAM,OAAO,SAAS;AAEpD,SAAI,MAAO,OAAM,MAAM;AAEvB,cAAS,SAAY;AACnB,UAAI,OAAO,WAAW,WAAY,SAAQ,KAAK;AAC/C,eAAS;;MAEX;;aAEK,CAAC,SACV,QAAO,YAAY;AACjB,UAAO,MAAM;AACb,UAAO,MAAM;;AAGjB,SAAO;GACP;;AAGJ,SAAS,QAAQ,IAAoB;CACnC,SAAS,MAAM,KAAc;AAC3B,MAAI,eAAe,QAAS,QAAO,IAAI,KAAK,QAAQ;MAC/C,OAAM;;CAGb,SAAS,UAAe;AACtB,MAAI;GACF,MAAM,SAAS,IAAI;AAEnB,UAAO,kBAAkB,UAAU,OAAO,MAAM,MAAM,GAAG;WAClD,KAAK;AACZ,UAAO,MAAM,IAAI;;;AAIrB,QAAO,SAAS"}

package/dist/index.d.ts

@@ -1,502 +1,10 @@
-//#region src/observable.d.ts
-/**
- * Update callback function.
- *
- * @param key -
- *   - `string` - property which has updated.
- *   - `false` - a normal update has completed.
- *   - `true` - initial event; instance is ready.
- *   - `null` - terminal event; instance is expired.
- * @param source - Instance of State for which update has occured.
- */
-type Notify<T extends Observable = any> = (this: T, key: Event, source: T) => (() => void) | null | void;
-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;
-};
-declare namespace Observable {
-  type Callback = () => void | PromiseLite;
-}
-interface Observable {
-  [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;
-/**
- * Create a side-effect which will update whenever values accessed change.
- * Callback is called immediately and whenever values are stale.
- *
- * @param target - Instance of State 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 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 {
-  /** 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;
-}
-declare abstract class State implements Observable {
-  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;
-  };
-}
-declare function use<T>(instruction: Instruction<T>): T extends void ? unknown : 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);
-}
-/**
- * Fetches upstream State from context with optional lifecycle callback.
- * Callback runs on mount and can return cleanup function for unmount.
- *
- * @param Type - Type of State to fetch.
- * @param callback - Optional lifecycle callback, receives (state, subject). Can return cleanup function.
- */
-declare function get<T extends State>(Type: State.Extends<T>, callback?: get.Callback<T>): T;
-/**
- * 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 - If false, property may be undefined. Otherwise will throw suspense.
- */
-declare function get<T extends State>(Type: State.Extends<T>, required: false): T | undefined;
-/**
- * Collects downstream States, this will accumulate all instances of specified type for which this is an ancestor.
- * Returns a frozen array that updates as States are added or removed.
- * Callback runs on each State registration and can return cleanup or false to prevent registration.
- *
- * @param Type - Type of State to collect.
- * @param downstream - Must be true to enable downstream mode.
- * @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;
-}
-/**
- * Set property as `undefined` but required.
- *
- * Property cannot be accessed until it is defined. If accessed while undefined, a hybrid
- * `Promise`/`Error` (aka: [Suspense](https://reactjs.org/docs/concurrent-mode-suspense.html)) will be thrown.
- */
-declare function set<T = any>(): T;
-/**
- * Set property with a factory function.
- *
- * **Note** Factory is lazy! It will only run if/when property is accessed.
- * Value will be undefined until factory resolves, which will also dispatch an update for the property.
- */
-declare function set<T>(factory: set.Factory<T>, required: false): T | undefined;
-/**
- * Set property with a factory function.
- *
- * If async, property cannot be accessed until resolves, yeilding a result.
- * If accessed while still processing, React Suspense will be thrown.
- *
- * @param factory - Callback run to derrive property value.
- * @param required - If true run factory immediately on creation, otherwise on access.
- */
-declare function set<T>(factory: set.Factory<T>, required?: boolean): T;
-/**
- * Set property with a factory function.
- *
- * If async, property cannot be accessed until resolves, yeilding a result.
- * If accessed while still processing, React Suspense will be thrown.
- *
- * @param factory - Callback run to derrive property value.
- * @param onUpdate - Callback run when property is finished computing or is set.
- */
-declare function set<T>(factory: set.Factory<T>, onUpdate?: set.Callback<T>): T;
-/**
- * Set a property with empty placeholder and/or update callback.
- *
- * @param value - Starting value for property. If undefined, suspense will be thrown on access, until value is set and accepted by callback.
- * @param onUpdate - Callback run when property is set. If returns false, update is not accepted and property will keep previous value.
- */
-declare function set<T>(value: T | undefined, onUpdate?: set.Callback<T>): T;
-/**
- * Implement a reactive computed value using a method reference.
- *
- * The method will automatically re-run when any accessed properties change.
- * Use `true` to indicate reactive mode with implicit `this` as the source.
- *
- * @param reactiveToThis - Pass `true` to enable reactive mode with implicit this
- * @param method - Method reference or compute function to use
- */
-declare function set<R, T = any>(reactiveToThis: true, method: set.Compute<R, T> | Function): R;
-/**
- * Implement a computed value; output will be generated by provided function.
- *
- * @param reactiveTo - Source state 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 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;
-  };
-}
-/**
- * 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 state from which to reference values.
- */
-declare function ref<T extends State>(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 state from which to reference values.
- * @param mapper - Function producing the placeholder value for any given property.
- */
-declare function ref<O extends State, R>(target: O, mapper: (key: State.Field<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>(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>(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.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;
-}
-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.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;
-}
-//#endregion
-export { Context, type Instruction, METHOD, Observable, State, State as default, addListener, event, get, ref, set, use, watch };
-//# sourceMappingURL=index.d.ts.map
+import { Context } from "./context.js";
+import { Observer, event, listener, observer, touch, watch } from "./observable.js";
+import { State, unbind } from "./state.js";
+import { Component } from "./component.js";
+import { def } from "./field/def.js";
+import { get } from "./field/get.js";
+import { hot } from "./field/hot.js";
+import { ref } from "./field/ref.js";
+import { set } from "./field/set.js";
+export { Component, Context, Observer, State, def, State as default, event, get, hot, listener, observer, ref, set, touch, unbind, watch };