obsidian-dev-utils 74.1.0 → 74.2.0

package/dist/lib/cjs/setup/async-operation-tracking-setup.cjs

@@ -0,0 +1,140 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  globalThisRecord['__name'] ??= name;
+  const originalRequire = require;
+  if (originalRequire && !originalRequire.__isPatched) {
+    // eslint-disable-next-line no-global-assign, no-implicit-globals -- We need to patch the `require()` function.
+    require = Object.assign(
+      (id) => requirePatched(id),
+      originalRequire,
+      {
+        __isPatched: true
+      }
+    );
+  }
+
+  const newFuncs = {
+    __extractDefault() {
+      return extractDefault;
+    },
+    process() {
+      const browserProcess = {
+        browser: true,
+        cwd() {
+          return '/';
+        },
+        env: {},
+        platform: 'android'
+      };
+      return browserProcess;
+    }
+  };
+
+  for (const key of Object.keys(newFuncs)) {
+    globalThisRecord[key] ??= newFuncs[key]?.();
+  }
+
+  function name(obj) {
+    return obj;
+  }
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  'obsidian',
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/lr',
+  '@lezer/highlight'];
+
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  '@codemirror/closebrackets',
+  '@codemirror/comment',
+  '@codemirror/fold',
+  '@codemirror/gutter',
+  '@codemirror/highlight',
+  '@codemirror/history',
+  '@codemirror/matchbrackets',
+  '@codemirror/panel',
+  '@codemirror/rangeset',
+  '@codemirror/rectangular-selection',
+  '@codemirror/stream-parser',
+  '@codemirror/tooltip'];
+
+
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id)) {
+      return originalRequire?.(id);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+        return globalThis.process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var async_operation_tracking_setup_exports = {};
+__export(async_operation_tracking_setup_exports, {
+  setupAsyncOperationTracking: () => setupAsyncOperationTracking
+});
+module.exports = __toCommonJS(async_operation_tracking_setup_exports);
+var import_async = require('../async.cjs');
+function setupAsyncOperationTracking(params) {
+  params.beforeEach(import_async.enableAsyncOperationTracking);
+  params.afterEach(import_async.disableAsyncOperationTracking);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setupAsyncOperationTracking
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/setup/async-operation-tracking-setup.d.cts

@@ -0,0 +1,47 @@
+/// <reference path="../library.d.cts" />
+/**
+ * @file
+ *
+ * Framework-agnostic test-setup endpoint for async-operation tracking.
+ *
+ * Wires {@link enableAsyncOperationTracking} / {@link disableAsyncOperationTracking} into a test
+ * framework's `beforeEach` / `afterEach` lifecycle hooks. Each test gets a fresh tracking session:
+ * tracking is enabled before the test runs and disabled (clearing any tracked operations) after it
+ * finishes, so a test can `await waitForAllAsyncOperations()` without leaking module-global state into
+ * the next test.
+ *
+ * This module has no import-time side effects and no dependency on any specific test framework. The
+ * thin Vitest/Jest setup files (`async-operation-tracking-vitest-setup.ts` /
+ * `async-operation-tracking-jest-setup.ts`) call {@link setupAsyncOperationTracking} with the hooks
+ * imported from their respective frameworks.
+ */
+/**
+ * A test-framework lifecycle hook registrar, such as `beforeEach` or `afterEach`.
+ *
+ * @param fn - The callback to register with the hook.
+ */
+export type HookRegistrar = (fn: () => void) => void;
+/**
+ * Parameters for {@link setupAsyncOperationTracking}.
+ */
+export interface SetupAsyncOperationTrackingParams {
+    /**
+     * The test framework's `afterEach` hook registrar. Used to disable async-operation tracking after
+     * each test.
+     */
+    readonly afterEach: HookRegistrar;
+    /**
+     * The test framework's `beforeEach` hook registrar. Used to enable async-operation tracking before
+     * each test.
+     */
+    readonly beforeEach: HookRegistrar;
+}
+/**
+ * Registers async-operation tracking with a test framework's lifecycle hooks.
+ *
+ * Enables tracking before each test (via the supplied `beforeEach`) and disables it after each test
+ * (via the supplied `afterEach`), so every test runs with a fresh tracking session.
+ *
+ * @param params - The lifecycle hook registrars to wire tracking into.
+ */
+export declare function setupAsyncOperationTracking(params: SetupAsyncOperationTrackingParams): void;

package/dist/lib/cjs/setup/async-operation-tracking-vitest-setup.cjs

@@ -0,0 +1,115 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  globalThisRecord['__name'] ??= name;
+  const originalRequire = require;
+  if (originalRequire && !originalRequire.__isPatched) {
+    // eslint-disable-next-line no-global-assign, no-implicit-globals -- We need to patch the `require()` function.
+    require = Object.assign(
+      (id) => requirePatched(id),
+      originalRequire,
+      {
+        __isPatched: true
+      }
+    );
+  }
+
+  const newFuncs = {
+    __extractDefault() {
+      return extractDefault;
+    },
+    process() {
+      const browserProcess = {
+        browser: true,
+        cwd() {
+          return '/';
+        },
+        env: {},
+        platform: 'android'
+      };
+      return browserProcess;
+    }
+  };
+
+  for (const key of Object.keys(newFuncs)) {
+    globalThisRecord[key] ??= newFuncs[key]?.();
+  }
+
+  function name(obj) {
+    return obj;
+  }
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  'obsidian',
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/lr',
+  '@lezer/highlight'];
+
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  '@codemirror/closebrackets',
+  '@codemirror/comment',
+  '@codemirror/fold',
+  '@codemirror/gutter',
+  '@codemirror/highlight',
+  '@codemirror/history',
+  '@codemirror/matchbrackets',
+  '@codemirror/panel',
+  '@codemirror/rangeset',
+  '@codemirror/rectangular-selection',
+  '@codemirror/stream-parser',
+  '@codemirror/tooltip'];
+
+
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id)) {
+      return originalRequire?.(id);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+        return globalThis.process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var import_vitest = require('vitest');
+var import_async_operation_tracking_setup = require('./async-operation-tracking-setup.cjs');
+(0, import_async_operation_tracking_setup.setupAsyncOperationTracking)({
+  afterEach: import_vitest.afterEach,
+  beforeEach: import_vitest.beforeEach
+});
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3NldHVwL2FzeW5jLW9wZXJhdGlvbi10cmFja2luZy12aXRlc3Qtc2V0dXAudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBWaXRlc3Qgc2V0dXAgZmlsZSB0aGF0IGVuYWJsZXMgYXN5bmMtb3BlcmF0aW9uIHRyYWNraW5nIGZvciB0aGUgZHVyYXRpb24gb2YgZWFjaCB0ZXN0LlxuICpcbiAqIEFkZCBpdCB0byB5b3VyIFZpdGVzdCBjb25maWcncyBgc2V0dXBGaWxlc2AgKG9yIGltcG9ydCBpdCBmcm9tIGFub3RoZXIgc2V0dXAgZmlsZSkuIEl0IGVuYWJsZXNcbiAqIHRyYWNraW5nIGJlZm9yZSBlYWNoIHRlc3QgYW5kIGRpc2FibGVzIGl0IGFmdGVyd2FyZHMsIHNvIHRlc3RzIGNhbiBgYXdhaXQgd2FpdEZvckFsbEFzeW5jT3BlcmF0aW9ucygpYC5cbiAqL1xuXG4vKiB2OCBpZ25vcmUgc3RhcnQgLS0gVGhpbiBWaXRlc3Qgc2V0dXAtZmlsZSBnbHVlOyBzZXR1cEFzeW5jT3BlcmF0aW9uVHJhY2tpbmcgaXMgdW5pdC10ZXN0ZWQgc2VwYXJhdGVseS4gKi9cbmltcG9ydCB7XG4gIGFmdGVyRWFjaCxcbiAgYmVmb3JlRWFjaFxufSBmcm9tICd2aXRlc3QnO1xuXG5pbXBvcnQgeyBzZXR1cEFzeW5jT3BlcmF0aW9uVHJhY2tpbmcgfSBmcm9tICcuL2FzeW5jLW9wZXJhdGlvbi10cmFja2luZy1zZXR1cC50cyc7XG5cbnNldHVwQXN5bmNPcGVyYXRpb25UcmFja2luZyh7XG4gIGFmdGVyRWFjaCxcbiAgYmVmb3JlRWFjaFxufSk7XG4vKiB2OCBpZ25vcmUgc3RvcCAqL1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBVUEsb0JBR087QUFFUCw0Q0FBNEM7QUFBQSxJQUU1QyxtRUFBNEI7QUFBQSxFQUMxQjtBQUFBLEVBQ0E7QUFDRixDQUFDOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/cjs/setup/async-operation-tracking-vitest-setup.d.cts

@@ -0,0 +1,10 @@
+/// <reference path="../library.d.cts" />
+/**
+ * @file
+ *
+ * Vitest setup file that enables async-operation tracking for the duration of each test.
+ *
+ * Add it to your Vitest config's `setupFiles` (or import it from another setup file). It enables
+ * tracking before each test and disables it afterwards, so tests can `await waitForAllAsyncOperations()`.
+ */
+export {};

package/dist/lib/cjs/strict-proxy.cjs

@@ -195,4 +195,4 @@ function wrapProxy(value) {
   bypassStrictProxy,
   strictProxy
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/strict-proxy.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Strictly-typed mock object factory via `Proxy`. Throws a descriptive error\n * when any unmocked property is accessed, preventing silent `undefined` returns.\n *\n * The proxy implementation mirrors the design of\n * `obsidian-test-mocks/src/internal/strict-proxy.ts`.\n */\n\nimport type { GenericFunction } from './function.ts';\n\n/**\n * A recursive partial type compatible with `exactOptionalPropertyTypes`.\n *\n * Unlike `PartialDeep` from type-fest, this type allows full `T` values at any\n * nesting level via the `| T[K]` union. This is essential for composing nested\n * `strictProxy` calls \u2014 an inner `strictProxy<MetadataCache>({...})` returns\n * `MetadataCache`, which must be assignable to the outer partial type.\n *\n * @typeParam T - The target type to create a partial version of.\n */\nexport type StrictProxyPartial<T> = T extends GenericFunction ? T\n  : T extends readonly unknown[] ? T\n  : T extends object ? { [K in keyof T]?: StrictProxyPartial<T[K]> | T[K] }\n  : T;\n\nconst STRICT_PROXY_TARGET_SYMBOL = Symbol.for('strictProxyTarget');\n\nconst PASSTHROUGH_PROPS = new Set<string | symbol>([\n  '_isMockFunction',\n  '$$typeof',\n  'asymmetricMatch',\n  'nodeType',\n  Symbol.iterator,\n  Symbol.toPrimitive,\n  Symbol.toStringTag,\n  'tagName',\n  'then',\n  'toJSON'\n]);\n\n/**\n * Bypasses strict proxy to access the underlying object.\n *\n * If the object is wrapped in a strict proxy, returns the unwrapped target.\n * Otherwise, returns the object as-is. This allows safely accessing\n * optional properties without triggering the proxy's error on missing props.\n *\n * @typeParam T - The object type.\n * @param obj - The object to bypass.\n * @returns The unwrapped object.\n */\nexport function bypassStrictProxy<T>(obj: T): T {\n  if (!isObjectLike(obj)) {\n    return obj;\n  }\n  if (!(STRICT_PROXY_TARGET_SYMBOL in obj)) {\n    return obj;\n  }\n  return obj[STRICT_PROXY_TARGET_SYMBOL] as T;\n}\n\n/**\n * Creates a strictly-typed mock object from a partial implementation.\n * Uses a `Proxy` that throws a descriptive error when any unmocked\n * property is accessed, preventing silent `undefined` returns.\n *\n * - Idempotent: double-wrapping is a no-op.\n * - Passthrough for well-known props (`then`, `toJSON`, `Symbol.iterator`, etc.).\n * - Recursive proxying of nested plain objects.\n *\n * @typeParam T - The target type to mock.\n * @param partial - A partial object containing only the mocked members.\n * @returns A proxy typed as `T` that throws on unmocked property access.\n */\nexport function strictProxy<T>(partial: StrictProxyPartial<T>): T {\n  return wrapProxy<T>(partial);\n}\n\n/**\n * Checks if a value is an object-like value (not null).\n *\n * @param value - The value to check.\n * @returns Whether the value is object-like.\n */\nfunction isObjectLike(value: unknown): value is object {\n  return value !== null && typeof value === 'object';\n}\n\n/**\n * Checks if a value is a plain object (not a class instance, array, null, etc.).\n *\n * @param value - The value to check.\n * @returns Whether the value is a plain object.\n */\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  return isObjectLike(value) && Object.getPrototypeOf(value) === Object.prototype;\n}\n\n/**\n * Wraps a value in a strict proxy. Idempotent \u2014 double-wrapping is a no-op.\n *\n * @typeParam T - The target type for the proxy.\n * @param value - The value to wrap.\n * @returns The proxied value typed as `T`.\n */\n// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- T provides return type inference at call sites.\nfunction wrapProxy<T>(value: unknown): T {\n  if (!isObjectLike(value)) {\n    return value as T;\n  }\n\n  if (STRICT_PROXY_TARGET_SYMBOL in value) {\n    return value as T;\n  }\n  Object.defineProperty(value, STRICT_PROXY_TARGET_SYMBOL, { value });\n\n  const proxiedChildren = new Map<string | symbol>();\n\n  return new Proxy(value, {\n    get(target, prop, receiver): unknown {\n      if (prop in target) {\n        if (proxiedChildren.has(prop)) {\n          return proxiedChildren.get(prop);\n        }\n\n        const val: unknown = Reflect.get(target, prop, receiver);\n        if (isPlainObject(val)) {\n          const result = wrapProxy<unknown>(val);\n          proxiedChildren.set(prop, result);\n          return result;\n        }\n        return val;\n      }\n\n      if (typeof prop === 'symbol' || PASSTHROUGH_PROPS.has(prop)) {\n        return Reflect.get(target, prop, receiver);\n      }\n\n      throw new Error(`Unmocked property \"${prop}\" was accessed on mock object`);\n    }\n  }) as T;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA2BA,MAAM,6BAA6B,uBAAO,IAAI,mBAAmB;AAEjE,MAAM,oBAAoB,oBAAI,IAAqB;AAAA,EACjD;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,OAAO;AAAA,EACP,OAAO;AAAA,EACP,OAAO;AAAA,EACP;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAaM,SAAS,kBAAqB,KAAW;AAC9C,MAAI,CAAC,aAAa,GAAG,GAAG;AACtB,WAAO;AAAA,EACT;AACA,MAAI,EAAE,8BAA8B,MAAM;AACxC,WAAO;AAAA,EACT;AACA,SAAO,IAAI,0BAA0B;AACvC;AAeO,SAAS,YAAe,SAAmC;AAChE,SAAO,UAAa,OAAO;AAC7B;AAQA,SAAS,aAAa,OAAiC;AACrD,SAAO,UAAU,QAAQ,OAAO,UAAU;AAC5C;AAQA,SAAS,cAAc,OAAkD;AACvE,SAAO,aAAa,KAAK,KAAK,OAAO,eAAe,KAAK,MAAM,OAAO;AACxE;AAUA,SAAS,UAAa,OAAmB;AACvC,MAAI,CAAC,aAAa,KAAK,GAAG;AACxB,WAAO;AAAA,EACT;AAEA,MAAI,8BAA8B,OAAO;AACvC,WAAO;AAAA,EACT;AACA,SAAO,eAAe,OAAO,4BAA4B,EAAE,MAAM,CAAC;AAElE,QAAM,kBAAkB,oBAAI,IAAqB;AAEjD,SAAO,IAAI,MAAM,OAAO;AAAA,IACtB,IAAI,QAAQ,MAAM,UAAmB;AACnC,UAAI,QAAQ,QAAQ;AAClB,YAAI,gBAAgB,IAAI,IAAI,GAAG;AAC7B,iBAAO,gBAAgB,IAAI,IAAI;AAAA,QACjC;AAEA,cAAM,MAAe,QAAQ,IAAI,QAAQ,MAAM,QAAQ;AACvD,YAAI,cAAc,GAAG,GAAG;AACtB,gBAAM,SAAS,UAAmB,GAAG;AACrC,0BAAgB,IAAI,MAAM,MAAM;AAChC,iBAAO;AAAA,QACT;AACA,eAAO;AAAA,MACT;AAEA,UAAI,OAAO,SAAS,YAAY,kBAAkB,IAAI,IAAI,GAAG;AAC3D,eAAO,QAAQ,IAAI,QAAQ,MAAM,QAAQ;AAAA,MAC3C;AAEA,YAAM,IAAI,MAAM,sBAAsB,IAAI,+BAA+B;AAAA,IAC3E;AAAA,EACF,CAAC;AACH;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/strict-proxy.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Strictly-typed mock object factory via `Proxy`. Throws a descriptive error\n * when any unmocked property is accessed, preventing silent `undefined` returns.\n *\n * The proxy implementation mirrors the design of\n * `obsidian-test-mocks/src/internal/strict-proxy.ts`.\n */\n\nimport type { GenericFunction } from './function.ts';\n\n/**\n * A recursive partial type compatible with `exactOptionalPropertyTypes`.\n *\n * Unlike `PartialDeep` from type-fest, this type allows full `T` values at any\n * nesting level via the `| T[K]` union. This is essential for composing nested\n * `strictProxy` calls \u2014 an inner `strictProxy<MetadataCache>({...})` returns\n * `MetadataCache`, which must be assignable to the outer partial type.\n *\n * @typeParam T - The target type to create a partial version of.\n */\nexport type StrictProxyPartial<T> = T extends GenericFunction ? T\n  : T extends readonly unknown[] ? T\n  : T extends object ? StrictProxyPartialObject<T>\n  : T;\n\ntype StrictProxyPartialObject<T> = {\n  [K in keyof T]?: StrictProxyPartial<T[K]> | T[K];\n};\n\nconst STRICT_PROXY_TARGET_SYMBOL = Symbol.for('strictProxyTarget');\n\nconst PASSTHROUGH_PROPS = new Set<string | symbol>([\n  '_isMockFunction',\n  '$$typeof',\n  'asymmetricMatch',\n  'nodeType',\n  Symbol.iterator,\n  Symbol.toPrimitive,\n  Symbol.toStringTag,\n  'tagName',\n  'then',\n  'toJSON'\n]);\n\n/**\n * Bypasses strict proxy to access the underlying object.\n *\n * If the object is wrapped in a strict proxy, returns the unwrapped target.\n * Otherwise, returns the object as-is. This allows safely accessing\n * optional properties without triggering the proxy's error on missing props.\n *\n * @typeParam T - The object type.\n * @param obj - The object to bypass.\n * @returns The unwrapped object.\n */\nexport function bypassStrictProxy<T>(obj: T): T {\n  if (!isObjectLike(obj)) {\n    return obj;\n  }\n  if (!(STRICT_PROXY_TARGET_SYMBOL in obj)) {\n    return obj;\n  }\n  return obj[STRICT_PROXY_TARGET_SYMBOL] as T;\n}\n\n/**\n * Creates a strictly-typed mock object from a partial implementation.\n * Uses a `Proxy` that throws a descriptive error when any unmocked\n * property is accessed, preventing silent `undefined` returns.\n *\n * - Idempotent: double-wrapping is a no-op.\n * - Passthrough for well-known props (`then`, `toJSON`, `Symbol.iterator`, etc.).\n * - Recursive proxying of nested plain objects.\n *\n * @typeParam T - The target type to mock.\n * @param partial - A partial object containing only the mocked members.\n * @returns A proxy typed as `T` that throws on unmocked property access.\n */\nexport function strictProxy<T>(partial: StrictProxyPartial<T>): T {\n  return wrapProxy<T>(partial);\n}\n\n/**\n * Checks if a value is an object-like value (not null).\n *\n * @param value - The value to check.\n * @returns Whether the value is object-like.\n */\nfunction isObjectLike(value: unknown): value is object {\n  return value !== null && typeof value === 'object';\n}\n\n/**\n * Checks if a value is a plain object (not a class instance, array, null, etc.).\n *\n * @param value - The value to check.\n * @returns Whether the value is a plain object.\n */\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  return isObjectLike(value) && Object.getPrototypeOf(value) === Object.prototype;\n}\n\n/**\n * Wraps a value in a strict proxy. Idempotent \u2014 double-wrapping is a no-op.\n *\n * @typeParam T - The target type for the proxy.\n * @param value - The value to wrap.\n * @returns The proxied value typed as `T`.\n */\n// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- T provides return type inference at call sites.\nfunction wrapProxy<T>(value: unknown): T {\n  if (!isObjectLike(value)) {\n    return value as T;\n  }\n\n  if (STRICT_PROXY_TARGET_SYMBOL in value) {\n    return value as T;\n  }\n  Object.defineProperty(value, STRICT_PROXY_TARGET_SYMBOL, { value });\n\n  const proxiedChildren = new Map<string | symbol>();\n\n  return new Proxy(value, {\n    get(target, prop, receiver): unknown {\n      if (prop in target) {\n        if (proxiedChildren.has(prop)) {\n          return proxiedChildren.get(prop);\n        }\n\n        const val: unknown = Reflect.get(target, prop, receiver);\n        if (isPlainObject(val)) {\n          const result = wrapProxy<unknown>(val);\n          proxiedChildren.set(prop, result);\n          return result;\n        }\n        return val;\n      }\n\n      if (typeof prop === 'symbol' || PASSTHROUGH_PROPS.has(prop)) {\n        return Reflect.get(target, prop, receiver);\n      }\n\n      throw new Error(`Unmocked property \"${prop}\" was accessed on mock object`);\n    }\n  }) as T;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA+BA,MAAM,6BAA6B,uBAAO,IAAI,mBAAmB;AAEjE,MAAM,oBAAoB,oBAAI,IAAqB;AAAA,EACjD;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,OAAO;AAAA,EACP,OAAO;AAAA,EACP,OAAO;AAAA,EACP;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAaM,SAAS,kBAAqB,KAAW;AAC9C,MAAI,CAAC,aAAa,GAAG,GAAG;AACtB,WAAO;AAAA,EACT;AACA,MAAI,EAAE,8BAA8B,MAAM;AACxC,WAAO;AAAA,EACT;AACA,SAAO,IAAI,0BAA0B;AACvC;AAeO,SAAS,YAAe,SAAmC;AAChE,SAAO,UAAa,OAAO;AAC7B;AAQA,SAAS,aAAa,OAAiC;AACrD,SAAO,UAAU,QAAQ,OAAO,UAAU;AAC5C;AAQA,SAAS,cAAc,OAAkD;AACvE,SAAO,aAAa,KAAK,KAAK,OAAO,eAAe,KAAK,MAAM,OAAO;AACxE;AAUA,SAAS,UAAa,OAAmB;AACvC,MAAI,CAAC,aAAa,KAAK,GAAG;AACxB,WAAO;AAAA,EACT;AAEA,MAAI,8BAA8B,OAAO;AACvC,WAAO;AAAA,EACT;AACA,SAAO,eAAe,OAAO,4BAA4B,EAAE,MAAM,CAAC;AAElE,QAAM,kBAAkB,oBAAI,IAAqB;AAEjD,SAAO,IAAI,MAAM,OAAO;AAAA,IACtB,IAAI,QAAQ,MAAM,UAAmB;AACnC,UAAI,QAAQ,QAAQ;AAClB,YAAI,gBAAgB,IAAI,IAAI,GAAG;AAC7B,iBAAO,gBAAgB,IAAI,IAAI;AAAA,QACjC;AAEA,cAAM,MAAe,QAAQ,IAAI,QAAQ,MAAM,QAAQ;AACvD,YAAI,cAAc,GAAG,GAAG;AACtB,gBAAM,SAAS,UAAmB,GAAG;AACrC,0BAAgB,IAAI,MAAM,MAAM;AAChC,iBAAO;AAAA,QACT;AACA,eAAO;AAAA,MACT;AAEA,UAAI,OAAO,SAAS,YAAY,kBAAkB,IAAI,IAAI,GAAG;AAC3D,eAAO,QAAQ,IAAI,QAAQ,MAAM,QAAQ;AAAA,MAC3C;AAEA,YAAM,IAAI,MAAM,sBAAsB,IAAI,+BAA+B;AAAA,IAC3E;AAAA,EACF,CAAC;AACH;",
  "names": []
}


