mvc-kit 2.12.5 → 2.13.1

package/dist/Trackable.cjs

@@ -1,81 +1,113 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const bindPublicMethods = require("./bindPublicMethods.cjs");
-const PROTECTED_KEYS = /* @__PURE__ */ new Set(["addCleanup", "notify"]);
-class Trackable {
-  _listeners = null;
-  _disposed = false;
-  _abortController = null;
-  _cleanups = null;
-  constructor() {
-    bindPublicMethods.bindPublicMethods(this, Object.prototype, PROTECTED_KEYS);
-  }
-  // ── Disposable interface ──
-  /** Whether this instance has been disposed. */
-  get disposed() {
-    return this._disposed;
-  }
-  /** AbortSignal that fires when this instance is disposed. Lazily created. */
-  get disposeSignal() {
-    if (!this._abortController) {
-      this._abortController = new AbortController();
-    }
-    return this._abortController.signal;
-  }
-  /**
-   * Tear down the instance: abort the dispose signal, run all registered
-   * cleanups, clear subscribers, and call onDispose. Idempotent.
-   */
-  dispose() {
-    if (this._disposed) return;
-    this._disposed = true;
-    this._abortController?.abort();
-    if (this._cleanups) {
-      for (const fn of this._cleanups) fn();
-      this._cleanups = null;
-    }
-    this._listeners?.clear();
-    this.onDispose?.();
-  }
-  // ── Subscribable (notification-only, no state) ──
-  /**
-   * Subscribe to change notifications. The callback is invoked (with no
-   * arguments) whenever the subclass calls {@link notify}.
-   *
-   * This is the duck-typed contract that ViewModel's auto-tracking system
-   * recognizes — any object with a `subscribe` method is automatically
-   * tracked when accessed inside a ViewModel getter.
-   *
-   * @returns An unsubscribe function.
-   */
-  subscribe(cb) {
-    if (!this._listeners) this._listeners = /* @__PURE__ */ new Set();
-    this._listeners.add(cb);
-    return () => {
-      this._listeners?.delete(cb);
-    };
-  }
-  /**
-   * Notify all subscribers that state has changed. Call this after
-   * mutating internal state to trigger ViewModel getter invalidation
-   * and React re-renders.
-   * @protected
-   */
-  notify() {
-    if (this._listeners) {
-      for (const cb of this._listeners) cb();
-    }
-  }
-  // ── Protected utilities ──
-  /**
-   * Register a cleanup function to be called on {@link dispose}.
-   * Cleanups run in registration order.
-   * @protected
-   */
-  addCleanup(fn) {
-    if (!this._cleanups) this._cleanups = [];
-    this._cleanups.push(fn);
-  }
-}
+const require_bindPublicMethods = require("./bindPublicMethods.cjs");
+//#region src/Trackable.ts
+var PROTECTED_KEYS = new Set(["addCleanup", "notify"]);
+/**
+* Base class for custom reactive objects that integrate with ViewModel's
+* auto-tracking system. Provides subscribable notifications, disposal
+* lifecycle, and automatic method binding.
+*
+* Any object with a `subscribe()` method is auto-tracked by ViewModel
+* getters. Trackable gives you that plus cleanup infrastructure and
+* point-free methods — the same building blocks used by Sorting,
+* Selection, Feed, Pagination, and Pending.
+*
+* Use Trackable when integrating third-party SDKs, custom query objects,
+* or any reactive state that doesn't fit ViewModel's state/getter model.
+*
+* @example
+* ```ts
+* class RPCQuery<Data> extends Trackable {
+*   private _data: Data | undefined;
+*   private _loading = false;
+*
+*   get data() { return this._data; }
+*   get loading() { return this._loading; }
+*
+*   async call(): Promise<void> {
+*     this._loading = true;
+*     this.notify();
+*     this._data = await fetchData();
+*     this._loading = false;
+*     this.notify();
+*   }
+* }
+*
+* // Used as a ViewModel property — auto-tracked:
+* class UsersVM extends ViewModel {
+*   readonly users = new RPCQuery<User[]>();
+*   get userList() { return this.users.data ?? []; }
+* }
+* ```
+*/
+var Trackable = class {
+	_listeners = null;
+	_disposed = false;
+	_abortController = null;
+	_cleanups = null;
+	constructor() {
+		require_bindPublicMethods.bindPublicMethods(this, Object.prototype, PROTECTED_KEYS);
+	}
+	/** Whether this instance has been disposed. */
+	get disposed() {
+		return this._disposed;
+	}
+	/** AbortSignal that fires when this instance is disposed. Lazily created. */
+	get disposeSignal() {
+		if (!this._abortController) this._abortController = new AbortController();
+		return this._abortController.signal;
+	}
+	/**
+	* Tear down the instance: abort the dispose signal, run all registered
+	* cleanups, clear subscribers, and call onDispose. Idempotent.
+	*/
+	dispose() {
+		if (this._disposed) return;
+		this._disposed = true;
+		this._abortController?.abort();
+		if (this._cleanups) {
+			for (const fn of this._cleanups) fn();
+			this._cleanups = null;
+		}
+		this._listeners?.clear();
+		this.onDispose?.();
+	}
+	/**
+	* Subscribe to change notifications. The callback is invoked (with no
+	* arguments) whenever the subclass calls {@link notify}.
+	*
+	* This is the duck-typed contract that ViewModel's auto-tracking system
+	* recognizes — any object with a `subscribe` method is automatically
+	* tracked when accessed inside a ViewModel getter.
+	*
+	* @returns An unsubscribe function.
+	*/
+	subscribe(cb) {
+		if (!this._listeners) this._listeners = /* @__PURE__ */ new Set();
+		this._listeners.add(cb);
+		return () => {
+			this._listeners?.delete(cb);
+		};
+	}
+	/**
+	* Notify all subscribers that state has changed. Call this after
+	* mutating internal state to trigger ViewModel getter invalidation
+	* and React re-renders.
+	* @protected
+	*/
+	notify() {
+		if (this._listeners) for (const cb of this._listeners) cb();
+	}
+	/**
+	* Register a cleanup function to be called on {@link dispose}.
+	* Cleanups run in registration order.
+	* @protected
+	*/
+	addCleanup(fn) {
+		if (!this._cleanups) this._cleanups = [];
+		this._cleanups.push(fn);
+	}
+};
+//#endregion
 exports.Trackable = Trackable;
