mvc-kit 2.7.0 → 2.8.0

package/dist/walkPrototypeChain.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"walkPrototypeChain.cjs","sources":["../src/walkPrototypeChain.ts"],"sourcesContent":["/**\n * Walk the prototype chain from `instance`'s class up to (but not including)\n * `stopAt`. Calls `visitor` for each own property descriptor found.\n *\n * Shared utility — used by ViewModel's _memoizeGetters() and _wrapMethods(),\n * and by Resource's _wrapMethods().\n */\nexport function walkPrototypeChain(\n  instance: object,\n  stopAt: object,\n  visitor: (key: string, desc: PropertyDescriptor, proto: object) => void,\n): void {\n  let proto = Object.getPrototypeOf(instance);\n  while (proto && proto !== stopAt) {\n    const descriptors = Object.getOwnPropertyDescriptors(proto);\n    for (const [key, desc] of Object.entries(descriptors)) {\n      if (key === 'constructor') continue;\n      visitor(key, desc, proto);\n    }\n    proto = Object.getPrototypeOf(proto);\n  }\n}\n"],"names":[],"mappings":";;AAOO,SAAS,mBACd,UACA,QACA,SACM;AACN,MAAI,QAAQ,OAAO,eAAe,QAAQ;AAC1C,SAAO,SAAS,UAAU,QAAQ;AAChC,UAAM,cAAc,OAAO,0BAA0B,KAAK;AAC1D,eAAW,CAAC,KAAK,IAAI,KAAK,OAAO,QAAQ,WAAW,GAAG;AACrD,UAAI,QAAQ,cAAe;AAC3B,cAAQ,KAAK,MAAM,KAAK;AAAA,IAC1B;AACA,YAAQ,OAAO,eAAe,KAAK;AAAA,EACrC;AACF;;"}
+{"version":3,"file":"walkPrototypeChain.cjs","sources":["../src/walkPrototypeChain.ts"],"sourcesContent":["/**\n * Walk the prototype chain from `instance`'s class up to (but not including)\n * `stopAt`. Calls `visitor` for each own property descriptor found.\n *\n * Shared utility — used by ViewModel's _processMembers(), wrapAsyncMethods(),\n * and ViewModel/Resource's _guardReservedKeys().\n */\nexport function walkPrototypeChain(\n  instance: object,\n  stopAt: object,\n  visitor: (key: string, desc: PropertyDescriptor, proto: object) => void,\n): void {\n  let proto = Object.getPrototypeOf(instance);\n  while (proto && proto !== stopAt) {\n    const descriptors = Object.getOwnPropertyDescriptors(proto);\n    for (const [key, desc] of Object.entries(descriptors)) {\n      if (key === 'constructor') continue;\n      visitor(key, desc, proto);\n    }\n    proto = Object.getPrototypeOf(proto);\n  }\n}\n"],"names":[],"mappings":";;AAOO,SAAS,mBACd,UACA,QACA,SACM;AACN,MAAI,QAAQ,OAAO,eAAe,QAAQ;AAC1C,SAAO,SAAS,UAAU,QAAQ;AAChC,UAAM,cAAc,OAAO,0BAA0B,KAAK;AAC1D,eAAW,CAAC,KAAK,IAAI,KAAK,OAAO,QAAQ,WAAW,GAAG;AACrD,UAAI,QAAQ,cAAe;AAC3B,cAAQ,KAAK,MAAM,KAAK;AAAA,IAC1B;AACA,YAAQ,OAAO,eAAe,KAAK;AAAA,EACrC;AACF;;"}

package/dist/walkPrototypeChain.d.ts

@@ -2,8 +2,8 @@
  * Walk the prototype chain from `instance`'s class up to (but not including)
  * `stopAt`. Calls `visitor` for each own property descriptor found.
  *
- * Shared utility — used by ViewModel's _memoizeGetters() and _wrapMethods(),
- * and by Resource's _wrapMethods().
+ * Shared utility — used by ViewModel's _processMembers(), wrapAsyncMethods(),
+ * and ViewModel/Resource's _guardReservedKeys().
  */
 export declare function walkPrototypeChain(instance: object, stopAt: object, visitor: (key: string, desc: PropertyDescriptor, proto: object) => void): void;
 //# sourceMappingURL=walkPrototypeChain.d.ts.map

package/dist/walkPrototypeChain.js.map

