@expressive/mvc 0.72.0 → 0.73.0

package/dist/esm/observable.js

@@ -0,0 +1,121 @@
+//#region src/observable.ts
+const Observable = Symbol("observe");
+/** Placeholder event determines if state is initialized or not. */
+const onReady = () => null;
+const LISTENERS = /* @__PURE__ */ new WeakMap();
+/** Events pending for a given object. */
+const PENDING = /* @__PURE__ */ new WeakMap();
+/** Update register. */
+const PENDING_KEYS = /* @__PURE__ */ new WeakMap();
+/** Central event dispatch. Bunches all updates to occur at same time. */
+const DISPATCH = /* @__PURE__ */ new Set();
+function addListener(subject, callback, select) {
+	let listeners = LISTENERS.get(subject);
+	if (!listeners) LISTENERS.set(subject, listeners = new Map([[onReady, void 0]]));
+	if (select !== void 0 && !(select instanceof Set)) select = new Set([select]);
+	if (!listeners.has(onReady) && !select) callback.call(subject, true, subject);
+	listeners.set(callback, select);
+	return () => listeners.delete(callback);
+}
+function emit(state, key) {
+	const listeners = LISTENERS.get(state);
+	const notReady = listeners.has(onReady);
+	if (key === true && !notReady) return;
+	let pending = PENDING.get(state);
+	if (pending) {
+		pending.add(key);
+		return;
+	}
+	PENDING.set(state, pending = new Set(notReady ? [true, key] : [key]));
+	for (const key of pending) for (const [callback, filter] of listeners) if (!filter || filter.has(key)) {
+		const after = callback.call(state, key, state);
+		if (after) enqueue(after);
+		else if (after === null) listeners.delete(callback);
+	}
+	if (key === null) listeners.clear();
+	PENDING.delete(state);
+}
+function event(subject, key, silent) {
+	if (key === null) return emit(subject, key);
+	if (!key) return emit(subject, true);
+	let pending = PENDING_KEYS.get(subject);
+	if (!pending) {
+		PENDING_KEYS.set(subject, pending = /* @__PURE__ */ new Set());
+		if (!silent) enqueue(() => {
+			emit(subject, false);
+			PENDING_KEYS.delete(subject);
+		});
+	}
+	pending.add(key);
+	if (!silent) emit(subject, key);
+}
+function enqueue(eventHandler) {
+	if (!DISPATCH.size) setTimeout(() => {
+		DISPATCH.forEach((event) => {
+			try {
+				event();
+			} catch (err) {
+				console.error(err);
+			}
+		});
+		DISPATCH.clear();
+	}, 0);
+	DISPATCH.add(eventHandler);
+}
+function watch(target, callback, argument) {
+	let unset;
+	let reset;
+	function invoke() {
+		let ignore = true;
+		function onUpdate() {
+			if (ignore || reset === null) return;
+			ignore = true;
+			if (reset && unset) {
+				unset(true);
+				unset = void 0;
+			}
+			enqueue(invoke);
+			return { then: enqueue };
+		}
+		try {
+			const exit = argument === false ? void 0 : scope();
+			const output = callback(target[Observable](onUpdate, argument === true));
+			const flush = exit ? exit() : () => {};
+			ignore = false;
+			reset = output === null ? null : invoke;
+			unset = (key) => {
+				if (typeof output == "function") output(key);
+				flush();
+			};
+		} catch (err) {
+			if (err instanceof Promise) {
+				reset = void 0;
+				err.then(invoke);
+			} else throw err;
+		}
+	}
+	function cleanup() {
+		if (unset) unset(false);
+		reset = null;
+	}
+	if (EffectContext && argument !== false) EffectContext.add(cleanup);
+	addListener(target, (key) => {
+		if (key === true) invoke();
+		else if (!reset) return reset;
+		if (key === null && unset) unset(null);
+	});
+	return cleanup;
+}
+let EffectContext;
+function scope() {
+	const last = EffectContext;
+	const context = EffectContext = /* @__PURE__ */ new Set();
+	return () => {
+		EffectContext = last;
+		return () => context.forEach((fn) => fn());
+	};
+}
+
+//#endregion
+export { Observable, PENDING_KEYS, addListener, event, scope, watch };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"observable.js","names":[],"sources":["../../src/observable.ts"],"sourcesContent":["/**\n * Update callback function.\n *\n * @param key -\n *   - `string` - property which has updated.\n *   - `false` - a normal update has completed.\n *   - `true` - initial event; instance is ready.\n *   - `null` - terminal event; instance is expired.\n * @param source - Instance of State for which update has occured.\n */\ntype Notify<T extends Observable = any> = (\n  this: T,\n  key: Event,\n  source: T\n) => (() => void) | null | void;\n\ntype Effect<T extends Observable> = (\n  proxy: T\n) => ((update: boolean | null) => void) | Promise<void> | null | void;\n\ntype Event = number | string | null | boolean | symbol;\n\ntype PromiseLite<T = void> = { then: (callback: () => T) => T };\n\ndeclare namespace Observable {\n  export type Callback = () => void | PromiseLite;\n}\n\ninterface Observable {\n  [Observable](callback: Observable.Callback, required?: boolean): this | void;\n}\n\nconst Observable = Symbol('observe');\n\n/** Placeholder event determines if state is initialized or not. */\nconst onReady = () => null;\n\nconst LISTENERS = new WeakMap<\n  Observable,\n  Map<Notify, Set<Event> | undefined>\n>();\n\n/** Events pending for a given object. */\nconst PENDING = new WeakMap<Observable, Set<Event>>();\n\n/** Update register. */\nconst PENDING_KEYS = new WeakMap<Observable, Set<string | number | symbol>>();\n\n/** Central event dispatch. Bunches all updates to occur at same time. */\nconst DISPATCH = new Set<() => void>();\n\nfunction addListener<T extends Observable>(\n  subject: T,\n  callback: Notify<T>,\n  select?: Event | Set<Event>\n) {\n  let listeners = LISTENERS.get(subject)!;\n\n  if (!listeners)\n    LISTENERS.set(subject, (listeners = new Map([[onReady, undefined]])));\n\n  if (select !== undefined && !(select instanceof Set))\n    select = new Set([select]);\n\n  if (!listeners.has(onReady) && !select) {\n    callback.call(subject, true, subject);\n  }\n\n  listeners.set(callback, select);\n\n  return () => listeners.delete(callback);\n}\n\nfunction emit(state: Observable, key: Event): void {\n  const listeners = LISTENERS.get(state)!;\n  const notReady = listeners.has(onReady);\n\n  if (key === true && !notReady) return;\n\n  let pending = PENDING.get(state);\n\n  if (pending) {\n    pending.add(key);\n    return;\n  }\n\n  PENDING.set(state, (pending = new Set(notReady ? [true, key] : [key])));\n\n  for (const key of pending)\n    for (const [callback, filter] of listeners)\n      if (!filter || filter.has(key)) {\n        const after = callback.call(state, key, state);\n\n        if (after) {\n          enqueue(after);\n        } else if (after === null) {\n          listeners.delete(callback);\n        }\n      }\n\n  if (key === null) listeners.clear();\n\n  PENDING.delete(state);\n}\n\nfunction event(\n  subject: Observable,\n  key?: string | number | symbol | null,\n  silent?: boolean\n) {\n  if (key === null) return emit(subject, key);\n\n  if (!key) return emit(subject, true);\n\n  let pending = PENDING_KEYS.get(subject);\n\n  if (!pending) {\n    PENDING_KEYS.set(subject, (pending = new Set()));\n\n    if (!silent)\n      enqueue(() => {\n        emit(subject, false);\n        PENDING_KEYS.delete(subject);\n      });\n  }\n\n  pending.add(key);\n\n  if (!silent) emit(subject, key);\n}\n\nfunction enqueue(eventHandler: () => void) {\n  if (!DISPATCH.size)\n    setTimeout(() => {\n      DISPATCH.forEach((event) => {\n        try {\n          event();\n        } catch (err) {\n          console.error(err);\n        }\n      });\n      DISPATCH.clear();\n    }, 0);\n\n  DISPATCH.add(eventHandler);\n}\n\n/**\n * Create a side-effect which will update whenever values accessed change.\n * Callback is called immediately and whenever values are stale.\n *\n * @param target - Instance of State to observe.\n * @param callback - Function to invoke when values change.\n * @param requireValues - If `true` will throw if accessing a value which is `undefined`.\n */\nfunction watch<T extends Observable>(\n  target: T,\n  callback: Effect<Required<T>>,\n  requireValues: true\n): () => void;\n\nfunction watch<T extends Observable>(\n  target: T,\n  callback: Effect<T>,\n  recursive?: boolean\n): () => void;\n\nfunction watch<T extends Observable>(\n  target: T,\n  callback: Effect<T>,\n  argument?: boolean\n) {\n  let unset: ((update: boolean | null) => void) | undefined;\n  let reset: (() => void) | null | undefined;\n\n  function invoke() {\n    let ignore: boolean = true;\n\n    function onUpdate(): void | PromiseLite<void> {\n      if (ignore || reset === null) return;\n\n      ignore = true;\n\n      if (reset && unset) {\n        unset(true);\n        unset = undefined;\n      }\n\n      enqueue(invoke);\n      return { then: enqueue };\n    }\n\n    try {\n      const exit = argument === false ? undefined : scope();\n      const output = callback(\n        target[Observable](onUpdate, argument === true) as T\n      );\n      const flush = exit ? exit() : () => {};\n\n      ignore = false;\n      reset = output === null ? null : invoke;\n      unset = (key) => {\n        if (typeof output == 'function') output(key);\n\n        flush();\n      };\n    } catch (err) {\n      if (err instanceof Promise) {\n        reset = undefined;\n        err.then(invoke);\n      } else {\n        throw err;\n      }\n    }\n  }\n\n  function cleanup() {\n    if (unset) unset(false);\n\n    reset = null;\n  }\n\n  if (EffectContext && argument !== false) EffectContext.add(cleanup);\n\n  addListener(target, (key) => {\n    if (key === true) invoke();\n    else if (!reset) return reset;\n\n    if (key === null && unset) unset(null);\n  });\n\n  return cleanup;\n}\n\nlet EffectContext: Set<() => void> | undefined;\n\nexport function scope() {\n  const last = EffectContext;\n  const context = (EffectContext = new Set());\n\n  return () => {\n    EffectContext = last;\n    return () => context.forEach((fn) => fn());\n  };\n}\n\nexport { addListener, watch, event, Notify, PENDING_KEYS, Observable };\n"],"mappings":"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"}