-//# sourceMappingURL=Trackable.cjs.map
+
+//# sourceMappingURL=Trackable.cjs.map

package/dist/Trackable.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"Trackable.cjs","sources":["../src/Trackable.ts"],"sourcesContent":["import type { Disposable } from './types';\nimport { bindPublicMethods } from './bindPublicMethods';\n\nconst PROTECTED_KEYS = new Set(['addCleanup', 'notify']);\n\n/**\n * Base class for custom reactive objects that integrate with ViewModel's\n * auto-tracking system. Provides subscribable notifications, disposal\n * lifecycle, and automatic method binding.\n *\n * Any object with a `subscribe()` method is auto-tracked by ViewModel\n * getters. Trackable gives you that plus cleanup infrastructure and\n * point-free methods — the same building blocks used by Sorting,\n * Selection, Feed, Pagination, and Pending.\n *\n * Use Trackable when integrating third-party SDKs, custom query objects,\n * or any reactive state that doesn't fit ViewModel's state/getter model.\n *\n * @example\n * ```ts\n * class RPCQuery<Data> extends Trackable {\n *   private _data: Data | undefined;\n *   private _loading = false;\n *\n *   get data() { return this._data; }\n *   get loading() { return this._loading; }\n *\n *   async call(): Promise<void> {\n *     this._loading = true;\n *     this.notify();\n *     this._data = await fetchData();\n *     this._loading = false;\n *     this.notify();\n *   }\n * }\n *\n * // Used as a ViewModel property — auto-tracked:\n * class UsersVM extends ViewModel {\n *   readonly users = new RPCQuery<User[]>();\n *   get userList() { return this.users.data ?? []; }\n * }\n * ```\n */\nexport class Trackable implements Disposable {\n  private _listeners: Set<() => void> | null = null;\n  private _disposed = false;\n  private _abortController: AbortController | null = null;\n  private _cleanups: (() => void)[] | null = null;\n\n  constructor() {\n    bindPublicMethods(this, Object.prototype, PROTECTED_KEYS);\n  }\n\n  // ── Disposable interface ──\n\n  /** Whether this instance has been disposed. */\n  get disposed(): boolean {\n    return this._disposed;\n  }\n\n  /** AbortSignal that fires when this instance is disposed. Lazily created. */\n  get disposeSignal(): AbortSignal {\n    if (!this._abortController) {\n      this._abortController = new AbortController();\n    }\n    return this._abortController.signal;\n  }\n\n  /**\n   * Tear down the instance: abort the dispose signal, run all registered\n   * cleanups, clear subscribers, and call onDispose. Idempotent.\n   */\n  dispose(): void {\n    if (this._disposed) return;\n    this._disposed = true;\n    this._abortController?.abort();\n    if (this._cleanups) {\n      for (const fn of this._cleanups) fn();\n      this._cleanups = null;\n    }\n    this._listeners?.clear();\n    this.onDispose?.();\n  }\n\n  // ── Subscribable (notification-only, no state) ──\n\n  /**\n   * Subscribe to change notifications. The callback is invoked (with no\n   * arguments) whenever the subclass calls {@link notify}.\n   *\n   * This is the duck-typed contract that ViewModel's auto-tracking system\n   * recognizes — any object with a `subscribe` method is automatically\n   * tracked when accessed inside a ViewModel getter.\n   *\n   * @returns An unsubscribe function.\n   */\n  subscribe(cb: () => void): () => void {\n    if (!this._listeners) this._listeners = new Set();\n    this._listeners.add(cb);\n    return () => { this._listeners?.delete(cb); };\n  }\n\n  /**\n   * Notify all subscribers that state has changed. Call this after\n   * mutating internal state to trigger ViewModel getter invalidation\n   * and React re-renders.\n   * @protected\n   */\n  protected notify(): void {\n    if (this._listeners) {\n      for (const cb of this._listeners) cb();\n    }\n  }\n\n  // ── Protected utilities ──\n\n  /**\n   * Register a cleanup function to be called on {@link dispose}.\n   * Cleanups run in registration order.\n   * @protected\n   */\n  protected addCleanup(fn: () => void): void {\n    if (!this._cleanups) this._cleanups = [];\n    this._cleanups.push(fn);\n  }\n\n  /** Lifecycle hook called at the end of dispose(). Override for custom teardown. @protected */\n  protected onDispose?(): void;\n}\n"],"names":["bindPublicMethods"],"mappings":";;;AAGA,MAAM,iBAAiB,oBAAI,IAAI,CAAC,cAAc,QAAQ,CAAC;AAwChD,MAAM,UAAgC;AAAA,EACnC,aAAqC;AAAA,EACrC,YAAY;AAAA,EACZ,mBAA2C;AAAA,EAC3C,YAAmC;AAAA,EAE3C,cAAc;AACZA,sBAAAA,kBAAkB,MAAM,OAAO,WAAW,cAAc;AAAA,EAC1D;AAAA;AAAA;AAAA,EAKA,IAAI,WAAoB;AACtB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA,EAGA,IAAI,gBAA6B;AAC/B,QAAI,CAAC,KAAK,kBAAkB;AAC1B,WAAK,mBAAmB,IAAI,gBAAA;AAAA,IAC9B;AACA,WAAO,KAAK,iBAAiB;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,UAAgB;AACd,QAAI,KAAK,UAAW;AACpB,SAAK,YAAY;AACjB,SAAK,kBAAkB,MAAA;AACvB,QAAI,KAAK,WAAW;AAClB,iBAAW,MAAM,KAAK,UAAW,IAAA;AACjC,WAAK,YAAY;AAAA,IACnB;AACA,SAAK,YAAY,MAAA;AACjB,SAAK,YAAA;AAAA,EACP;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcA,UAAU,IAA4B;AACpC,QAAI,CAAC,KAAK,WAAY,MAAK,iCAAiB,IAAA;AAC5C,SAAK,WAAW,IAAI,EAAE;AACtB,WAAO,MAAM;AAAE,WAAK,YAAY,OAAO,EAAE;AAAA,IAAG;AAAA,EAC9C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQU,SAAe;AACvB,QAAI,KAAK,YAAY;AACnB,iBAAW,MAAM,KAAK,WAAY,IAAA;AAAA,IACpC;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASU,WAAW,IAAsB;AACzC,QAAI,CAAC,KAAK,UAAW,MAAK,YAAY,CAAA;AACtC,SAAK,UAAU,KAAK,EAAE;AAAA,EACxB;AAIF;;"}
+{"version":3,"file":"Trackable.cjs","names":[],"sources":["../src/Trackable.ts"],"sourcesContent":["import type { Disposable } from './types';\nimport { bindPublicMethods } from './bindPublicMethods';\n\nconst PROTECTED_KEYS = new Set(['addCleanup', 'notify']);\n\n/**\n * Base class for custom reactive objects that integrate with ViewModel's\n * auto-tracking system. Provides subscribable notifications, disposal\n * lifecycle, and automatic method binding.\n *\n * Any object with a `subscribe()` method is auto-tracked by ViewModel\n * getters. Trackable gives you that plus cleanup infrastructure and\n * point-free methods — the same building blocks used by Sorting,\n * Selection, Feed, Pagination, and Pending.\n *\n * Use Trackable when integrating third-party SDKs, custom query objects,\n * or any reactive state that doesn't fit ViewModel's state/getter model.\n *\n * @example\n * ```ts\n * class RPCQuery<Data> extends Trackable {\n *   private _data: Data | undefined;\n *   private _loading = false;\n *\n *   get data() { return this._data; }\n *   get loading() { return this._loading; }\n *\n *   async call(): Promise<void> {\n *     this._loading = true;\n *     this.notify();\n *     this._data = await fetchData();\n *     this._loading = false;\n *     this.notify();\n *   }\n * }\n *\n * // Used as a ViewModel property — auto-tracked:\n * class UsersVM extends ViewModel {\n *   readonly users = new RPCQuery<User[]>();\n *   get userList() { return this.users.data ?? []; }\n * }\n * ```\n */\nexport class Trackable implements Disposable {\n  private _listeners: Set<() => void> | null = null;\n  private _disposed = false;\n  private _abortController: AbortController | null = null;\n  private _cleanups: (() => void)[] | null = null;\n\n  constructor() {\n    bindPublicMethods(this, Object.prototype, PROTECTED_KEYS);\n  }\n\n  // ── Disposable interface ──\n\n  /** Whether this instance has been disposed. */\n  get disposed(): boolean {\n    return this._disposed;\n  }\n\n  /** AbortSignal that fires when this instance is disposed. Lazily created. */\n  get disposeSignal(): AbortSignal {\n    if (!this._abortController) {\n      this._abortController = new AbortController();\n    }\n    return this._abortController.signal;\n  }\n\n  /**\n   * Tear down the instance: abort the dispose signal, run all registered\n   * cleanups, clear subscribers, and call onDispose. Idempotent.\n   */\n  dispose(): void {\n    if (this._disposed) return;\n    this._disposed = true;\n    this._abortController?.abort();\n    if (this._cleanups) {\n      for (const fn of this._cleanups) fn();\n      this._cleanups = null;\n    }\n    this._listeners?.clear();\n    this.onDispose?.();\n  }\n\n  // ── Subscribable (notification-only, no state) ──\n\n  /**\n   * Subscribe to change notifications. The callback is invoked (with no\n   * arguments) whenever the subclass calls {@link notify}.\n   *\n   * This is the duck-typed contract that ViewModel's auto-tracking system\n   * recognizes — any object with a `subscribe` method is automatically\n   * tracked when accessed inside a ViewModel getter.\n   *\n   * @returns An unsubscribe function.\n   */\n  subscribe(cb: () => void): () => void {\n    if (!this._listeners) this._listeners = new Set();\n    this._listeners.add(cb);\n    return () => { this._listeners?.delete(cb); };\n  }\n\n  /**\n   * Notify all subscribers that state has changed. Call this after\n   * mutating internal state to trigger ViewModel getter invalidation\n   * and React re-renders.\n   * @protected\n   */\n  protected notify(): void {\n    if (this._listeners) {\n      for (const cb of this._listeners) cb();\n    }\n  }\n\n  // ── Protected utilities ──\n\n  /**\n   * Register a cleanup function to be called on {@link dispose}.\n   * Cleanups run in registration order.\n   * @protected\n   */\n  protected addCleanup(fn: () => void): void {\n    if (!this._cleanups) this._cleanups = [];\n    this._cleanups.push(fn);\n  }\n\n  /** Lifecycle hook called at the end of dispose(). Override for custom teardown. @protected */\n  protected onDispose?(): void;\n}\n"],"mappings":";;AAGA,IAAM,iBAAiB,IAAI,IAAI,CAAC,cAAc,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCxD,IAAa,YAAb,MAA6C;CAC3C,aAA6C;CAC7C,YAAoB;CACpB,mBAAmD;CACnD,YAA2C;CAE3C,cAAc;AACZ,4BAAA,kBAAkB,MAAM,OAAO,WAAW,eAAe;;;CAM3D,IAAI,WAAoB;AACtB,SAAO,KAAK;;;CAId,IAAI,gBAA6B;AAC/B,MAAI,CAAC,KAAK,iBACR,MAAK,mBAAmB,IAAI,iBAAiB;AAE/C,SAAO,KAAK,iBAAiB;;;;;;CAO/B,UAAgB;AACd,MAAI,KAAK,UAAW;AACpB,OAAK,YAAY;AACjB,OAAK,kBAAkB,OAAO;AAC9B,MAAI,KAAK,WAAW;AAClB,QAAK,MAAM,MAAM,KAAK,UAAW,KAAI;AACrC,QAAK,YAAY;;AAEnB,OAAK,YAAY,OAAO;AACxB,OAAK,aAAa;;;;;;;;;;;;CAepB,UAAU,IAA4B;AACpC,MAAI,CAAC,KAAK,WAAY,MAAK,6BAAa,IAAI,KAAK;AACjD,OAAK,WAAW,IAAI,GAAG;AACvB,eAAa;AAAE,QAAK,YAAY,OAAO,GAAG;;;;;;;;;CAS5C,SAAyB;AACvB,MAAI,KAAK,WACP,MAAK,MAAM,MAAM,KAAK,WAAY,KAAI;;;;;;;CAW1C,WAAqB,IAAsB;AACzC,MAAI,CAAC,KAAK,UAAW,MAAK,YAAY,EAAE;AACxC,OAAK,UAAU,KAAK,GAAG"}

