mvc-kit 2.7.1 → 2.9.0

package/dist/ViewModel.cjs

@@ -1,9 +1,39 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const EventBus = require("./EventBus.cjs");
-const errors = require("./errors.cjs");
 const walkPrototypeChain = require("./walkPrototypeChain.cjs");
+const wrapAsyncMethods = require("./wrapAsyncMethods.cjs");
 const __DEV__ = typeof __MVC_KIT_DEV__ !== "undefined" && __MVC_KIT_DEV__;
+function freeze(obj) {
+  return __DEV__ ? Object.freeze(obj) : obj;
+}
+const classMembers = /* @__PURE__ */ new WeakMap();
+function getClassMemberInfo(instance, stopPrototype, reservedKeys, lifecycleHooks) {
+  const ctor = instance.constructor;
+  let info = classMembers.get(ctor);
+  if (info) return info;
+  const getters = [];
+  const methods = [];
+  const found = [];
+  const processedGetters = /* @__PURE__ */ new Set();
+  const processedMethods = /* @__PURE__ */ new Set();
+  walkPrototypeChain.walkPrototypeChain(instance, stopPrototype, (key, desc) => {
+    if (reservedKeys.includes(key)) {
+      found.push(key);
+    }
+    if (desc.get && !processedGetters.has(key)) {
+      processedGetters.add(key);
+      getters.push({ key, get: desc.get });
+    }
+    if (!desc.get && !desc.set && typeof desc.value === "function" && !key.startsWith("_") && !lifecycleHooks.has(key) && !processedMethods.has(key)) {
+      processedMethods.add(key);
+      methods.push({ key, fn: desc.value });
+    }
+  });
+  info = { getters, methods, reservedKeys: found };
+  classMembers.set(ctor, info);
+  return info;
+}
 function isAutoTrackable(value) {
   return value !== null && typeof value === "object" && typeof value.subscribe === "function";
 }
