mvc-kit 2.5.3 → 2.5.4

package/dist/ViewModel.d.ts

@@ -1,13 +1,7 @@
 import { EventBus } from './EventBus';
 import type { Listener, Updater, Subscribable, TaskState } from './types';
 export type { Listener, Updater } from './types';
-/**
- * Walk the prototype chain from `instance`'s class up to (but not including)
- * `stopAt`. Calls `visitor` for each own property descriptor found.
- *
- * Shared utility — also used by RFC 2's _wrapMethods().
- */
-export declare function walkPrototypeChain(instance: object, stopAt: object, visitor: (key: string, desc: PropertyDescriptor, proto: object) => void): void;
+export { walkPrototypeChain } from './walkPrototypeChain';
 export type AsyncMethodKeys<T, Base = ViewModel<any, any>> = {
     [K in Exclude<keyof T, keyof Base>]: T[K] extends (...args: any[]) => Promise<any> ? K : never;
 }[Exclude<keyof T, keyof Base>];

package/dist/ViewModel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ViewModel.d.ts","sourceRoot":"","sources":["../src/ViewModel.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ViewModel.d.ts","sourceRoot":"","sources":["../src/ViewModel.ts"],"names":[],"mappings":"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"}

package/dist/ViewModel.js

@@ -0,0 +1,582 @@
+import { EventBus } from "./EventBus.js";
+import { isAbortError, classifyError } from "./errors.js";
+import { walkPrototypeChain } from "./walkPrototypeChain.js";
+const __DEV__ = typeof __MVC_KIT_DEV__ !== "undefined" && __MVC_KIT_DEV__;
+function isAutoTrackable(value) {
+  return value !== null && typeof value === "object" && typeof value.subscribe === "function";
+}
+const DEFAULT_TASK_STATE = Object.freeze({ loading: false, error: null, errorCode: null });
+const RESERVED_ASYNC_KEYS = ["async", "subscribeAsync"];
+const LIFECYCLE_HOOKS = /* @__PURE__ */ new Set(["onInit", "onSet", "onDispose"]);
+class ViewModel {
+  _state;
+  _initialState;
+  _disposed = false;
+  _initialized = false;
+  _listeners = /* @__PURE__ */ new Set();
+  _abortController = null;
+  _cleanups = null;
+  _subscriptionCleanups = null;
+  _eventBus = null;
+  // ── Reactive derived state (RFC 1) ─────────────────────────────
+  _revision = 0;
+  _stateTracking = null;
+  _sourceTracking = null;
+  _trackedSources = /* @__PURE__ */ new Map();
+  // ── Async tracking (RFC 2) ──────────────────────────────────────
+  _asyncStates = /* @__PURE__ */ new Map();
+  _asyncSnapshots = /* @__PURE__ */ new Map();
+  _asyncListeners = /* @__PURE__ */ new Set();
+  _asyncProxy = null;
+  _activeOps = null;
+  /** DEV-only timeout (ms) for detecting ghost async operations after dispose. */
+  static GHOST_TIMEOUT = 3e3;
+  constructor(initialState) {
+    this._state = Object.freeze({ ...initialState });
+    this._initialState = this._state;
+    this._guardReservedKeys();
+  }
+  /** Current frozen state object. */
+  get state() {
+    return this._state;
+  }
+  /** Whether this instance has been disposed. */
+  get disposed() {
+    return this._disposed;
+  }
+  /** Whether init() has been called. */
+  get initialized() {
+    return this._initialized;
+  }
+  /** AbortSignal that fires when this instance is disposed. Lazily created. */
+  get disposeSignal() {
+    if (!this._abortController) {
+      this._abortController = new AbortController();
+    }
+    return this._abortController.signal;
+  }
+  /** Lazily-created typed EventBus for emitting and subscribing to events. */
+  get events() {
+    if (!this._eventBus) {
+      this._eventBus = new EventBus();
+    }
+    return this._eventBus;
+  }
+  /** Initializes the instance. Called automatically by React hooks after mount. */
+  init() {
+    if (this._initialized || this._disposed) return;
+    this._initialized = true;
+    this._trackSubscribables();
+    this._installStateProxy();
+    this._memoizeGetters();
+    this._wrapMethods();
+    return this.onInit?.();
+  }
+  /**
+   * Merges partial state into current state. If no values actually
+   * changed by reference, this is a no-op.
+   *
+   * Triggers React re-render via listener notification. Called when:
+   *   - User code calls set() to update source state
+   *
+   * NOT called for subscribable member notifications — those use
+   * a separate notification path (see _trackSubscribables).
+   */
+  set(partialOrUpdater) {
+    if (this._disposed) return;
+    if (__DEV__ && this._stateTracking) {
+      console.error(
+        "[mvc-kit] set() called inside a getter. Getters must be pure — they read state and return a value. They must never call set(), which would cause an infinite render loop. Move this logic to an action method."
+      );
+      return;
+    }
+    const partial = typeof partialOrUpdater === "function" ? partialOrUpdater(this._state) : partialOrUpdater;
+    const keys = Object.keys(partial);
+    const hasChanges = keys.some(
+      (key) => partial[key] !== this._state[key]
+    );
+    if (!hasChanges) {
+      return;
+    }
+    const prev = this._state;
+    const next = Object.freeze({ ...prev, ...partial });
+    this._state = next;
+    this._revision++;
+    this.onSet?.(prev, next);
+    for (const listener of this._listeners) {
+      listener(next, prev);
+    }
+  }
+  /**
+   * Emits a typed event via the internal EventBus.
+   * Safe to call during dispose cleanup callbacks.
+   * @protected
+   */
+  emit(event, payload) {
+    if (this._eventBus?.disposed ?? this._disposed) return;
+    this.events.emit(event, payload);
+  }
+  /** Subscribes to state changes. Returns an unsubscribe function. */
+  subscribe(listener) {
+    if (this._disposed) {
+      return () => {
+      };
+    }
+    this._listeners.add(listener);
+    return () => {
+      this._listeners.delete(listener);
+    };
+  }
+  /** Tears down the instance, releasing all subscriptions and resources. */
+  dispose() {
+    if (this._disposed) {
+      return;
+    }
+    this._disposed = true;
+    this._teardownSubscriptions();
+    this._abortController?.abort();
+    if (this._cleanups) {
+      for (const fn of this._cleanups) fn();
+      this._cleanups = null;
+    }
+    this._eventBus?.dispose();
+    this.onDispose?.();
+    this._listeners.clear();
+  }
+  /**
+   * Resets state to initial values (or provided state), aborts in-flight work,
+   * clears async tracking, and re-runs onInit().
+   */
+  reset(newState) {
+    if (this._disposed) return;
+    this._abortController?.abort();
+    this._abortController = null;
+    this._teardownSubscriptions();
+    this._state = newState ? Object.freeze({ ...newState }) : this._initialState;
+    this._revision++;
+    this._asyncStates.clear();
+    this._asyncSnapshots.clear();
+    this._notifyAsync();
+    this._trackSubscribables();
+    for (const listener of this._listeners) {
+      listener(this._state, this._state);
+    }
+    return this.onInit?.();
+  }
+  /**
+   * Registers a cleanup function to be called on dispose. Used internally for things like method wrapper
+   * cleanup and event bus disposal, but can also be used by subclasses for custom cleanup logic.
+   * @param fn
+   * @protected
+   */
+  addCleanup(fn) {
+    if (!this._cleanups) {
+      this._cleanups = [];
+    }
+    this._cleanups.push(fn);
+  }
+  /** Subscribes to an external Subscribable with automatic cleanup on dispose. @protected */
+  subscribeTo(source, listener) {
+    const unsubscribe = source.subscribe(listener);
+    if (!this._subscriptionCleanups) this._subscriptionCleanups = [];
+    this._subscriptionCleanups.push(unsubscribe);
+    return unsubscribe;
+  }
+  // ── Async tracking API ──────────────────────────────────────────
+  /** Proxy providing `TaskState` (loading, error, errorCode) per async method. */
+  get async() {
+    if (!this._asyncProxy) {
+      const self = this;
+      this._asyncProxy = new Proxy({}, {
+        get(_, prop) {
+          return self._asyncSnapshots.get(prop) ?? DEFAULT_TASK_STATE;
+        },
+        has(_, prop) {
+          return self._asyncSnapshots.has(prop);
+        },
+        ownKeys() {
+          return Array.from(self._asyncSnapshots.keys());
+        },
+        getOwnPropertyDescriptor(_, prop) {
+          if (self._asyncSnapshots.has(prop)) {
+            return { configurable: true, enumerable: true, value: self._asyncSnapshots.get(prop) };
+          }
+          return void 0;
+        }
+      });
+    }
+    return this._asyncProxy;
+  }
+  /** Subscribes to async state changes. Used by `useAsync` for React integration. */
+  subscribeAsync(listener) {
+    if (this._disposed) return () => {
+    };
+    this._asyncListeners.add(listener);
+    return () => {
+      this._asyncListeners.delete(listener);
+    };
+  }
+  _notifyAsync() {
+    for (const listener of this._asyncListeners) {
+      listener();
+    }
+  }
+  // ── Async tracking internals ────────────────────────────────────
+  _teardownSubscriptions() {
+    for (const tracked of this._trackedSources.values()) tracked.unsubscribe();
+    this._trackedSources.clear();
+    if (this._subscriptionCleanups) {
+      for (const fn of this._subscriptionCleanups) fn();
+      this._subscriptionCleanups = null;
+    }
+  }
+  _guardReservedKeys() {
+    walkPrototypeChain(this, ViewModel.prototype, (key) => {
+      if (RESERVED_ASYNC_KEYS.includes(key)) {
+        throw new Error(
+          `[mvc-kit] "${key}" is a reserved property on ViewModel and cannot be overridden.`
+        );
+      }
+    });
+  }
+  _wrapMethods() {
+    for (const key of RESERVED_ASYNC_KEYS) {
+      if (Object.getOwnPropertyDescriptor(this, key)?.value !== void 0) {
+        throw new Error(
+          `[mvc-kit] "${key}" is a reserved property on ViewModel and cannot be overridden.`
+        );
+      }
+    }
+    const self = this;
+    const processed = /* @__PURE__ */ new Set();
+    const wrappedKeys = [];
+    if (__DEV__) {
+      this._activeOps = /* @__PURE__ */ new Map();
+    }
+    walkPrototypeChain(this, ViewModel.prototype, (key, desc) => {
+      if (desc.get || desc.set) return;
+      if (typeof desc.value !== "function") return;
+      if (key.startsWith("_")) return;
+      if (LIFECYCLE_HOOKS.has(key)) return;
+      if (processed.has(key)) return;
+      processed.add(key);
+      const original = desc.value;
+      let pruned = false;
+      const wrapper = function(...args) {
+        if (self._disposed) {
+          if (__DEV__) {
+            console.warn(`[mvc-kit] "${key}" called after dispose — ignored.`);
+          }
+          return void 0;
+        }
+        if (__DEV__ && !self._initialized) {
+          console.warn(
+            `[mvc-kit] "${key}" called before init(). Async tracking is active only after init().`
+          );
+        }
+        let result;
+        try {
+          result = original.apply(self, args);
+        } catch (e) {
+          throw e;
+        }
+        if (!result || typeof result.then !== "function") {
+          if (!pruned) {
+            pruned = true;
+            self._asyncStates.delete(key);
+            self._asyncSnapshots.delete(key);
+            self[key] = original.bind(self);
+          }
+          return result;
+        }
+        let internal = self._asyncStates.get(key);
+        if (!internal) {
+          internal = { loading: false, error: null, errorCode: null, count: 0 };
+          self._asyncStates.set(key, internal);
+        }
+        internal.count++;
+        internal.loading = true;
+        internal.error = null;
+        internal.errorCode = null;
+        self._asyncSnapshots.set(key, Object.freeze({ loading: true, error: null, errorCode: null }));
+        self._notifyAsync();
+        if (__DEV__ && self._activeOps) {
+          self._activeOps.set(key, (self._activeOps.get(key) ?? 0) + 1);
+        }
+        return result.then(
+          (value) => {
+            if (self._disposed) return value;
+            internal.count--;
+            internal.loading = internal.count > 0;
+            self._asyncSnapshots.set(
+              key,
+              Object.freeze({ loading: internal.loading, error: internal.error, errorCode: internal.errorCode })
+            );
+            self._notifyAsync();
+            if (__DEV__ && self._activeOps) {
+              const c = (self._activeOps.get(key) ?? 1) - 1;
+              if (c <= 0) self._activeOps.delete(key);
+              else self._activeOps.set(key, c);
+            }
+            return value;
+          },
+          (error) => {
+            if (isAbortError(error)) {
+              if (!self._disposed) {
+                internal.count--;
+                internal.loading = internal.count > 0;
+                self._asyncSnapshots.set(
+                  key,
+                  Object.freeze({ loading: internal.loading, error: internal.error, errorCode: internal.errorCode })
+                );
+                self._notifyAsync();
+              }
+              if (__DEV__ && self._activeOps) {
+                const c = (self._activeOps.get(key) ?? 1) - 1;
+                if (c <= 0) self._activeOps.delete(key);
+                else self._activeOps.set(key, c);
+              }
+              return void 0;
+            }
+            if (self._disposed) return void 0;
+            internal.count--;
+            internal.loading = internal.count > 0;
+            const classified = classifyError(error);
+            internal.error = classified.message;
+            internal.errorCode = classified.code;
+            self._asyncSnapshots.set(
+              key,
+              Object.freeze({ loading: internal.loading, error: classified.message, errorCode: classified.code })
+            );
+            self._notifyAsync();
+            if (__DEV__ && self._activeOps) {
+              const c = (self._activeOps.get(key) ?? 1) - 1;
+              if (c <= 0) self._activeOps.delete(key);
+              else self._activeOps.set(key, c);
+            }
+            throw error;
+          }
+        );
+      };
+      wrappedKeys.push(key);
+      self[key] = wrapper;
+    });
+    if (wrappedKeys.length > 0) {
+      this.addCleanup(() => {
+        const opsSnapshot = __DEV__ && self._activeOps ? new Map(self._activeOps) : null;
+        for (const k of wrappedKeys) {
+          if (__DEV__) {
+            self[k] = () => {
+              console.warn(`[mvc-kit] "${k}" called after dispose — ignored.`);
+              return void 0;
+            };
+          } else {
+            self[k] = () => void 0;
+          }
+        }
+        self._asyncListeners.clear();
+        self._asyncStates.clear();
+        self._asyncSnapshots.clear();
+        if (__DEV__ && opsSnapshot && opsSnapshot.size > 0) {
+          self._scheduleGhostCheck(opsSnapshot);
+        }
+      });
+    }
+  }
+  _scheduleGhostCheck(opsSnapshot) {
+    if (!__DEV__) return;
+    setTimeout(() => {
+      for (const [key, count] of opsSnapshot) {
+        console.warn(
+          `[mvc-kit] Ghost async operation detected: "${key}" had ${count} pending call(s) when the ViewModel was disposed. Consider using disposeSignal to cancel in-flight work.`
+        );
+      }
+    }, this.constructor.GHOST_TIMEOUT);
+  }
+  // ── Auto-tracking internals ────────────────────────────────────
+  /**
+   * Installs a context-sensitive state getter on the instance.
+   *
+   * During getter tracking (_stateTracking is active): returns a Proxy
+   * that records which state properties are accessed.
+   *
+   * Otherwise: returns the frozen state object directly. This is critical
+   * for React's useSyncExternalStore — it needs a changing reference to
+   * detect state updates and trigger re-renders.
+   */
+  _installStateProxy() {
+    const stateProxy = new Proxy({}, {
+      get: (_, prop) => {
+        this._stateTracking?.add(prop);
+        return this._state[prop];
+      },
+      ownKeys: () => Reflect.ownKeys(this._state),
+      getOwnPropertyDescriptor: (_, prop) => Reflect.getOwnPropertyDescriptor(this._state, prop),
+      set: () => {
+        throw new Error("Cannot mutate state directly. Use set() instead.");
+      },
+      has: (_, prop) => prop in this._state
+    });
+    Object.defineProperty(this, "state", {
+      get: () => {
+        if (this._stateTracking) return stateProxy;
+        return this._state;
+      },
+      configurable: true,
+      enumerable: true
+    });
+  }
+  /**
+   * Scans own instance properties for Subscribable objects and sets up
+   * automatic dependency tracking for each one found.
+   *
+   * For each subscribable member:
+   *   1. Subscribe to it. On notification: bump its tracked revision
+   *      AND the VM's global revision, then force a new state reference
+   *      and notify listeners so React re-renders.
+   *   2. Replace the instance property with a getter that participates
+   *      in dependency tracking.
+   *   3. Register unsubscribe in the dispose chain.
+   *
+   * Called during init(), AFTER all subclass property initializers
+   * have run (they execute during the constructor, before init()).
+   */
+  _trackSubscribables() {
+    for (const key of Object.getOwnPropertyNames(this)) {
+      const value = this[key];
+      if (!isAutoTrackable(value)) continue;
+      let tracked;
+      const onSourceNotify = () => {
+        if (this._disposed) return;
+        tracked.revision++;
+        this._revision++;
+        this._state = Object.freeze({ ...this._state });
+        for (const listener of this._listeners) {
+          listener(this._state, this._state);
+        }
+      };
+      const unsubState = value.subscribe(onSourceNotify);
+      const unsubAsync = typeof value.subscribeAsync === "function" ? value.subscribeAsync(onSourceNotify) : void 0;
+      tracked = {
+        source: value,
+        revision: 0,
+        unsubscribe: unsubAsync ? () => {
+          unsubState();
+          unsubAsync();
+        } : unsubState
+      };
+      this._trackedSources.set(key, tracked);
+      Object.defineProperty(this, key, {
+        get: () => {
+          this._sourceTracking?.set(key, tracked);
+          return value;
+        },
+        configurable: true,
+        enumerable: false
+      });
+    }
+  }
+  /**
+   * Walks the prototype chain from the subclass up to (but not including)
+   * ViewModel.prototype. For every getter found, replaces it on the
+   * instance with a memoized version that tracks dependencies and caches.
+   *
+   * Processing order: most-derived class first. If a subclass overrides
+   * a parent getter, only the subclass version is memoized.
+   */
+  _memoizeGetters() {
+    const processed = /* @__PURE__ */ new Set();
+    walkPrototypeChain(this, ViewModel.prototype, (key, desc) => {
+      if (!desc.get || processed.has(key)) return;
+      processed.add(key);
+      this._wrapGetter(key, desc.get);
+    });
+  }
+  /**
+   * Replaces a single prototype getter with a memoized version on this
+   * instance. The memoized getter tracks both state dependencies and
+   * subscribable member dependencies, caching its result and
+   * revalidating through a three-tier strategy:
+   *
+   *   Tier 1 (fast):   revision unchanged → return cached (1 int compare)
+   *   Tier 2 (medium): revision changed but this getter's deps didn't → return cached
+   *   Tier 3 (slow):   at least one dep changed → full recompute with tracking
+   */
+  _wrapGetter(key, original) {
+    let cached;
+    let validatedAtRevision = -1;
+    let stateDeps;
+    let stateSnapshot;
+    let sourceDeps;
+    Object.defineProperty(this, key, {
+      get: () => {
+        if (this._disposed) return cached;
+        if (validatedAtRevision === this._revision) {
+          return cached;
+        }
+        if (stateDeps && stateSnapshot) {
+          let fresh = true;
+          for (const [k, v] of stateSnapshot) {
+            if (this._state[k] !== v) {
+              fresh = false;
+              break;
+            }
+          }
+          if (fresh && sourceDeps) {
+            for (const [memberKey, rev] of sourceDeps) {
+              const ts = this._trackedSources.get(memberKey);
+              if (ts && ts.revision !== rev) {
+                fresh = false;
+                break;
+              }
+            }
+          }
+          if (fresh) {
+            validatedAtRevision = this._revision;
+            return cached;
+          }
+        }
+        const parentStateTracking = this._stateTracking;
+        const parentSourceTracking = this._sourceTracking;
+        this._stateTracking = /* @__PURE__ */ new Set();
+        this._sourceTracking = /* @__PURE__ */ new Map();
+        try {
+          cached = original.call(this);
+        } catch (e) {
+          this._stateTracking = parentStateTracking;
+          this._sourceTracking = parentSourceTracking;
+          throw e;
+        }
+        stateDeps = this._stateTracking;
+        const capturedSourceDeps = this._sourceTracking;
+        this._stateTracking = parentStateTracking;
+        this._sourceTracking = parentSourceTracking;
+        if (parentStateTracking) {
+          for (const d of stateDeps) parentStateTracking.add(d);
+        }
+        if (parentSourceTracking) {
+          for (const [k, v] of capturedSourceDeps) {
+            parentSourceTracking.set(k, v);
+          }
+        }
+        stateSnapshot = /* @__PURE__ */ new Map();
+        for (const d of stateDeps) {
+          stateSnapshot.set(d, this._state[d]);
+        }
+        sourceDeps = /* @__PURE__ */ new Map();
+        for (const [memberKey, tracked] of capturedSourceDeps) {
+          sourceDeps.set(memberKey, tracked.revision);
+        }
+        validatedAtRevision = this._revision;
+        return cached;
+      },
+      configurable: true,
+      enumerable: true
+    });
+  }
+}
+export {
+  ViewModel,
+  walkPrototypeChain
+};
+//# sourceMappingURL=ViewModel.js.map