package/dist/Trackable.js

@@ -1,81 +1,113 @@
 import { bindPublicMethods } from "./bindPublicMethods.js";
-const PROTECTED_KEYS = /* @__PURE__ */ new Set(["addCleanup", "notify"]);
-class Trackable {
-  _listeners = null;
-  _disposed = false;
-  _abortController = null;
-  _cleanups = null;
-  constructor() {
-    bindPublicMethods(this, Object.prototype, PROTECTED_KEYS);
-  }
-  // ── Disposable interface ──
-  /** Whether this instance has been disposed. */
-  get disposed() {
-    return this._disposed;
-  }
-  /** AbortSignal that fires when this instance is disposed. Lazily created. */
-  get disposeSignal() {
-    if (!this._abortController) {
-      this._abortController = new AbortController();
-    }
-    return this._abortController.signal;
-  }
-  /**
-   * Tear down the instance: abort the dispose signal, run all registered
-   * cleanups, clear subscribers, and call onDispose. Idempotent.
-   */
-  dispose() {
-    if (this._disposed) return;
-    this._disposed = true;
-    this._abortController?.abort();
-    if (this._cleanups) {
-      for (const fn of this._cleanups) fn();
-      this._cleanups = null;
-    }
-    this._listeners?.clear();
-    this.onDispose?.();
-  }
-  // ── Subscribable (notification-only, no state) ──
-  /**
-   * Subscribe to change notifications. The callback is invoked (with no
-   * arguments) whenever the subclass calls {@link notify}.
-   *
-   * This is the duck-typed contract that ViewModel's auto-tracking system
-   * recognizes — any object with a `subscribe` method is automatically
-   * tracked when accessed inside a ViewModel getter.
-   *
-   * @returns An unsubscribe function.
-   */
-  subscribe(cb) {
-    if (!this._listeners) this._listeners = /* @__PURE__ */ new Set();
-    this._listeners.add(cb);
-    return () => {
-      this._listeners?.delete(cb);
-    };
-  }
-  /**
-   * Notify all subscribers that state has changed. Call this after
-   * mutating internal state to trigger ViewModel getter invalidation
-   * and React re-renders.
-   * @protected
-   */
-  notify() {
-    if (this._listeners) {
-      for (const cb of this._listeners) cb();
-    }
-  }
-  // ── Protected utilities ──
-  /**
-   * Register a cleanup function to be called on {@link dispose}.
-   * Cleanups run in registration order.
-   * @protected
-   */
-  addCleanup(fn) {
-    if (!this._cleanups) this._cleanups = [];
-    this._cleanups.push(fn);
-  }
-}
-export {
-  Trackable
+//#region src/Trackable.ts
+var PROTECTED_KEYS = new Set(["addCleanup", "notify"]);
+/**
+* Base class for custom reactive objects that integrate with ViewModel's
+* auto-tracking system. Provides subscribable notifications, disposal
+* lifecycle, and automatic method binding.
+*
+* Any object with a `subscribe()` method is auto-tracked by ViewModel
+* getters. Trackable gives you that plus cleanup infrastructure and
+* point-free methods — the same building blocks used by Sorting,
+* Selection, Feed, Pagination, and Pending.
+*
+* Use Trackable when integrating third-party SDKs, custom query objects,
+* or any reactive state that doesn't fit ViewModel's state/getter model.
+*
+* @example
+* ```ts
+* class RPCQuery<Data> extends Trackable {
+*   private _data: Data | undefined;
+*   private _loading = false;
+*
+*   get data() { return this._data; }
+*   get loading() { return this._loading; }
+*
+*   async call(): Promise<void> {
+*     this._loading = true;
+*     this.notify();
+*     this._data = await fetchData();
+*     this._loading = false;
+*     this.notify();
+*   }
+* }
+*
+* // Used as a ViewModel property — auto-tracked:
+* class UsersVM extends ViewModel {
+*   readonly users = new RPCQuery<User[]>();
+*   get userList() { return this.users.data ?? []; }
+* }
+* ```
+*/
+var Trackable = class {
+	_listeners = null;
+	_disposed = false;
+	_abortController = null;
+	_cleanups = null;
+	constructor() {
+		bindPublicMethods(this, Object.prototype, PROTECTED_KEYS);
+	}
+	/** Whether this instance has been disposed. */
+	get disposed() {
+		return this._disposed;
+	}
+	/** AbortSignal that fires when this instance is disposed. Lazily created. */
+	get disposeSignal() {
+		if (!this._abortController) this._abortController = new AbortController();
+		return this._abortController.signal;
+	}
+	/**
+	* Tear down the instance: abort the dispose signal, run all registered
+	* cleanups, clear subscribers, and call onDispose. Idempotent.
+	*/
+	dispose() {
+		if (this._disposed) return;
+		this._disposed = true;
+		this._abortController?.abort();
+		if (this._cleanups) {
+			for (const fn of this._cleanups) fn();
+			this._cleanups = null;
+		}
+		this._listeners?.clear();
+		this.onDispose?.();
+	}
+	/**
+	* Subscribe to change notifications. The callback is invoked (with no
+	* arguments) whenever the subclass calls {@link notify}.
+	*
+	* This is the duck-typed contract that ViewModel's auto-tracking system
+	* recognizes — any object with a `subscribe` method is automatically
+	* tracked when accessed inside a ViewModel getter.
+	*
+	* @returns An unsubscribe function.
+	*/
+	subscribe(cb) {
+		if (!this._listeners) this._listeners = /* @__PURE__ */ new Set();
+		this._listeners.add(cb);
+		return () => {
+			this._listeners?.delete(cb);
+		};
+	}
+	/**
+	* Notify all subscribers that state has changed. Call this after
+	* mutating internal state to trigger ViewModel getter invalidation
+	* and React re-renders.
+	* @protected
+	*/
+	notify() {
+		if (this._listeners) for (const cb of this._listeners) cb();
+	}
+	/**
+	* Register a cleanup function to be called on {@link dispose}.
+	* Cleanups run in registration order.
+	* @protected
+	*/
+	addCleanup(fn) {
+		if (!this._cleanups) this._cleanups = [];
+		this._cleanups.push(fn);
+	}
 };
-//# sourceMappingURL=Trackable.js.map
+//#endregion
+export { Trackable };
+
+//# sourceMappingURL=Trackable.js.map

package/dist/Trackable.js.map

@@ -1 +1 @@
-{"version":3,"file":"Trackable.js","sources":["../src/Trackable.ts"],"sourcesContent":["import type { Disposable } from './types';\nimport { bindPublicMethods } from './bindPublicMethods';\n\nconst PROTECTED_KEYS = new Set(['addCleanup', 'notify']);\n\n/**\n * Base class for custom reactive objects that integrate with ViewModel's\n * auto-tracking system. Provides subscribable notifications, disposal\n * lifecycle, and automatic method binding.\n *\n * Any object with a `subscribe()` method is auto-tracked by ViewModel\n * getters. Trackable gives you that plus cleanup infrastructure and\n * point-free methods — the same building blocks used by Sorting,\n * Selection, Feed, Pagination, and Pending.\n *\n * Use Trackable when integrating third-party SDKs, custom query objects,\n * or any reactive state that doesn't fit ViewModel's state/getter model.\n *\n * @example\n * ```ts\n * class RPCQuery<Data> extends Trackable {\n *   private _data: Data | undefined;\n *   private _loading = false;\n *\n *   get data() { return this._data; }\n *   get loading() { return this._loading; }\n *\n *   async call(): Promise<void> {\n *     this._loading = true;\n *     this.notify();\n *     this._data = await fetchData();\n *     this._loading = false;\n *     this.notify();\n *   }\n * }\n *\n * // Used as a ViewModel property — auto-tracked:\n * class UsersVM extends ViewModel {\n *   readonly users = new RPCQuery<User[]>();\n *   get userList() { return this.users.data ?? []; }\n * }\n * ```\n */\nexport class Trackable implements Disposable {\n  private _listeners: Set<() => void> | null = null;\n  private _disposed = false;\n  private _abortController: AbortController | null = null;\n  private _cleanups: (() => void)[] | null = null;\n\n  constructor() {\n    bindPublicMethods(this, Object.prototype, PROTECTED_KEYS);\n  }\n\n  // ── Disposable interface ──\n\n  /** Whether this instance has been disposed. */\n  get disposed(): boolean {\n    return this._disposed;\n  }\n\n  /** AbortSignal that fires when this instance is disposed. Lazily created. */\n  get disposeSignal(): AbortSignal {\n    if (!this._abortController) {\n      this._abortController = new AbortController();\n    }\n    return this._abortController.signal;\n  }\n\n  /**\n   * Tear down the instance: abort the dispose signal, run all registered\n   * cleanups, clear subscribers, and call onDispose. Idempotent.\n   */\n  dispose(): void {\n    if (this._disposed) return;\n    this._disposed = true;\n    this._abortController?.abort();\n    if (this._cleanups) {\n      for (const fn of this._cleanups) fn();\n      this._cleanups = null;\n    }\n    this._listeners?.clear();\n    this.onDispose?.();\n  }\n\n  // ── Subscribable (notification-only, no state) ──\n\n  /**\n   * Subscribe to change notifications. The callback is invoked (with no\n   * arguments) whenever the subclass calls {@link notify}.\n   *\n   * This is the duck-typed contract that ViewModel's auto-tracking system\n   * recognizes — any object with a `subscribe` method is automatically\n   * tracked when accessed inside a ViewModel getter.\n   *\n   * @returns An unsubscribe function.\n   */\n  subscribe(cb: () => void): () => void {\n    if (!this._listeners) this._listeners = new Set();\n    this._listeners.add(cb);\n    return () => { this._listeners?.delete(cb); };\n  }\n\n  /**\n   * Notify all subscribers that state has changed. Call this after\n   * mutating internal state to trigger ViewModel getter invalidation\n   * and React re-renders.\n   * @protected\n   */\n  protected notify(): void {\n    if (this._listeners) {\n      for (const cb of this._listeners) cb();\n    }\n  }\n\n  // ── Protected utilities ──\n\n  /**\n   * Register a cleanup function to be called on {@link dispose}.\n   * Cleanups run in registration order.\n   * @protected\n   */\n  protected addCleanup(fn: () => void): void {\n    if (!this._cleanups) this._cleanups = [];\n    this._cleanups.push(fn);\n  }\n\n  /** Lifecycle hook called at the end of dispose(). Override for custom teardown. @protected */\n  protected onDispose?(): void;\n}\n"],"names":[],"mappings":";AAGA,MAAM,iBAAiB,oBAAI,IAAI,CAAC,cAAc,QAAQ,CAAC;AAwChD,MAAM,UAAgC;AAAA,EACnC,aAAqC;AAAA,EACrC,YAAY;AAAA,EACZ,mBAA2C;AAAA,EAC3C,YAAmC;AAAA,EAE3C,cAAc;AACZ,sBAAkB,MAAM,OAAO,WAAW,cAAc;AAAA,EAC1D;AAAA;AAAA;AAAA,EAKA,IAAI,WAAoB;AACtB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA,EAGA,IAAI,gBAA6B;AAC/B,QAAI,CAAC,KAAK,kBAAkB;AAC1B,WAAK,mBAAmB,IAAI,gBAAA;AAAA,IAC9B;AACA,WAAO,KAAK,iBAAiB;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,UAAgB;AACd,QAAI,KAAK,UAAW;AACpB,SAAK,YAAY;AACjB,SAAK,kBAAkB,MAAA;AACvB,QAAI,KAAK,WAAW;AAClB,iBAAW,MAAM,KAAK,UAAW,IAAA;AACjC,WAAK,YAAY;AAAA,IACnB;AACA,SAAK,YAAY,MAAA;AACjB,SAAK,YAAA;AAAA,EACP;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcA,UAAU,IAA4B;AACpC,QAAI,CAAC,KAAK,WAAY,MAAK,iCAAiB,IAAA;AAC5C,SAAK,WAAW,IAAI,EAAE;AACtB,WAAO,MAAM;AAAE,WAAK,YAAY,OAAO,EAAE;AAAA,IAAG;AAAA,EAC9C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQU,SAAe;AACvB,QAAI,KAAK,YAAY;AACnB,iBAAW,MAAM,KAAK,WAAY,IAAA;AAAA,IACpC;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASU,WAAW,IAAsB;AACzC,QAAI,CAAC,KAAK,UAAW,MAAK,YAAY,CAAA;AACtC,SAAK,UAAU,KAAK,EAAE;AAAA,EACxB;AAIF;"}
+{"version":3,"file":"Trackable.js","names":[],"sources":["../src/Trackable.ts"],"sourcesContent":["import type { Disposable } from './types';\nimport { bindPublicMethods } from './bindPublicMethods';\n\nconst PROTECTED_KEYS = new Set(['addCleanup', 'notify']);\n\n/**\n * Base class for custom reactive objects that integrate with ViewModel's\n * auto-tracking system. Provides subscribable notifications, disposal\n * lifecycle, and automatic method binding.\n *\n * Any object with a `subscribe()` method is auto-tracked by ViewModel\n * getters. Trackable gives you that plus cleanup infrastructure and\n * point-free methods — the same building blocks used by Sorting,\n * Selection, Feed, Pagination, and Pending.\n *\n * Use Trackable when integrating third-party SDKs, custom query objects,\n * or any reactive state that doesn't fit ViewModel's state/getter model.\n *\n * @example\n * ```ts\n * class RPCQuery<Data> extends Trackable {\n *   private _data: Data | undefined;\n *   private _loading = false;\n *\n *   get data() { return this._data; }\n *   get loading() { return this._loading; }\n *\n *   async call(): Promise<void> {\n *     this._loading = true;\n *     this.notify();\n *     this._data = await fetchData();\n *     this._loading = false;\n *     this.notify();\n *   }\n * }\n *\n * // Used as a ViewModel property — auto-tracked:\n * class UsersVM extends ViewModel {\n *   readonly users = new RPCQuery<User[]>();\n *   get userList() { return this.users.data ?? []; }\n * }\n * ```\n */\nexport class Trackable implements Disposable {\n  private _listeners: Set<() => void> | null = null;\n  private _disposed = false;\n  private _abortController: AbortController | null = null;\n  private _cleanups: (() => void)[] | null = null;\n\n  constructor() {\n    bindPublicMethods(this, Object.prototype, PROTECTED_KEYS);\n  }\n\n  // ── Disposable interface ──\n\n  /** Whether this instance has been disposed. */\n  get disposed(): boolean {\n    return this._disposed;\n  }\n\n  /** AbortSignal that fires when this instance is disposed. Lazily created. */\n  get disposeSignal(): AbortSignal {\n    if (!this._abortController) {\n      this._abortController = new AbortController();\n    }\n    return this._abortController.signal;\n  }\n\n  /**\n   * Tear down the instance: abort the dispose signal, run all registered\n   * cleanups, clear subscribers, and call onDispose. Idempotent.\n   */\n  dispose(): void {\n    if (this._disposed) return;\n    this._disposed = true;\n    this._abortController?.abort();\n    if (this._cleanups) {\n      for (const fn of this._cleanups) fn();\n      this._cleanups = null;\n    }\n    this._listeners?.clear();\n    this.onDispose?.();\n  }\n\n  // ── Subscribable (notification-only, no state) ──\n\n  /**\n   * Subscribe to change notifications. The callback is invoked (with no\n   * arguments) whenever the subclass calls {@link notify}.\n   *\n   * This is the duck-typed contract that ViewModel's auto-tracking system\n   * recognizes — any object with a `subscribe` method is automatically\n   * tracked when accessed inside a ViewModel getter.\n   *\n   * @returns An unsubscribe function.\n   */\n  subscribe(cb: () => void): () => void {\n    if (!this._listeners) this._listeners = new Set();\n    this._listeners.add(cb);\n    return () => { this._listeners?.delete(cb); };\n  }\n\n  /**\n   * Notify all subscribers that state has changed. Call this after\n   * mutating internal state to trigger ViewModel getter invalidation\n   * and React re-renders.\n   * @protected\n   */\n  protected notify(): void {\n    if (this._listeners) {\n      for (const cb of this._listeners) cb();\n    }\n  }\n\n  // ── Protected utilities ──\n\n  /**\n   * Register a cleanup function to be called on {@link dispose}.\n   * Cleanups run in registration order.\n   * @protected\n   */\n  protected addCleanup(fn: () => void): void {\n    if (!this._cleanups) this._cleanups = [];\n    this._cleanups.push(fn);\n  }\n\n  /** Lifecycle hook called at the end of dispose(). Override for custom teardown. @protected */\n  protected onDispose?(): void;\n}\n"],"mappings":";;AAGA,IAAM,iBAAiB,IAAI,IAAI,CAAC,cAAc,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCxD,IAAa,YAAb,MAA6C;CAC3C,aAA6C;CAC7C,YAAoB;CACpB,mBAAmD;CACnD,YAA2C;CAE3C,cAAc;AACZ,oBAAkB,MAAM,OAAO,WAAW,eAAe;;;CAM3D,IAAI,WAAoB;AACtB,SAAO,KAAK;;;CAId,IAAI,gBAA6B;AAC/B,MAAI,CAAC,KAAK,iBACR,MAAK,mBAAmB,IAAI,iBAAiB;AAE/C,SAAO,KAAK,iBAAiB;;;;;;CAO/B,UAAgB;AACd,MAAI,KAAK,UAAW;AACpB,OAAK,YAAY;AACjB,OAAK,kBAAkB,OAAO;AAC9B,MAAI,KAAK,WAAW;AAClB,QAAK,MAAM,MAAM,KAAK,UAAW,KAAI;AACrC,QAAK,YAAY;;AAEnB,OAAK,YAAY,OAAO;AACxB,OAAK,aAAa;;;;;;;;;;;;CAepB,UAAU,IAA4B;AACpC,MAAI,CAAC,KAAK,WAAY,MAAK,6BAAa,IAAI,KAAK;AACjD,OAAK,WAAW,IAAI,GAAG;AACvB,eAAa;AAAE,QAAK,YAAY,OAAO,GAAG;;;;;;;;;CAS5C,SAAyB;AACvB,MAAI,KAAK,WACP,MAAK,MAAM,MAAM,KAAK,WAAY,KAAI;;;;;;;CAW1C,WAAqB,IAAsB;AACzC,MAAI,CAAC,KAAK,UAAW,MAAK,YAAY,EAAE;AACxC,OAAK,UAAU,KAAK,GAAG"}