package/dist/esm/state.d.ts

@@ -0,0 +1,234 @@
+import { Observable, event } from "./observable.js";
+
+//#region src/state.d.ts
+/** Internal state assigned to states. */
+declare const STATE: WeakMap<State, Record<string | number | symbol, unknown>>;
+/** Parent-child relationships. */
+declare const PARENT: WeakMap<State, State | null>;
+/** 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;
+}
+declare function follow(from: State, key: string | number, value?: any): any;
+declare function access(subject: State, property: string, required?: boolean): any;
+declare function update<T>(subject: State, key: string | number | symbol, value: T, arg?: boolean | State.Setter<T>): boolean | undefined;
+/** Random alphanumberic of length 6; always starts with a letter. */
+declare function uid(): string;
+//#endregion
+export { METHOD, PARENT, STATE, State, access, event, follow, uid, update };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"state.d.ts","names":[],"sources":["../../src/state.d.ts"],"sourcesContent":["import { event, Observable } from './observable';\n/** Internal state assigned to states. */\ndeclare const STATE: WeakMap<State, Record<string | number | symbol, unknown>>;\n/** Parent-child relationships. */\ndeclare const PARENT: WeakMap<State, State | null>;\n/** Reference bound instance methods to real ones. */\ndeclare const METHOD: WeakMap<any, any>;\ndeclare namespace State {\n    /** Any type of State, using own class constructor as its identifier. */\n    type Extends<T extends State = State> = (abstract new (...args: any[]) => T) & typeof State;\n    /** A State constructor which may be instanciated. */\n    type Type<T extends State = State> = (new (...args: State.Args<T>) => T) & Omit<typeof State, never>;\n    /** State constructor arguments */\n    type Args<T extends State = any> = (Args<T> | Init<T> | Assign<T> | string | void)[];\n    /**\n     * State constructor callback - is called when State finishes intializing.\n     * Returned function will run when state is destroyed.\n     */\n    type Init<T extends State = State> = (this: T, thisArg: T) => Promise<void> | (() => void) | Args<T> | Assign<T> | void;\n    /** Object overlay to override values and methods on a state. */\n    type Assign<T> = Record<string, unknown> & {\n        [K in Field<T>]?: T[K] extends (...args: infer A) => infer R ? (this: T, ...args: A) => R : T[K];\n    };\n    /** Subset of `keyof T` which are not methods or defined by base State U. **/\n    type Field<T> = Exclude<keyof T, keyof State>;\n    /** Any valid key for state, including but not limited to Field<T>. */\n    type Event<T> = Field<T> | number | symbol | (string & {});\n    /** Export/Import compatible value for a given property in a State. */\n    type Export<R> = R extends {\n        get(): infer T;\n    } ? T : R;\n    /** Value for a property managed by a state. */\n    type Value<T extends State, K extends State.Event<T>> = K extends keyof T ? Export<T[K]> : unknown;\n    type Setter<T> = (value: T, previous: T) => boolean | void | (() => T);\n    type OnEvent<T extends State> = (this: T, key: unknown, source: T) => void | (() => void) | null;\n    type OnUpdate<T extends State, K extends State.Event<T>> = (this: T, key: K, thisArg: K) => void;\n    /**\n     * Values from current state of given state.\n     * Differs from `Values` as values here will drill\n     * into \"real\" values held by exotics like ref.Object.\n     */\n    type Values<T> = {\n        [P in Field<T>]: Export<T[P]>;\n    };\n    /** Object comperable to data found in T. */\n    type Partial<T> = {\n        [P in Field<T>]?: Export<T[P]>;\n    };\n    /** Exotic value, where actual value is contained within. */\n    type Ref<T = any> = {\n        (next: T): void;\n        current: T | null;\n    };\n    /**\n     * A callback function which is subscribed to parent and updates when accessed properties change.\n     *\n     * @param current - Current state of this state. This is a proxy which detects properties which\n     * where accessed, and thus depended upon to stay current.\n     *\n     * @param update - Set of properties which have changed, and events fired, since last update.\n     *\n     * @returns A callback function which will be called when this effect is stale.\n     */\n    type Effect<T> = (this: T, current: T, update: Set<State.Event<T>>) => EffectCallback | Promise<void> | null | void;\n    /**\n     * A callback function returned by effect. Will be called when effect is stale.\n     *\n     * @param update - `true` if update is pending, `false` effect has been cancelled, `null` if state is destroyed.\n     */\n    type EffectCallback = (update: boolean | null) => void;\n}\ninterface State {\n    /**\n     * Loopback to instance of this state. This is useful when in a subscribed context,\n     * to keep write access to `this` after a destructure. You can use it to read variables silently as well.\n     **/\n    is: this;\n}\ndeclare abstract class State implements Observable {\n    constructor(...args: State.Args);\n    [Observable](callback: Observable.Callback, required?: boolean): this;\n    /**\n     * Optional lifecycle hook called during State initialization.\n     * Can return a cleanup function to run when state is destroyed.\n     */\n    protected new?(): void | (() => void);\n    /**\n     * Pull current values from state. Flattens all states and exotic values recursively.\n     *\n     * @returns Object with all values from this state.\n     **/\n    get(): State.Values<this>;\n    /**\n     * Run a function which will run automatically when accessed values change.\n     *\n     * @param effect Function to run, and again whenever accessed values change.\n     *               If effect returns a function, it will be called when a change occurs (syncronously),\n     *               effect is cancelled, or parent state is destroyed.\n     * @returns Function to cancel listener.\n     */\n    get(effect: State.Effect<this>): () => void;\n    /**\n     * Get value of a property.\n     *\n     * @param key - Property to get value of.\n     * @param required - If true, will throw an error if property is not available.\n     * @returns Value of property.\n     */\n    get<T extends State.Event<this>>(key: T, required?: boolean): State.Value<this, T>;\n    /**\n     * Run a function when a property is updated.\n     *\n     * @param key - Property to watch for updates.\n     * @param callback - Function to call when property is updated.\n     * @returns Function to cancel listener.\n     */\n    get<T extends State.Event<this>>(key: T, callback: State.OnUpdate<this, T>): () => void;\n    /**\n     * Check if state is expired.\n     *\n     * @param status - `null` to check if state is expired.\n     * @returns `true` if state is expired, `false` otherwise.\n     */\n    get(status: null): boolean;\n    /**\n     * Callback when state is to be destroyed.\n     *\n     * @param callback - Function to call when state is destroyed.\n     * @returns Function to cancel listener.\n     */\n    get(status: null, callback: () => void): () => void;\n    /**\n     * Get update in progress.\n     *\n     * @returns Promise which resolves object with updated values, `undefined` if there no update is pending.\n     **/\n    set(): PromiseLike<State.Event<this>[]> | undefined;\n    /**\n     * Update mulitple properties at once. Merges argument with current state.\n     * Properties which are not managed by this state will be ignored.\n     *\n     * @param assign - Object with properties to update.\n     * @param silent - If an update does occur, listeners will not be refreshed automatically.\n     * @returns Promise resolving an array of keys updated, `undefined` (immediately) if a noop.\n     */\n    set(assign?: State.Assign<this>, silent?: boolean): PromiseLike<State.Event<this>[]> | undefined;\n    /**\n     * Push an update. This will not change the value of associated property.\n     *\n     * Useful where a property value internally has changed, but the object is the same.\n     * For example: An array has pushed a new value, or a nested property is updated.\n     *\n     * You can also use this to dispatch arbitrary events.\n     * Symbols are recommended as non-property events, however you can use any string.\n     * If doing so, be sure to avoid collisions with property names! An easy way to do this is\n     * to prefix an event with \"!\" and/or use dash-case. e.g. `set(\"!event\")` or `set(\"my-event\")`.\n     *\n     * @param key - Property or event to dispatch.\n     * @returns Promise resolves an array of keys updated.\n     */\n    set(key: State.Event<this>): PromiseLike<State.Event<this>[]>;\n    /**\n     * Set a value for a property. This will update the value and notify listeners.\n     *\n     * **Use with caution!** Key nor value are checked for validity.\n     *\n     * This is meant for assigning values programmatically,\n     * where simple assignment is not practicable.\n     *\n     * For example: `(this as any)[myProperty] = value;`\n     *\n     * @param key - Property to set value for.\n     * @param value - Value to set for property.\n     * @param init - If true, state will begin to manage the property if it is not already.\n     * @returns Promise resolves an array of keys updated.\n     */\n    set(key: State.Event<this>, value: unknown, init?: boolean): PromiseLike<State.Event<this>[]>;\n    /**\n     * Call a function when update occurs.\n     *\n     * Given function is called for every assignment (which changes value) or explicit `set`.\n     *\n     * To run logic on final value only, callback may return a function. Using the same\n     * function for one or more events will ensure it is called only when events are settled.\n     *\n     * @param callback - Function to call when update occurs.\n     * @returns Function to remove listener. Will return `true` if removed, `false` if inactive already.\n     *\n     */\n    set(callback: State.OnEvent<this>): () => boolean;\n    /**\n     * Call a function when a property is updated.\n     * Unlike `get`, this calls synchronously and will fire as many times as the property is updated.\n     *\n     * @param callback - Function to call when property is updated.\n     * @param event - Property to watch for updates.\n     */\n    set(callback: State.OnEvent<this>, event: State.Event<this> | null): () => boolean;\n    /**\n     * Declare an end to updates. This event is final and will freeze state.\n     * This event can be watched for as well, to run cleanup logic and internally will remove all listeners.\n     *\n     * @param status - `null` to end updates.\n     */\n    set(status: null): void;\n    /**\n     * Iterate over managed properties in this instance of State.\n     * Yeilds the key and current value for each property.\n     */\n    [Symbol.iterator](): Iterator<[string, unknown]>;\n    /**\n     * Create and activate a new instance of this state.\n     *\n     * **Important** - Unlike `new this(...)` - this method also activates state.\n     *\n     * @param args - arguments sent to constructor\n     */\n    static new<T extends State>(this: State.Type<T>, ...args: State.Args<T>): T;\n    /**\n     * Static equivalent of `x instanceof this`.\n     * Determines if provided class is a subtype of this one.\n     * If so, language server will make available all static\n     * methods and properties of this class.\n     */\n    static is<T extends State.Extends>(this: T, maybe: unknown): maybe is T;\n    /**\n     * Register a callback to run when any instance of this State is updated.\n     */\n    static on<T extends State>(this: State.Extends<T>, listener: State.OnEvent<T>): () => boolean;\n}\ndeclare function follow(from: State, key: string | number, value?: any): any;\ndeclare function access(subject: State, property: string, required?: boolean): any;\ndeclare function update<T>(subject: State, key: string | number | symbol, value: T, arg?: boolean | State.Setter<T>): boolean | undefined;\n/** Random alphanumberic of length 6; always starts with a letter. */\ndeclare function uid(): string;\nexport { event, METHOD, State, PARENT, STATE, uid, access, update, follow };\n"],"mappings":"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"}