package/dist/lib/cjs/strict-proxy.d.cts

@@ -19,9 +19,10 @@ import type { GenericFunction } from './function.cjs';
  *
  * @typeParam T - The target type to create a partial version of.
  */
-export type StrictProxyPartial<T> = T extends GenericFunction ? T : T extends readonly unknown[] ? T : T extends object ? {
+export type StrictProxyPartial<T> = T extends GenericFunction ? T : T extends readonly unknown[] ? T : T extends object ? StrictProxyPartialObject<T> : T;
+type StrictProxyPartialObject<T> = {
     [K in keyof T]?: StrictProxyPartial<T[K]> | T[K];
-} : T;
+};
 /**
  * Bypasses strict proxy to access the underlying object.
  *
@@ -48,3 +49,4 @@ export declare function bypassStrictProxy<T>(obj: T): T;
  * @returns A proxy typed as `T` that throws on unmocked property access.
  */
 export declare function strictProxy<T>(partial: StrictProxyPartial<T>): T;
+export {};

package/dist/lib/esm/async.d.mts

@@ -121,6 +121,18 @@ export declare function ignoreError(promise: Promise<unknown>, fallbackValue?: u
  * @returns A {@link Promise} that resolves with the value returned by the asynchronous function or the fallback value if an error is thrown.
  */
 export declare function ignoreError<T>(promise: Promise<T>, fallbackValue: T): Promise<T>;
+/**
+ * Disables tracking previously enabled via {@link enableAsyncOperationTracking} and forgets any currently-tracked operations.
+ */
+export declare function disableAsyncOperationTracking(): void;
+/**
+ * Enables tracking of fire-and-forget operations scheduled via {@link invokeAsyncSafely} (and therefore {@link convertAsyncToSync}).
+ *
+ * While enabled, each scheduled operation is recorded until it settles so that tests can await them all via {@link waitForAllAsyncOperations}, removing the need to override {@link invokeAsyncSafely} / {@link convertAsyncToSync} in tests.
+ *
+ * Tracking is disabled by default, so production code carries no bookkeeping overhead. Intended to be enabled in test environments only.
+ */
+export declare function enableAsyncOperationTracking(): void;
 /**
  * Invokes a {@link Promise} and safely handles any errors by catching them and emitting an async error event.
  *
@@ -153,6 +165,15 @@ export declare function promiseAllAsyncFnsSequentially<T>(asyncFns: (() => Promi
  * @returns A {@link Promise} that resolves with an array of the results of the promises.
  */
 export declare function promiseAllSequentially<T>(promises: Promisable<T>[]): Promise<T[]>;
+/**
+ * Waits for all fire-and-forget operations tracked since {@link enableAsyncOperationTracking} was called to settle.
+ *
+ * Operations scheduled while awaiting are also awaited, so cascading fire-and-forget chains are fully drained.
+ *
+ * @returns A {@link Promise} that resolves once no tracked operations remain pending.
+ * @throws If tracking is not enabled. Otherwise this would silently resolve as if all operations were finished, masking a missing {@link enableAsyncOperationTracking} call.
+ */
+export declare function waitForAllAsyncOperations(): Promise<void>;
 /**
  * Options for {@link retryWithTimeout}.
  */