@@ -1 +1 @@
-{"version":3,"file":"walkPrototypeChain.js","sources":["../src/walkPrototypeChain.ts"],"sourcesContent":["/**\n * Walk the prototype chain from `instance`'s class up to (but not including)\n * `stopAt`. Calls `visitor` for each own property descriptor found.\n *\n * Shared utility — used by ViewModel's _memoizeGetters() and _wrapMethods(),\n * and by Resource's _wrapMethods().\n */\nexport function walkPrototypeChain(\n  instance: object,\n  stopAt: object,\n  visitor: (key: string, desc: PropertyDescriptor, proto: object) => void,\n): void {\n  let proto = Object.getPrototypeOf(instance);\n  while (proto && proto !== stopAt) {\n    const descriptors = Object.getOwnPropertyDescriptors(proto);\n    for (const [key, desc] of Object.entries(descriptors)) {\n      if (key === 'constructor') continue;\n      visitor(key, desc, proto);\n    }\n    proto = Object.getPrototypeOf(proto);\n  }\n}\n"],"names":[],"mappings":"AAOO,SAAS,mBACd,UACA,QACA,SACM;AACN,MAAI,QAAQ,OAAO,eAAe,QAAQ;AAC1C,SAAO,SAAS,UAAU,QAAQ;AAChC,UAAM,cAAc,OAAO,0BAA0B,KAAK;AAC1D,eAAW,CAAC,KAAK,IAAI,KAAK,OAAO,QAAQ,WAAW,GAAG;AACrD,UAAI,QAAQ,cAAe;AAC3B,cAAQ,KAAK,MAAM,KAAK;AAAA,IAC1B;AACA,YAAQ,OAAO,eAAe,KAAK;AAAA,EACrC;AACF;"}
+{"version":3,"file":"walkPrototypeChain.js","sources":["../src/walkPrototypeChain.ts"],"sourcesContent":["/**\n * Walk the prototype chain from `instance`'s class up to (but not including)\n * `stopAt`. Calls `visitor` for each own property descriptor found.\n *\n * Shared utility — used by ViewModel's _processMembers(), wrapAsyncMethods(),\n * and ViewModel/Resource's _guardReservedKeys().\n */\nexport function walkPrototypeChain(\n  instance: object,\n  stopAt: object,\n  visitor: (key: string, desc: PropertyDescriptor, proto: object) => void,\n): void {\n  let proto = Object.getPrototypeOf(instance);\n  while (proto && proto !== stopAt) {\n    const descriptors = Object.getOwnPropertyDescriptors(proto);\n    for (const [key, desc] of Object.entries(descriptors)) {\n      if (key === 'constructor') continue;\n      visitor(key, desc, proto);\n    }\n    proto = Object.getPrototypeOf(proto);\n  }\n}\n"],"names":[],"mappings":"AAOO,SAAS,mBACd,UACA,QACA,SACM;AACN,MAAI,QAAQ,OAAO,eAAe,QAAQ;AAC1C,SAAO,SAAS,UAAU,QAAQ;AAChC,UAAM,cAAc,OAAO,0BAA0B,KAAK;AAC1D,eAAW,CAAC,KAAK,IAAI,KAAK,OAAO,QAAQ,WAAW,GAAG;AACrD,UAAI,QAAQ,cAAe;AAC3B,cAAQ,KAAK,MAAM,KAAK;AAAA,IAC1B;AACA,YAAQ,OAAO,eAAe,KAAK;AAAA,EACrC;AACF;"}