@@ -26,16 +56,17 @@ class ViewModel {
   _sourceTracking = null;
   _trackedSources = /* @__PURE__ */ new Map();
   // ── Async tracking (RFC 2) ──────────────────────────────────────
-  _asyncStates = /* @__PURE__ */ new Map();
-  _asyncSnapshots = /* @__PURE__ */ new Map();
-  _asyncListeners = /* @__PURE__ */ new Set();
+  // Lazily allocated on first async method wrap to keep construction fast.
+  _asyncStates = null;
+  _asyncSnapshots = null;
+  _asyncListeners = null;
   _asyncProxy = null;
   _activeOps = null;
   /** DEV-only timeout (ms) for detecting ghost async operations after dispose. */
   static GHOST_TIMEOUT = 3e3;
   constructor(...args) {
     const initialState = args[0] ?? {};
-    this._state = Object.freeze({ ...initialState });
+    this._state = freeze({ ...initialState });
     this._initialState = this._state;
     this._guardReservedKeys();
   }
@@ -71,8 +102,7 @@ class ViewModel {
     this._initialized = true;
     this._trackSubscribables();
     this._installStateProxy();
-    this._memoizeGetters();
-    this._wrapMethods();
+    this._processMembers();
     return this.onInit?.();
   }
   /**
@@ -94,15 +124,19 @@ class ViewModel {
       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]
-    );
+    let hasChanges = false;
+    const current = this._state;
+    for (const key in partial) {
+      if (partial[key] !== current[key]) {
+        hasChanges = true;
+        break;
+      }
+    }
     if (!hasChanges) {
       return;
     }
     const prev = this._state;
-    const next = Object.freeze({ ...prev, ...partial });
+    const next = freeze({ ...prev, ...partial });
     this._state = next;
     this._revision++;
     this.onSet?.(prev, next);
@@ -155,10 +189,10 @@ class ViewModel {
     this._abortController?.abort();
     this._abortController = null;
     this._teardownSubscriptions();
-    this._state = newState ? Object.freeze({ ...newState }) : this._initialState;
+    this._state = newState ? freeze({ ...newState }) : this._initialState;
     this._revision++;
-    this._asyncStates.clear();
-    this._asyncSnapshots.clear();
+    this._asyncStates?.clear();
+    this._asyncSnapshots?.clear();
     this._notifyAsync();
     this._trackSubscribables();
     for (const listener of this._listeners) {
@@ -206,16 +240,16 @@ class ViewModel {
       const self = this;
       this._asyncProxy = new Proxy({}, {
         get(_, prop) {
-          return self._asyncSnapshots.get(prop) ?? DEFAULT_TASK_STATE;
+          return self._asyncSnapshots?.get(prop) ?? DEFAULT_TASK_STATE;
         },
         has(_, prop) {
-          return self._asyncSnapshots.has(prop);
+          return self._asyncSnapshots?.has(prop) ?? false;
         },
         ownKeys() {
-          return Array.from(self._asyncSnapshots.keys());
+          return self._asyncSnapshots ? Array.from(self._asyncSnapshots.keys()) : [];
         },
         getOwnPropertyDescriptor(_, prop) {
-          if (self._asyncSnapshots.has(prop)) {
+          if (self._asyncSnapshots?.has(prop)) {
             return { configurable: true, enumerable: true, value: self._asyncSnapshots.get(prop) };
           }
           return void 0;
@@ -228,12 +262,14 @@ class ViewModel {
   subscribeAsync(listener) {
     if (this._disposed) return () => {
     };
+    if (!this._asyncListeners) this._asyncListeners = /* @__PURE__ */ new Set();
     this._asyncListeners.add(listener);
     return () => {
       this._asyncListeners.delete(listener);
     };
   }
   _notifyAsync() {
+    if (!this._asyncListeners) return;
     for (const listener of this._asyncListeners) {
       listener();
     }
@@ -248,195 +284,92 @@ class ViewModel {
     }
   }
   _guardReservedKeys() {
-    walkPrototypeChain.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.`
-        );
-      }
-    });
+    const info = getClassMemberInfo(this, ViewModel.prototype, RESERVED_ASYNC_KEYS, LIFECYCLE_HOOKS);
+    if (info.reservedKeys.length > 0) {
+      throw new Error(
+        `[mvc-kit] "${info.reservedKeys[0]}" 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.`
-        );
+  // ── Member processing (merged getter memoization + async method wrapping) ──
+  /**
+   * Uses cached class metadata to memoize getters (RFC 1) and delegates
+   * async method wrapping to the shared wrapAsyncMethods helper (RFC 2).
+   * Class metadata is computed once per class via getClassMemberInfo() and reused
+   * across all instances — avoids repeated prototype walks.
+   */
+  _processMembers() {
+    const info = getClassMemberInfo(this, ViewModel.prototype, RESERVED_ASYNC_KEYS, LIFECYCLE_HOOKS);
+    for (let i = 0; i < info.getters.length; i++) {
+      this._wrapGetter(info.getters[i].key, info.getters[i].get);
+    }
+    if (__DEV__) {
+      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 (info.methods.length === 0) return;
+    if (!this._asyncStates) this._asyncStates = /* @__PURE__ */ new Map();
+    if (!this._asyncSnapshots) this._asyncSnapshots = /* @__PURE__ */ new Map();
+    if (!this._asyncListeners) this._asyncListeners = /* @__PURE__ */ new Set();
     if (__DEV__) {
       this._activeOps = /* @__PURE__ */ new Map();
     }
-    walkPrototypeChain.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 (errors.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 = errors.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;
+    wrapAsyncMethods.wrapAsyncMethods({
+      instance: this,
+      stopPrototype: ViewModel.prototype,
+      reservedKeys: RESERVED_ASYNC_KEYS,
+      lifecycleHooks: LIFECYCLE_HOOKS,
+      isDisposed: () => this._disposed,
+      isInitialized: () => this._initialized,
+      asyncStates: this._asyncStates,
+      asyncSnapshots: this._asyncSnapshots,
+      asyncListeners: this._asyncListeners,
+      notifyAsync: () => this._notifyAsync(),
+      addCleanup: (fn) => this.addCleanup(fn),
+      ghostTimeout: this.constructor.GHOST_TIMEOUT,
+      className: "ViewModel",
+      activeOps: this._activeOps,
+      methods: info.methods
     });
-    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.
+   * that records which state properties are accessed. The Proxy is created
+   * lazily on first tracking access to keep init() fast.
    *
    * 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
-    });
+    let stateProxy = null;
     Object.defineProperty(this, "state", {
       get: () => {
-        if (this._stateTracking) return stateProxy;
+        if (this._stateTracking) {
+          if (!stateProxy) {
+            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
+            });
+          }
+          return stateProxy;
+        }
         return this._state;
       },
       configurable: true,
@@ -467,7 +400,6 @@ class ViewModel {
         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);
         }
@@ -493,22 +425,6 @@ class ViewModel {
       });
     }
   }
-  /**
-   * 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.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
@@ -522,27 +438,31 @@ class ViewModel {
   _wrapGetter(key, original) {
     let cached;
     let validatedAtRevision = -1;
-    let stateDeps;
-    let stateSnapshot;
-    let sourceDeps;
+    let stateDepKeys;
+    let stateDepValues;
+    let sourceDepKeys;
+    let sourceDepRevisions;
+    let trackingSet;
+    let trackingMap;
     Object.defineProperty(this, key, {
       get: () => {
-        if (this._disposed) return cached;
         if (validatedAtRevision === this._revision) {
           return cached;
         }
-        if (stateDeps && stateSnapshot) {
+        if (this._disposed) return cached;
+        if (stateDepKeys !== void 0) {
           let fresh = true;
-          for (const [k, v] of stateSnapshot) {
-            if (this._state[k] !== v) {
+          const state = this._state;
+          for (let i = 0; i < stateDepKeys.length; i++) {
+            if (state[stateDepKeys[i]] !== stateDepValues[i]) {
               fresh = false;
               break;
             }
           }
-          if (fresh && sourceDeps) {
-            for (const [memberKey, rev] of sourceDeps) {
-              const ts = this._trackedSources.get(memberKey);
-              if (ts && ts.revision !== rev) {
+          if (fresh && sourceDepKeys !== void 0 && sourceDepKeys.length > 0) {
+            for (let i = 0; i < sourceDepKeys.length; i++) {
+              const ts = this._trackedSources.get(sourceDepKeys[i]);
+              if (ts && ts.revision !== sourceDepRevisions[i]) {
                 fresh = false;
                 break;
               }
@@ -555,8 +475,18 @@ class ViewModel {
         }
         const parentStateTracking = this._stateTracking;
         const parentSourceTracking = this._sourceTracking;
-        this._stateTracking = /* @__PURE__ */ new Set();
-        this._sourceTracking = /* @__PURE__ */ new Map();
+        if (trackingSet) {
+          trackingSet.clear();
+        } else {
+          trackingSet = /* @__PURE__ */ new Set();
+        }
+        if (trackingMap) {
+          trackingMap.clear();
+        } else {
+          trackingMap = /* @__PURE__ */ new Map();
+        }
+        this._stateTracking = trackingSet;
+        this._sourceTracking = trackingMap;
         try {
           cached = original.call(this);
         } catch (e) {
@@ -564,25 +494,45 @@ class ViewModel {
           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);
+          for (const d of trackingSet) parentStateTracking.add(d);
         }
         if (parentSourceTracking) {
-          for (const [k, v] of capturedSourceDeps) {
+          for (const [k, v] of trackingMap) {
             parentSourceTracking.set(k, v);
           }
         }
-        stateSnapshot = /* @__PURE__ */ new Map();
-        for (const d of stateDeps) {
-          stateSnapshot.set(d, this._state[d]);
+        const depCount = trackingSet.size;
+        if (!stateDepKeys || stateDepKeys.length !== depCount) {
+          stateDepKeys = new Array(depCount);
+          stateDepValues = new Array(depCount);
         }
-        sourceDeps = /* @__PURE__ */ new Map();
-        for (const [memberKey, tracked] of capturedSourceDeps) {
-          sourceDeps.set(memberKey, tracked.revision);
+        {
+          let i = 0;
+          const state = this._state;
+          for (const d of trackingSet) {
+            stateDepKeys[i] = d;
+            stateDepValues[i] = state[d];
+            i++;
+          }
+        }
+        const sourceCount = trackingMap.size;
+        if (sourceCount > 0) {
+          if (!sourceDepKeys || sourceDepKeys.length !== sourceCount) {
+            sourceDepKeys = new Array(sourceCount);
+            sourceDepRevisions = new Array(sourceCount);
+          }
+          let i = 0;
+          for (const [memberKey, tracked] of trackingMap) {
+            sourceDepKeys[i] = memberKey;
+            sourceDepRevisions[i] = tracked.revision;
+            i++;
+          }
+        } else {
+          sourceDepKeys = void 0;
+          sourceDepRevisions = void 0;
         }
         validatedAtRevision = this._revision;
         return cached;