package/dist/wrapAsyncMethods.cjs

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const errors = require("./errors.cjs");
+const walkPrototypeChain = require("./walkPrototypeChain.cjs");
+const __DEV__ = typeof __MVC_KIT_DEV__ !== "undefined" && __MVC_KIT_DEV__;
+const LOADING_TASK_STATE = Object.freeze({ loading: true, error: null, errorCode: null });
+function wrapAsyncMethods(ctx) {
+  const {
+    instance,
+    stopPrototype,
+    reservedKeys,
+    lifecycleHooks,
+    isDisposed,
+    isInitialized,
+    asyncStates,
+    asyncSnapshots,
+    asyncListeners,
+    notifyAsync,
+    addCleanup,
+    ghostTimeout,
+    className,
+    activeOps
+  } = ctx;
+  if (__DEV__) {
+    for (const key of reservedKeys) {
+      if (Object.getOwnPropertyDescriptor(instance, key)?.value !== void 0) {
+        throw new Error(
+          `[mvc-kit] "${key}" is a reserved property on ${className} and cannot be overridden.`
+        );
+      }
+    }
+  }
+  const methodEntries = ctx.methods ?? (() => {
+    const result = [];
+    const processed = /* @__PURE__ */ new Set();
+    walkPrototypeChain.walkPrototypeChain(instance, stopPrototype, (key, desc) => {
+      if (desc.get || desc.set) return;
+      if (typeof desc.value !== "function") return;
+      if (key.startsWith("_")) return;
+      if (lifecycleHooks.has(key)) return;
+      if (processed.has(key)) return;
+      processed.add(key);
+      result.push({ key, fn: desc.value });
+    });
+    return result;
+  })();
+  const wrappedKeys = [];
+  for (const { key, fn: original } of methodEntries) {
+    let pruned = false;
+    const wrapper = function(...args) {
+      if (isDisposed()) {
+        if (__DEV__) {
+          console.warn(`[mvc-kit] "${key}" called after dispose — ignored.`);
+        }
+        return void 0;
+      }
+      if (__DEV__ && !isInitialized()) {
+        console.warn(
+          `[mvc-kit] "${key}" called before init(). Async tracking is active only after init().`
+        );
+      }
+      let result;
+      try {
+        result = original.apply(instance, args);
+      } catch (e) {
+        throw e;
+      }
+      if (!result || typeof result.then !== "function") {
+        if (!pruned) {
+          pruned = true;
+          asyncStates.delete(key);
+          asyncSnapshots.delete(key);
+          instance[key] = original.bind(instance);
+        }
+        return result;
+      }
+      let internal = asyncStates.get(key);
+      if (!internal) {
+        internal = { loading: false, error: null, errorCode: null, count: 0 };
+        asyncStates.set(key, internal);
+      }
+      internal.count++;
+      internal.loading = true;
+      internal.error = null;
+      internal.errorCode = null;
+      asyncSnapshots.set(key, LOADING_TASK_STATE);
+      notifyAsync();
+      if (__DEV__ && activeOps) {
+        activeOps.set(key, (activeOps.get(key) ?? 0) + 1);
+      }
+      return result.then(
+        (value) => {
+          if (isDisposed()) return value;
+          internal.count--;
+          internal.loading = internal.count > 0;
+          asyncSnapshots.set(
+            key,
+            Object.freeze({ loading: internal.loading, error: internal.error, errorCode: internal.errorCode })
+          );
+          notifyAsync();
+          if (__DEV__ && activeOps) {
+            const c = (activeOps.get(key) ?? 1) - 1;
+            if (c <= 0) activeOps.delete(key);
+            else activeOps.set(key, c);
+          }
+          return value;
+        },
+        (error) => {
+          if (errors.isAbortError(error)) {
+            if (!isDisposed()) {
+              internal.count--;
+              internal.loading = internal.count > 0;
+              asyncSnapshots.set(
+                key,
+                Object.freeze({ loading: internal.loading, error: internal.error, errorCode: internal.errorCode })
+              );
+              notifyAsync();
+            }
+            if (__DEV__ && activeOps) {
+              const c = (activeOps.get(key) ?? 1) - 1;
+              if (c <= 0) activeOps.delete(key);
+              else activeOps.set(key, c);
+            }
+            return void 0;
+          }
+          if (isDisposed()) return void 0;
+          internal.count--;
+          internal.loading = internal.count > 0;
+          const classified = errors.classifyError(error);
+          internal.error = classified.message;
+          internal.errorCode = classified.code;
+          asyncSnapshots.set(
+            key,
+            Object.freeze({ loading: internal.loading, error: classified.message, errorCode: classified.code })
+          );
+          notifyAsync();
+          if (__DEV__ && activeOps) {
+            const c = (activeOps.get(key) ?? 1) - 1;
+            if (c <= 0) activeOps.delete(key);
+            else activeOps.set(key, c);
+          }
+          throw error;
+        }
+      );
+    };
+    wrappedKeys.push(key);
+    instance[key] = wrapper;
+  }
+  if (wrappedKeys.length > 0) {
+    addCleanup(() => {
+      const opsSnapshot = __DEV__ && activeOps ? new Map(activeOps) : null;
+      for (const k of wrappedKeys) {
+        if (__DEV__) {
+          instance[k] = () => {
+            console.warn(`[mvc-kit] "${k}" called after dispose — ignored.`);
+            return void 0;
+          };
+        } else {
+          instance[k] = () => void 0;
+        }
+      }
+      asyncListeners.clear();
+      asyncStates.clear();
+      asyncSnapshots.clear();
+      if (__DEV__ && opsSnapshot && opsSnapshot.size > 0) {
+        setTimeout(() => {
+          for (const [key, count] of opsSnapshot) {
+            console.warn(
+              `[mvc-kit] Ghost async operation detected: "${key}" had ${count} pending call(s) when the ${className} was disposed. Consider using disposeSignal to cancel in-flight work.`
+            );
+          }
+        }, ghostTimeout);
+      }
+    });
+  }
+  return wrappedKeys;
+}
+exports.wrapAsyncMethods = wrapAsyncMethods;
+//# sourceMappingURL=wrapAsyncMethods.cjs.map

package/dist/wrapAsyncMethods.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapAsyncMethods.cjs","sources":["../src/wrapAsyncMethods.ts"],"sourcesContent":["import { isAbortError, classifyError } from './errors';\nimport { walkPrototypeChain } from './walkPrototypeChain';\nimport type { TaskState } from './types';\n\nconst __DEV__ = typeof __MVC_KIT_DEV__ !== 'undefined' && __MVC_KIT_DEV__;\n\nconst LOADING_TASK_STATE: TaskState = Object.freeze({ loading: true, error: null, errorCode: null });\n\nexport interface InternalTaskState {\n  loading: boolean;\n  error: string | null;\n  errorCode: TaskState['errorCode'];\n  count: number;\n}\n\nexport interface AsyncTrackingContext {\n  instance: object;\n  stopPrototype: object;\n  reservedKeys: readonly string[];\n  lifecycleHooks: Set<string>;\n  isDisposed: () => boolean;\n  isInitialized: () => boolean;\n  asyncStates: Map<string, InternalTaskState>;\n  asyncSnapshots: Map<string, TaskState>;\n  asyncListeners: Set<() => void>;\n  notifyAsync: () => void;\n  addCleanup: (fn: () => void) => void;\n  ghostTimeout: number;\n  className: string;\n  activeOps: Map<string, number> | null;\n  /** Pre-scanned methods from class metadata cache. When provided, skips prototype walk. */\n  methods?: Array<{ key: string; fn: Function }>;\n}\n\n/**\n * Shared async method wrapping logic used by both ViewModel and Resource.\n * Walks the prototype chain, wraps methods with async tracking, and registers cleanup.\n * Returns the list of wrapped method keys.\n */\nexport function wrapAsyncMethods(ctx: AsyncTrackingContext): string[] {\n  const {\n    instance,\n    stopPrototype,\n    reservedKeys,\n    lifecycleHooks,\n    isDisposed,\n    isInitialized,\n    asyncStates,\n    asyncSnapshots,\n    asyncListeners,\n    notifyAsync,\n    addCleanup,\n    ghostTimeout,\n    className,\n    activeOps,\n  } = ctx;\n\n  // Instance property reserved key check (DEV-only — prototype check in constructor catches most cases)\n  if (__DEV__) {\n    for (const key of reservedKeys) {\n      if (Object.getOwnPropertyDescriptor(instance, key)?.value !== undefined) {\n        throw new Error(\n          `[mvc-kit] \"${key}\" is a reserved property on ${className} and cannot be overridden.`\n        );\n      }\n    }\n  }\n\n  // Use pre-scanned methods from class metadata cache, or walk prototype chain\n  const methodEntries: Array<{ key: string; fn: Function }> = ctx.methods ?? (() => {\n    const result: Array<{ key: string; fn: Function }> = [];\n    const processed = new Set<string>();\n    walkPrototypeChain(instance, stopPrototype, (key, desc) => {\n      if (desc.get || desc.set) return;\n      if (typeof desc.value !== 'function') return;\n      if (key.startsWith('_')) return;\n      if (lifecycleHooks.has(key)) return;\n      if (processed.has(key)) return;\n      processed.add(key);\n      result.push({ key, fn: desc.value });\n    });\n    return result;\n  })();\n\n  const wrappedKeys: string[] = [];\n\n  for (const { key, fn: original } of methodEntries) {\n    let pruned = false;\n\n    const wrapper = function (this: any, ...args: unknown[]) {\n      // Disposed guard\n      if (isDisposed()) {\n        if (__DEV__) {\n          console.warn(`[mvc-kit] \"${key}\" called after dispose — ignored.`);\n        }\n        return undefined;\n      }\n\n      // Pre-init guard (DEV only — method still executes)\n      if (__DEV__ && !isInitialized()) {\n        console.warn(\n          `[mvc-kit] \"${key}\" called before init(). ` +\n          `Async tracking is active only after init().`\n        );\n      }\n\n      let result: unknown;\n      try {\n        result = original.apply(instance, args);\n      } catch (e) {\n        // Sync throw — not tracked as async\n        throw e;\n      }\n\n      // Sync detection: if not thenable, prune from async tracking\n      if (!result || typeof (result as any).then !== 'function') {\n        if (!pruned) {\n          pruned = true;\n          // Remove from async maps\n          asyncStates.delete(key);\n          asyncSnapshots.delete(key);\n          // Replace wrapper with bound original for zero overhead\n          (instance as any)[key] = original.bind(instance);\n        }\n        return result;\n      }\n\n      // ── Async tracking ──────────────────────────────────────\n      let internal = asyncStates.get(key);\n      if (!internal) {\n        internal = { loading: false, error: null, errorCode: null, count: 0 };\n        asyncStates.set(key, internal);\n      }\n\n      internal.count++;\n      internal.loading = true;\n      internal.error = null;\n      internal.errorCode = null;\n      asyncSnapshots.set(key, LOADING_TASK_STATE);\n      notifyAsync();\n\n      if (__DEV__ && activeOps) {\n        activeOps.set(key, (activeOps.get(key) ?? 0) + 1);\n      }\n\n      return (result as Promise<unknown>).then(\n        (value) => {\n          if (isDisposed()) return value;\n\n          internal!.count--;\n          internal!.loading = internal!.count > 0;\n          asyncSnapshots.set(\n            key,\n            Object.freeze({ loading: internal!.loading, error: internal!.error, errorCode: internal!.errorCode }),\n          );\n          notifyAsync();\n\n          if (__DEV__ && activeOps) {\n            const c = (activeOps.get(key) ?? 1) - 1;\n            if (c <= 0) activeOps.delete(key);\n            else activeOps.set(key, c);\n          }\n\n          return value;\n        },\n        (error) => {\n          // AbortError — silently swallow\n          if (isAbortError(error)) {\n            if (!isDisposed()) {\n              internal!.count--;\n              internal!.loading = internal!.count > 0;\n              asyncSnapshots.set(\n                key,\n                Object.freeze({ loading: internal!.loading, error: internal!.error, errorCode: internal!.errorCode }),\n              );\n              notifyAsync();\n            }\n\n            if (__DEV__ && activeOps) {\n              const c = (activeOps.get(key) ?? 1) - 1;\n              if (c <= 0) activeOps.delete(key);\n              else activeOps.set(key, c);\n            }\n\n            return undefined;\n          }\n\n          // Disposed — fizzle silently\n          if (isDisposed()) return undefined;\n\n          internal!.count--;\n          internal!.loading = internal!.count > 0;\n          const classified = classifyError(error);\n          internal!.error = classified.message;\n          internal!.errorCode = classified.code;\n          asyncSnapshots.set(\n            key,\n            Object.freeze({ loading: internal!.loading, error: classified.message, errorCode: classified.code }),\n          );\n          notifyAsync();\n\n          if (__DEV__ && activeOps) {\n            const c = (activeOps.get(key) ?? 1) - 1;\n            if (c <= 0) activeOps.delete(key);\n            else activeOps.set(key, c);\n          }\n\n          // Re-throw to preserve standard Promise rejection\n          throw error;\n        },\n      );\n    };\n\n    wrappedKeys.push(key);\n    (instance as any)[key] = wrapper;\n  }\n\n  // Register cleanup for disposal\n  if (wrappedKeys.length > 0) {\n    addCleanup(() => {\n      // Snapshot active ops for ghost check before clearing\n      const opsSnapshot = __DEV__ && activeOps ? new Map(activeOps) : null;\n\n      // Swap all wrapped methods to no-ops (with DEV warning)\n      for (const k of wrappedKeys) {\n        if (__DEV__) {\n          (instance as any)[k] = () => {\n            console.warn(`[mvc-kit] \"${k}\" called after dispose — ignored.`);\n            return undefined;\n          };\n        } else {\n          (instance as any)[k] = () => undefined;\n        }\n      }\n\n      // Clear async state\n      asyncListeners.clear();\n      asyncStates.clear();\n      asyncSnapshots.clear();\n\n      // DEV: schedule ghost check\n      if (__DEV__ && opsSnapshot && opsSnapshot.size > 0) {\n        setTimeout(() => {\n          for (const [key, count] of opsSnapshot) {\n            console.warn(\n              `[mvc-kit] Ghost async operation detected: \"${key}\" had ${count} ` +\n              `pending call(s) when the ${className} was disposed. ` +\n              `Consider using disposeSignal to cancel in-flight work.`\n            );\n          }\n        }, ghostTimeout);\n      }\n    });\n  }\n\n  return wrappedKeys;\n}\n"],"names":["walkPrototypeChain","isAbortError","classifyError"],"mappings":"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"}

package/dist/wrapAsyncMethods.d.ts

@@ -0,0 +1,35 @@
+import type { TaskState } from './types';
+export interface InternalTaskState {
+    loading: boolean;
+    error: string | null;
+    errorCode: TaskState['errorCode'];
+    count: number;
+}
+export interface AsyncTrackingContext {
+    instance: object;
+    stopPrototype: object;
+    reservedKeys: readonly string[];
+    lifecycleHooks: Set<string>;
+    isDisposed: () => boolean;
+    isInitialized: () => boolean;
+    asyncStates: Map<string, InternalTaskState>;
+    asyncSnapshots: Map<string, TaskState>;
+    asyncListeners: Set<() => void>;
+    notifyAsync: () => void;
+    addCleanup: (fn: () => void) => void;
+    ghostTimeout: number;
+    className: string;
+    activeOps: Map<string, number> | null;
+    /** Pre-scanned methods from class metadata cache. When provided, skips prototype walk. */
+    methods?: Array<{
+        key: string;
+        fn: Function;
+    }>;
+}
+/**
+ * Shared async method wrapping logic used by both ViewModel and Resource.
+ * Walks the prototype chain, wraps methods with async tracking, and registers cleanup.
+ * Returns the list of wrapped method keys.
+ */
+export declare function wrapAsyncMethods(ctx: AsyncTrackingContext): string[];
+//# sourceMappingURL=wrapAsyncMethods.d.ts.map

package/dist/wrapAsyncMethods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapAsyncMethods.d.ts","sourceRoot":"","sources":["../src/wrapAsyncMethods.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAMzC,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,SAAS,EAAE,SAAS,CAAC,WAAW,CAAC,CAAC;IAClC,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC5B,UAAU,EAAE,MAAM,OAAO,CAAC;IAC1B,aAAa,EAAE,MAAM,OAAO,CAAC;IAC7B,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;IAC5C,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACvC,cAAc,EAAE,GAAG,CAAC,MAAM,IAAI,CAAC,CAAC;IAChC,WAAW,EAAE,MAAM,IAAI,CAAC;IACxB,UAAU,EAAE,CAAC,EAAE,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;IACrC,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IACtC,0FAA0F;IAC1F,OAAO,CAAC,EAAE,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,QAAQ,CAAA;KAAE,CAAC,CAAC;CAChD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,oBAAoB,GAAG,MAAM,EAAE,CAyNpE"}

package/dist/wrapAsyncMethods.js

@@ -0,0 +1,179 @@
+import { isAbortError, classifyError } from "./errors.js";
+import { walkPrototypeChain } from "./walkPrototypeChain.js";
+const __DEV__ = typeof __MVC_KIT_DEV__ !== "undefined" && __MVC_KIT_DEV__;
+const LOADING_TASK_STATE = Object.freeze({ loading: true, error: null, errorCode: null });
+function wrapAsyncMethods(ctx) {
+  const {
+    instance,
+    stopPrototype,
+    reservedKeys,
+    lifecycleHooks,
+    isDisposed,
+    isInitialized,
+    asyncStates,
+    asyncSnapshots,
+    asyncListeners,
+    notifyAsync,
+    addCleanup,
+    ghostTimeout,
+    className,
+    activeOps
+  } = ctx;
+  if (__DEV__) {
+    for (const key of reservedKeys) {
+      if (Object.getOwnPropertyDescriptor(instance, key)?.value !== void 0) {
+        throw new Error(
+          `[mvc-kit] "${key}" is a reserved property on ${className} and cannot be overridden.`
+        );
+      }
+    }
+  }
+  const methodEntries = ctx.methods ?? (() => {
+    const result = [];
+    const processed = /* @__PURE__ */ new Set();
+    walkPrototypeChain(instance, stopPrototype, (key, desc) => {
+      if (desc.get || desc.set) return;
+      if (typeof desc.value !== "function") return;
+      if (key.startsWith("_")) return;
+      if (lifecycleHooks.has(key)) return;
+      if (processed.has(key)) return;
+      processed.add(key);
+      result.push({ key, fn: desc.value });
+    });
+    return result;
+  })();
+  const wrappedKeys = [];
+  for (const { key, fn: original } of methodEntries) {
+    let pruned = false;
+    const wrapper = function(...args) {
+      if (isDisposed()) {
+        if (__DEV__) {
+          console.warn(`[mvc-kit] "${key}" called after dispose — ignored.`);
+        }
+        return void 0;
+      }
+      if (__DEV__ && !isInitialized()) {
+        console.warn(
+          `[mvc-kit] "${key}" called before init(). Async tracking is active only after init().`
+        );
+      }
+      let result;
+      try {
+        result = original.apply(instance, args);
+      } catch (e) {
+        throw e;
+      }
+      if (!result || typeof result.then !== "function") {
+        if (!pruned) {
+          pruned = true;
+          asyncStates.delete(key);
+          asyncSnapshots.delete(key);
+          instance[key] = original.bind(instance);
+        }
+        return result;
+      }
+      let internal = asyncStates.get(key);
+      if (!internal) {
+        internal = { loading: false, error: null, errorCode: null, count: 0 };
+        asyncStates.set(key, internal);
+      }
+      internal.count++;
+      internal.loading = true;
+      internal.error = null;
+      internal.errorCode = null;
+      asyncSnapshots.set(key, LOADING_TASK_STATE);
+      notifyAsync();
+      if (__DEV__ && activeOps) {
+        activeOps.set(key, (activeOps.get(key) ?? 0) + 1);
+      }
+      return result.then(
+        (value) => {
+          if (isDisposed()) return value;
+          internal.count--;
+          internal.loading = internal.count > 0;
+          asyncSnapshots.set(
+            key,
+            Object.freeze({ loading: internal.loading, error: internal.error, errorCode: internal.errorCode })
+          );
+          notifyAsync();
+          if (__DEV__ && activeOps) {
+            const c = (activeOps.get(key) ?? 1) - 1;
+            if (c <= 0) activeOps.delete(key);
+            else activeOps.set(key, c);
+          }
+          return value;
+        },
+        (error) => {
+          if (isAbortError(error)) {
+            if (!isDisposed()) {
+              internal.count--;
+              internal.loading = internal.count > 0;
+              asyncSnapshots.set(
+                key,
+                Object.freeze({ loading: internal.loading, error: internal.error, errorCode: internal.errorCode })
+              );
+              notifyAsync();
+            }
+            if (__DEV__ && activeOps) {
+              const c = (activeOps.get(key) ?? 1) - 1;
+              if (c <= 0) activeOps.delete(key);
+              else activeOps.set(key, c);
+            }
+            return void 0;
+          }
+          if (isDisposed()) return void 0;
+          internal.count--;
+          internal.loading = internal.count > 0;
+          const classified = classifyError(error);
+          internal.error = classified.message;
+          internal.errorCode = classified.code;
+          asyncSnapshots.set(
+            key,
+            Object.freeze({ loading: internal.loading, error: classified.message, errorCode: classified.code })
+          );
+          notifyAsync();
+          if (__DEV__ && activeOps) {
+            const c = (activeOps.get(key) ?? 1) - 1;
+            if (c <= 0) activeOps.delete(key);
+            else activeOps.set(key, c);
+          }
+          throw error;
+        }
+      );
+    };
+    wrappedKeys.push(key);
+    instance[key] = wrapper;
+  }
+  if (wrappedKeys.length > 0) {
+    addCleanup(() => {
+      const opsSnapshot = __DEV__ && activeOps ? new Map(activeOps) : null;
+      for (const k of wrappedKeys) {
+        if (__DEV__) {
+          instance[k] = () => {
+            console.warn(`[mvc-kit] "${k}" called after dispose — ignored.`);
+            return void 0;
+          };
+        } else {
+          instance[k] = () => void 0;
+        }
+      }
+      asyncListeners.clear();
+      asyncStates.clear();
+      asyncSnapshots.clear();
+      if (__DEV__ && opsSnapshot && opsSnapshot.size > 0) {
+        setTimeout(() => {
+          for (const [key, count] of opsSnapshot) {
+            console.warn(
+              `[mvc-kit] Ghost async operation detected: "${key}" had ${count} pending call(s) when the ${className} was disposed. Consider using disposeSignal to cancel in-flight work.`
+            );
+          }
+        }, ghostTimeout);
+      }
+    });
+  }
+  return wrappedKeys;
+}
+export {
+  wrapAsyncMethods
+};
+//# sourceMappingURL=wrapAsyncMethods.js.map

package/dist/wrapAsyncMethods.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapAsyncMethods.js","sources":["../src/wrapAsyncMethods.ts"],"sourcesContent":["import { isAbortError, classifyError } from './errors';\nimport { walkPrototypeChain } from './walkPrototypeChain';\nimport type { TaskState } from './types';\n\nconst __DEV__ = typeof __MVC_KIT_DEV__ !== 'undefined' && __MVC_KIT_DEV__;\n\nconst LOADING_TASK_STATE: TaskState = Object.freeze({ loading: true, error: null, errorCode: null });\n\nexport interface InternalTaskState {\n  loading: boolean;\n  error: string | null;\n  errorCode: TaskState['errorCode'];\n  count: number;\n}\n\nexport interface AsyncTrackingContext {\n  instance: object;\n  stopPrototype: object;\n  reservedKeys: readonly string[];\n  lifecycleHooks: Set<string>;\n  isDisposed: () => boolean;\n  isInitialized: () => boolean;\n  asyncStates: Map<string, InternalTaskState>;\n  asyncSnapshots: Map<string, TaskState>;\n  asyncListeners: Set<() => void>;\n  notifyAsync: () => void;\n  addCleanup: (fn: () => void) => void;\n  ghostTimeout: number;\n  className: string;\n  activeOps: Map<string, number> | null;\n  /** Pre-scanned methods from class metadata cache. When provided, skips prototype walk. */\n  methods?: Array<{ key: string; fn: Function }>;\n}\n\n/**\n * Shared async method wrapping logic used by both ViewModel and Resource.\n * Walks the prototype chain, wraps methods with async tracking, and registers cleanup.\n * Returns the list of wrapped method keys.\n */\nexport function wrapAsyncMethods(ctx: AsyncTrackingContext): string[] {\n  const {\n    instance,\n    stopPrototype,\n    reservedKeys,\n    lifecycleHooks,\n    isDisposed,\n    isInitialized,\n    asyncStates,\n    asyncSnapshots,\n    asyncListeners,\n    notifyAsync,\n    addCleanup,\n    ghostTimeout,\n    className,\n    activeOps,\n  } = ctx;\n\n  // Instance property reserved key check (DEV-only — prototype check in constructor catches most cases)\n  if (__DEV__) {\n    for (const key of reservedKeys) {\n      if (Object.getOwnPropertyDescriptor(instance, key)?.value !== undefined) {\n        throw new Error(\n          `[mvc-kit] \"${key}\" is a reserved property on ${className} and cannot be overridden.`\n        );\n      }\n    }\n  }\n\n  // Use pre-scanned methods from class metadata cache, or walk prototype chain\n  const methodEntries: Array<{ key: string; fn: Function }> = ctx.methods ?? (() => {\n    const result: Array<{ key: string; fn: Function }> = [];\n    const processed = new Set<string>();\n    walkPrototypeChain(instance, stopPrototype, (key, desc) => {\n      if (desc.get || desc.set) return;\n      if (typeof desc.value !== 'function') return;\n      if (key.startsWith('_')) return;\n      if (lifecycleHooks.has(key)) return;\n      if (processed.has(key)) return;\n      processed.add(key);\n      result.push({ key, fn: desc.value });\n    });\n    return result;\n  })();\n\n  const wrappedKeys: string[] = [];\n\n  for (const { key, fn: original } of methodEntries) {\n    let pruned = false;\n\n    const wrapper = function (this: any, ...args: unknown[]) {\n      // Disposed guard\n      if (isDisposed()) {\n        if (__DEV__) {\n          console.warn(`[mvc-kit] \"${key}\" called after dispose — ignored.`);\n        }\n        return undefined;\n      }\n\n      // Pre-init guard (DEV only — method still executes)\n      if (__DEV__ && !isInitialized()) {\n        console.warn(\n          `[mvc-kit] \"${key}\" called before init(). ` +\n          `Async tracking is active only after init().`\n        );\n      }\n\n      let result: unknown;\n      try {\n        result = original.apply(instance, args);\n      } catch (e) {\n        // Sync throw — not tracked as async\n        throw e;\n      }\n\n      // Sync detection: if not thenable, prune from async tracking\n      if (!result || typeof (result as any).then !== 'function') {\n        if (!pruned) {\n          pruned = true;\n          // Remove from async maps\n          asyncStates.delete(key);\n          asyncSnapshots.delete(key);\n          // Replace wrapper with bound original for zero overhead\n          (instance as any)[key] = original.bind(instance);\n        }\n        return result;\n      }\n\n      // ── Async tracking ──────────────────────────────────────\n      let internal = asyncStates.get(key);\n      if (!internal) {\n        internal = { loading: false, error: null, errorCode: null, count: 0 };\n        asyncStates.set(key, internal);\n      }\n\n      internal.count++;\n      internal.loading = true;\n      internal.error = null;\n      internal.errorCode = null;\n      asyncSnapshots.set(key, LOADING_TASK_STATE);\n      notifyAsync();\n\n      if (__DEV__ && activeOps) {\n        activeOps.set(key, (activeOps.get(key) ?? 0) + 1);\n      }\n\n      return (result as Promise<unknown>).then(\n        (value) => {\n          if (isDisposed()) return value;\n\n          internal!.count--;\n          internal!.loading = internal!.count > 0;\n          asyncSnapshots.set(\n            key,\n            Object.freeze({ loading: internal!.loading, error: internal!.error, errorCode: internal!.errorCode }),\n          );\n          notifyAsync();\n\n          if (__DEV__ && activeOps) {\n            const c = (activeOps.get(key) ?? 1) - 1;\n            if (c <= 0) activeOps.delete(key);\n            else activeOps.set(key, c);\n          }\n\n          return value;\n        },\n        (error) => {\n          // AbortError — silently swallow\n          if (isAbortError(error)) {\n            if (!isDisposed()) {\n              internal!.count--;\n              internal!.loading = internal!.count > 0;\n              asyncSnapshots.set(\n                key,\n                Object.freeze({ loading: internal!.loading, error: internal!.error, errorCode: internal!.errorCode }),\n              );\n              notifyAsync();\n            }\n\n            if (__DEV__ && activeOps) {\n              const c = (activeOps.get(key) ?? 1) - 1;\n              if (c <= 0) activeOps.delete(key);\n              else activeOps.set(key, c);\n            }\n\n            return undefined;\n          }\n\n          // Disposed — fizzle silently\n          if (isDisposed()) return undefined;\n\n          internal!.count--;\n          internal!.loading = internal!.count > 0;\n          const classified = classifyError(error);\n          internal!.error = classified.message;\n          internal!.errorCode = classified.code;\n          asyncSnapshots.set(\n            key,\n            Object.freeze({ loading: internal!.loading, error: classified.message, errorCode: classified.code }),\n          );\n          notifyAsync();\n\n          if (__DEV__ && activeOps) {\n            const c = (activeOps.get(key) ?? 1) - 1;\n            if (c <= 0) activeOps.delete(key);\n            else activeOps.set(key, c);\n          }\n\n          // Re-throw to preserve standard Promise rejection\n          throw error;\n        },\n      );\n    };\n\n    wrappedKeys.push(key);\n    (instance as any)[key] = wrapper;\n  }\n\n  // Register cleanup for disposal\n  if (wrappedKeys.length > 0) {\n    addCleanup(() => {\n      // Snapshot active ops for ghost check before clearing\n      const opsSnapshot = __DEV__ && activeOps ? new Map(activeOps) : null;\n\n      // Swap all wrapped methods to no-ops (with DEV warning)\n      for (const k of wrappedKeys) {\n        if (__DEV__) {\n          (instance as any)[k] = () => {\n            console.warn(`[mvc-kit] \"${k}\" called after dispose — ignored.`);\n            return undefined;\n          };\n        } else {\n          (instance as any)[k] = () => undefined;\n        }\n      }\n\n      // Clear async state\n      asyncListeners.clear();\n      asyncStates.clear();\n      asyncSnapshots.clear();\n\n      // DEV: schedule ghost check\n      if (__DEV__ && opsSnapshot && opsSnapshot.size > 0) {\n        setTimeout(() => {\n          for (const [key, count] of opsSnapshot) {\n            console.warn(\n              `[mvc-kit] Ghost async operation detected: \"${key}\" had ${count} ` +\n              `pending call(s) when the ${className} was disposed. ` +\n              `Consider using disposeSignal to cancel in-flight work.`\n            );\n          }\n        }, ghostTimeout);\n      }\n    });\n  }\n\n  return wrappedKeys;\n}\n"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mvc-kit",
-  "version": "2.7.0",
+  "version": "2.8.0",
   "description": "Zero-magic, class-based reactive ViewModel library",
   "type": "module",
   "main": "./dist/mvc-kit.cjs",