obsidian-dev-utils 74.0.0 → 74.2.0

package/dist/lib/esm/script-utils/linters/eslint-rules/no-unused-params-members.mjs

@@ -0,0 +1,206 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+import { ensureNonNullable } from "../../../type-guards.mjs";
+const PARAMS_OPTIONS_SUFFIX_PATTERN = /(?:Params|Options)$/;
+const MESSAGE_ID = "unusedParamsMember";
+const noUnusedParamsMembers = {
+  create(context) {
+    const interfaceKeyNodes = /* @__PURE__ */ new Map();
+    const usageByInterface = /* @__PURE__ */ new Map();
+    return {
+      ":function"(node) {
+        for (const param of record(node)["params"]) {
+          const info = getParamInfo(param);
+          if (!info) {
+            continue;
+          }
+          const usage = getOrCreateUsage(info.typeName);
+          if (info.binding.type === "pattern") {
+            collectPatternMembers(info.binding.pattern, usage);
+          } else {
+            collectReferenceMembers(context.sourceCode.getScope(node), info.binding.name, usage);
+          }
+        }
+      },
+      "Program:exit"() {
+        for (const [typeName, keyNodes] of interfaceKeyNodes) {
+          const usage = usageByInterface.get(typeName);
+          if (!usage || usage.usesAll) {
+            continue;
+          }
+          for (const [memberName, keyNode] of keyNodes) {
+            if (!usage.used.has(memberName)) {
+              context.report({
+                data: {
+                  interfaceName: typeName,
+                  member: memberName
+                },
+                messageId: MESSAGE_ID,
+                node: keyNode
+              });
+            }
+          }
+        }
+      },
+      TSInterfaceDeclaration(node) {
+        const name = getInterfaceName(node);
+        if (!PARAMS_OPTIONS_SUFFIX_PATTERN.test(name)) {
+          return;
+        }
+        interfaceKeyNodes.set(name, getInterfaceMembers(node));
+      }
+    };
+    function getOrCreateUsage(typeName) {
+      let usage = usageByInterface.get(typeName);
+      if (!usage) {
+        usage = { used: /* @__PURE__ */ new Set(), usesAll: false };
+        usageByInterface.set(typeName, usage);
+      }
+      return usage;
+    }
+  },
+  meta: {
+    docs: {
+      description: "Flag `*Params`/`*Options` interface members never accessed by the function that receives them"
+    },
+    messages: {
+      [MESSAGE_ID]: 'Member "{{ member }}" of "{{ interfaceName }}" is never accessed by the function that receives it. Remove it (the compiler will catch it if it is still needed elsewhere).'
+    },
+    schema: [],
+    type: "suggestion"
+  }
+};
+function classifyReference(reference, usage) {
+  const parent = record(reference)["parent"];
+  if (parent.type === "MemberExpression" && record(parent)["object"] === reference) {
+    collectMemberAccess(parent, usage);
+    return;
+  }
+  if (parent.type === "VariableDeclarator" && record(parent)["init"] === reference && record(parent)["id"].type === "ObjectPattern") {
+    collectPatternMembers(record(parent)["id"], usage);
+    return;
+  }
+  usage.usesAll = true;
+}
+function collectMemberAccess(node, usage) {
+  const computed = record(node)["computed"] === true;
+  const property = record(node)["property"];
+  if (property.type === "Identifier") {
+    if (!computed) {
+      usage.used.add(record(property)["name"]);
+    }
+    return;
+  }
+  if (property.type === "Literal") {
+    const value = record(property)["value"];
+    if (typeof value === "string") {
+      usage.used.add(value);
+    }
+  }
+}
+function collectPatternMembers(pattern, usage) {
+  for (const property of record(pattern)["properties"]) {
+    if (property.type !== "Property") {
+      usage.usesAll = true;
+      continue;
+    }
+    if (record(property)["computed"] === true) {
+      continue;
+    }
+    const key = record(property)["key"];
+    if (key.type === "Identifier") {
+      usage.used.add(record(key)["name"]);
+    }
+  }
+}
+function collectReferenceMembers(scope, paramName, usage) {
+  const variable = ensureNonNullable(scope.set.get(paramName));
+  for (const reference of variable.references) {
+    classifyReference(reference.identifier, usage);
+  }
+}
+function getInterfaceMembers(node) {
+  const members = /* @__PURE__ */ new Map();
+  const interfaceBody = record(node)["body"];
+  for (const signature of record(interfaceBody)["body"]) {
+    if (nodeType(signature) !== "TSPropertySignature" && nodeType(signature) !== "TSMethodSignature") {
+      continue;
+    }
+    if (record(signature)["computed"] === true) {
+      continue;
+    }
+    const key = record(signature)["key"];
+    if (key.type === "Identifier") {
+      members.set(record(key)["name"], key);
+    }
+  }
+  return members;
+}
+function getInterfaceName(node) {
+  const id = record(node)["id"];
+  return record(id)["name"];
+}
+function getParamInfo(param) {
+  const actualParam = nodeType(param) === "TSParameterProperty" ? record(param)["parameter"] : param;
+  const typeName = getTypeReferenceName(actualParam);
+  if (!typeName || !PARAMS_OPTIONS_SUFFIX_PATTERN.test(typeName)) {
+    return void 0;
+  }
+  if (actualParam.type === "Identifier") {
+    return { binding: { name: record(actualParam)["name"], type: "identifier" }, typeName };
+  }
+  if (actualParam.type === "ObjectPattern") {
+    return { binding: { pattern: actualParam, type: "pattern" }, typeName };
+  }
+  return void 0;
+}
+function getTypeReferenceName(param) {
+  const annotation = record(param)["typeAnnotation"];
+  if (!isNode(annotation)) {
+    return void 0;
+  }
+  const typeNode = record(annotation)["typeAnnotation"];
+  if (nodeType(typeNode) !== "TSTypeReference") {
+    return void 0;
+  }
+  const typeName = record(typeNode)["typeName"];
+  if (typeName.type !== "Identifier") {
+    return void 0;
+  }
+  return record(typeName)["name"];
+}
+function isNode(value) {
+  return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+function nodeType(node) {
+  return record(node)["type"];
+}
+function record(node) {
+  return node;
+}
+export {
+  MESSAGE_ID,
+  noUnusedParamsMembers
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../../src/script-utils/linters/eslint-rules/no-unused-params-members.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * ESLint rule: no-unused-params-members\n *\n * Flags members of a `*Params` / `*Options` parameter-bag interface that are\n * never accessed within the function/method/constructor that receives the\n * interface as a parameter.\n *\n * Detection is per-function, using scope analysis to find the real references\n * to the parameter (not unrelated same-named identifiers). A member counts as\n * used when it is referenced by name \u2014 `params.member`, `params['member']`, or\n * `const { member } = params` (plus a destructured signature\n * `fn({ member }: FooParams)`).\n *\n * Crucially, if the object ever ESCAPES whole \u2014 spread (`{ ...params }`), rest\n * (`const { ...rest } = params`), passed as an argument (`f(params)`), returned,\n * or stored (`this.params = params`) \u2014 every member is treated as used and\n * nothing is reported for that interface. Such an escape either reads every\n * member (spread/rest) or hands the object to code this rule cannot see, so\n * member deadness cannot be decided locally.\n *\n * A member is therefore flagged only when it is never referenced by name AND\n * the object never escapes \u2014 i.e. the \"a `params.x` usage was deleted but `x`\n * was left on the interface\" case. A member that is actually still needed (read\n * via an escape) is never wrongly flagged; a member that is escaped but dead\n * downstream is a tolerated false negative (its deadness is not local).\n *\n * Only interfaces declared in the same file are checked; an imported parameter\n * type is skipped. Only identifier-named members are tracked.\n */\n\nimport type {\n  Rule,\n  Scope\n} from 'eslint';\n\nimport { ensureNonNullable } from '../../../type-guards.ts';\n\nconst PARAMS_OPTIONS_SUFFIX_PATTERN = /(?:Params|Options)$/;\n\nexport const MESSAGE_ID = 'unusedParamsMember';\n\ninterface IdentifierBinding {\n  name: string;\n  type: 'identifier';\n}\n\ninterface InterfaceUsage {\n  readonly used: Set<string>;\n  usesAll: boolean;\n}\n\ninterface MaybeTypedNode {\n  type?: unknown;\n}\n\ntype ParamBinding = IdentifierBinding | PatternBinding;\n\ninterface ParamInfo {\n  readonly binding: ParamBinding;\n  readonly typeName: string;\n}\n\ninterface PatternBinding {\n  pattern: Rule.Node;\n  type: 'pattern';\n}\n\nexport const noUnusedParamsMembers: Rule.RuleModule = {\n  create(context) {\n    const interfaceKeyNodes = new Map<string, Map<string, Rule.Node>>();\n    const usageByInterface = new Map<string, InterfaceUsage>();\n\n    return {\n      ':function'(node: Rule.Node): void {\n        for (const param of record(node)['params'] as Rule.Node[]) {\n          const info = getParamInfo(param);\n          if (!info) {\n            continue;\n          }\n\n          const usage = getOrCreateUsage(info.typeName);\n          if (info.binding.type === 'pattern') {\n            collectPatternMembers(info.binding.pattern, usage);\n          } else {\n            collectReferenceMembers(context.sourceCode.getScope(node), info.binding.name, usage);\n          }\n        }\n      },\n      'Program:exit'(): void {\n        for (const [typeName, keyNodes] of interfaceKeyNodes) {\n          const usage = usageByInterface.get(typeName);\n          if (!usage || usage.usesAll) {\n            continue;\n          }\n\n          for (const [memberName, keyNode] of keyNodes) {\n            if (!usage.used.has(memberName)) {\n              context.report({\n                data: {\n                  interfaceName: typeName,\n                  member: memberName\n                },\n                messageId: MESSAGE_ID,\n                node: keyNode\n              });\n            }\n          }\n        }\n      },\n      TSInterfaceDeclaration(node: Rule.Node): void {\n        const name = getInterfaceName(node);\n        if (!PARAMS_OPTIONS_SUFFIX_PATTERN.test(name)) {\n          return;\n        }\n        interfaceKeyNodes.set(name, getInterfaceMembers(node));\n      }\n    };\n\n    function getOrCreateUsage(typeName: string): InterfaceUsage {\n      let usage = usageByInterface.get(typeName);\n      if (!usage) {\n        usage = { used: new Set<string>(), usesAll: false };\n        usageByInterface.set(typeName, usage);\n      }\n      return usage;\n    }\n  },\n  meta: {\n    docs: {\n      description: 'Flag `*Params`/`*Options` interface members never accessed by the function that receives them'\n    },\n    messages: {\n      [MESSAGE_ID]: 'Member \"{{ member }}\" of \"{{ interfaceName }}\" is never accessed by the function that receives it. Remove it (the compiler will catch it if it is still needed elsewhere).'\n    },\n    schema: [],\n    type: 'suggestion'\n  }\n};\n\nfunction classifyReference(reference: object, usage: InterfaceUsage): void {\n  const parent = record(reference)['parent'] as Rule.Node;\n  if (parent.type === 'MemberExpression' && record(parent)['object'] === reference) {\n    collectMemberAccess(parent, usage);\n    return;\n  }\n\n  if (parent.type === 'VariableDeclarator' && record(parent)['init'] === reference && (record(parent)['id'] as Rule.Node).type === 'ObjectPattern') {\n    collectPatternMembers(record(parent)['id'] as Rule.Node, usage);\n    return;\n  }\n\n  // The object escapes whole (passed as an argument, returned, stored, spread, ...): every member may be read elsewhere.\n  usage.usesAll = true;\n}\n\nfunction collectMemberAccess(node: Rule.Node, usage: InterfaceUsage): void {\n  const computed = record(node)['computed'] === true;\n  const property = record(node)['property'] as Rule.Node;\n  if (property.type === 'Identifier') {\n    if (!computed) {\n      usage.used.add(record(property)['name'] as string);\n    }\n    return;\n  }\n\n  if (property.type === 'Literal') {\n    const value = record(property)['value'];\n    if (typeof value === 'string') {\n      usage.used.add(value);\n    }\n  }\n}\n\nfunction collectPatternMembers(pattern: Rule.Node, usage: InterfaceUsage): void {\n  for (const property of record(pattern)['properties'] as Rule.Node[]) {\n    if (property.type !== 'Property') {\n      // `const { ...rest } = params` reads every remaining member.\n      usage.usesAll = true;\n      continue;\n    }\n    if (record(property)['computed'] === true) {\n      continue;\n    }\n    const key = record(property)['key'] as Rule.Node;\n    if (key.type === 'Identifier') {\n      usage.used.add(record(key)['name'] as string);\n    }\n  }\n}\n\nfunction collectReferenceMembers(scope: Scope.Scope, paramName: string, usage: InterfaceUsage): void {\n  const variable = ensureNonNullable(scope.set.get(paramName));\n  for (const reference of variable.references) {\n    classifyReference(reference.identifier, usage);\n  }\n}\n\nfunction getInterfaceMembers(node: Rule.Node): Map<string, Rule.Node> {\n  const members = new Map<string, Rule.Node>();\n  const interfaceBody = record(node)['body'] as Rule.Node;\n  for (const signature of record(interfaceBody)['body'] as Rule.Node[]) {\n    if (nodeType(signature) !== 'TSPropertySignature' && nodeType(signature) !== 'TSMethodSignature') {\n      continue;\n    }\n    if (record(signature)['computed'] === true) {\n      continue;\n    }\n    const key = record(signature)['key'] as Rule.Node;\n    if (key.type === 'Identifier') {\n      members.set(record(key)['name'] as string, key);\n    }\n  }\n  return members;\n}\n\nfunction getInterfaceName(node: Rule.Node): string {\n  const id = record(node)['id'] as Rule.Node;\n  return record(id)['name'] as string;\n}\n\nfunction getParamInfo(param: Rule.Node): ParamInfo | undefined {\n  const actualParam = nodeType(param) === 'TSParameterProperty' ? record(param)['parameter'] as Rule.Node : param;\n\n  const typeName = getTypeReferenceName(actualParam);\n  if (!typeName || !PARAMS_OPTIONS_SUFFIX_PATTERN.test(typeName)) {\n    return undefined;\n  }\n\n  if (actualParam.type === 'Identifier') {\n    return { binding: { name: record(actualParam)['name'] as string, type: 'identifier' }, typeName };\n  }\n\n  if (actualParam.type === 'ObjectPattern') {\n    return { binding: { pattern: actualParam, type: 'pattern' }, typeName };\n  }\n\n  return undefined;\n}\n\nfunction getTypeReferenceName(param: Rule.Node): string | undefined {\n  const annotation = record(param)['typeAnnotation'];\n  if (!isNode(annotation)) {\n    return undefined;\n  }\n\n  const typeNode = record(annotation)['typeAnnotation'] as Rule.Node;\n  if (nodeType(typeNode) !== 'TSTypeReference') {\n    return undefined;\n  }\n\n  const typeName = record(typeNode)['typeName'] as Rule.Node;\n  if (typeName.type !== 'Identifier') {\n    return undefined;\n  }\n  return record(typeName)['name'] as string;\n}\n\nfunction isNode(value: unknown): value is Rule.Node {\n  return typeof value === 'object' && value !== null && typeof (value as MaybeTypedNode).type === 'string';\n}\n\nfunction nodeType(node: Rule.Node): string {\n  return record(node)['type'] as string;\n}\n\nfunction record(node: object): Record<string, unknown> {\n  return node as Record<string, unknown>;\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/script-utils/linters/eslint-rules/obsidian-dev-utils-plugin.mjs

@@ -22,6 +22,7 @@ if you want to view the source, please visit the github repository of this plugi
 })();
 
 import { noAsyncCallbackToUnsafeReturn } from "./no-async-callback-to-unsafe-return.mjs";
+import { noUnusedParamsMembers } from "./no-unused-params-members.mjs";
 import { noUsedUnderscoreVariables } from "./no-used-underscore-variables.mjs";
 import { paramsOptionsNameMatch } from "./params-options-name-match.mjs";
 import { preferNoopAsync } from "./prefer-noop-async.mjs";
@@ -32,6 +33,7 @@ import { requireSuperCall } from "./require-super-call.mjs";
 const obsidianDevUtilsPlugin = {
   rules: {
     "no-async-callback-to-unsafe-return": noAsyncCallbackToUnsafeReturn,
+    "no-unused-params-members": noUnusedParamsMembers,
     "no-used-underscore-variables": noUsedUnderscoreVariables,
     "params-options-name-match": paramsOptionsNameMatch,
     "prefer-noop-async": preferNoopAsync,
@@ -44,4 +46,4 @@ const obsidianDevUtilsPlugin = {
 export {
   obsidianDevUtilsPlugin
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/setup/async-operation-tracking-jest-setup.d.mts

@@ -0,0 +1,12 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * Jest setup file that enables async-operation tracking for the duration of each test.
+ *
+ * Add it to your Jest config's `setupFilesAfterEach` (or import it from another setup file). It enables
+ * tracking before each test and disables it afterwards, so tests can `await waitForAllAsyncOperations()`.
+ *
+ * This is a per-test setup file, not a Jest `globalSetup` module, so it has no default export.
+ */
+export {};

package/dist/lib/esm/setup/async-operation-tracking-jest-setup.mjs

@@ -0,0 +1,33 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+import {
+  afterEach,
+  beforeEach
+} from "@jest/globals";
+import { setupAsyncOperationTracking } from "./async-operation-tracking-setup.mjs";
+setupAsyncOperationTracking({
+  afterEach,
+  beforeEach
+});
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3NldHVwL2FzeW5jLW9wZXJhdGlvbi10cmFja2luZy1qZXN0LXNldHVwLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogSmVzdCBzZXR1cCBmaWxlIHRoYXQgZW5hYmxlcyBhc3luYy1vcGVyYXRpb24gdHJhY2tpbmcgZm9yIHRoZSBkdXJhdGlvbiBvZiBlYWNoIHRlc3QuXG4gKlxuICogQWRkIGl0IHRvIHlvdXIgSmVzdCBjb25maWcncyBgc2V0dXBGaWxlc0FmdGVyRWFjaGAgKG9yIGltcG9ydCBpdCBmcm9tIGFub3RoZXIgc2V0dXAgZmlsZSkuIEl0IGVuYWJsZXNcbiAqIHRyYWNraW5nIGJlZm9yZSBlYWNoIHRlc3QgYW5kIGRpc2FibGVzIGl0IGFmdGVyd2FyZHMsIHNvIHRlc3RzIGNhbiBgYXdhaXQgd2FpdEZvckFsbEFzeW5jT3BlcmF0aW9ucygpYC5cbiAqXG4gKiBUaGlzIGlzIGEgcGVyLXRlc3Qgc2V0dXAgZmlsZSwgbm90IGEgSmVzdCBgZ2xvYmFsU2V0dXBgIG1vZHVsZSwgc28gaXQgaGFzIG5vIGRlZmF1bHQgZXhwb3J0LlxuICovXG5cbi8qIHY4IGlnbm9yZSBzdGFydCAtLSBUaGluIEplc3Qgc2V0dXAtZmlsZSBnbHVlOyBzZXR1cEFzeW5jT3BlcmF0aW9uVHJhY2tpbmcgaXMgdW5pdC10ZXN0ZWQgc2VwYXJhdGVseS4gKi9cbmltcG9ydCB7XG4gIGFmdGVyRWFjaCxcbiAgYmVmb3JlRWFjaFxufSBmcm9tICdAamVzdC9nbG9iYWxzJztcblxuaW1wb3J0IHsgc2V0dXBBc3luY09wZXJhdGlvblRyYWNraW5nIH0gZnJvbSAnLi9hc3luYy1vcGVyYXRpb24tdHJhY2tpbmctc2V0dXAudHMnO1xuXG5zZXR1cEFzeW5jT3BlcmF0aW9uVHJhY2tpbmcoe1xuICBhZnRlckVhY2gsXG4gIGJlZm9yZUVhY2hcbn0pO1xuLyogdjggaWdub3JlIHN0b3AgKi9cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBWUE7QUFBQSxFQUNFO0FBQUEsRUFDQTtBQUFBLE9BQ0s7QUFFUCxTQUFTLG1DQUFtQztBQUU1Qyw0QkFBNEI7QUFBQSxFQUMxQjtBQUFBLEVBQ0E7QUFDRixDQUFDOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/esm/setup/async-operation-tracking-setup.d.mts

@@ -0,0 +1,47 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @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/esm/setup/async-operation-tracking-setup.mjs

@@ -0,0 +1,35 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+import {
+  disableAsyncOperationTracking,
+  enableAsyncOperationTracking
+} from "../async.mjs";
+function setupAsyncOperationTracking(params) {
+  params.beforeEach(enableAsyncOperationTracking);
+  params.afterEach(disableAsyncOperationTracking);
+}
+export {
+  setupAsyncOperationTracking
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/setup/async-operation-tracking-vitest-setup.d.mts

@@ -0,0 +1,10 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @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/esm/setup/async-operation-tracking-vitest-setup.mjs

@@ -0,0 +1,33 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+import {
+  afterEach,
+  beforeEach
+} from "vitest";
+import { setupAsyncOperationTracking } from "./async-operation-tracking-setup.mjs";
+setupAsyncOperationTracking({
+  afterEach,
+  beforeEach
+});
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3NldHVwL2FzeW5jLW9wZXJhdGlvbi10cmFja2luZy12aXRlc3Qtc2V0dXAudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBWaXRlc3Qgc2V0dXAgZmlsZSB0aGF0IGVuYWJsZXMgYXN5bmMtb3BlcmF0aW9uIHRyYWNraW5nIGZvciB0aGUgZHVyYXRpb24gb2YgZWFjaCB0ZXN0LlxuICpcbiAqIEFkZCBpdCB0byB5b3VyIFZpdGVzdCBjb25maWcncyBgc2V0dXBGaWxlc2AgKG9yIGltcG9ydCBpdCBmcm9tIGFub3RoZXIgc2V0dXAgZmlsZSkuIEl0IGVuYWJsZXNcbiAqIHRyYWNraW5nIGJlZm9yZSBlYWNoIHRlc3QgYW5kIGRpc2FibGVzIGl0IGFmdGVyd2FyZHMsIHNvIHRlc3RzIGNhbiBgYXdhaXQgd2FpdEZvckFsbEFzeW5jT3BlcmF0aW9ucygpYC5cbiAqL1xuXG4vKiB2OCBpZ25vcmUgc3RhcnQgLS0gVGhpbiBWaXRlc3Qgc2V0dXAtZmlsZSBnbHVlOyBzZXR1cEFzeW5jT3BlcmF0aW9uVHJhY2tpbmcgaXMgdW5pdC10ZXN0ZWQgc2VwYXJhdGVseS4gKi9cbmltcG9ydCB7XG4gIGFmdGVyRWFjaCxcbiAgYmVmb3JlRWFjaFxufSBmcm9tICd2aXRlc3QnO1xuXG5pbXBvcnQgeyBzZXR1cEFzeW5jT3BlcmF0aW9uVHJhY2tpbmcgfSBmcm9tICcuL2FzeW5jLW9wZXJhdGlvbi10cmFja2luZy1zZXR1cC50cyc7XG5cbnNldHVwQXN5bmNPcGVyYXRpb25UcmFja2luZyh7XG4gIGFmdGVyRWFjaCxcbiAgYmVmb3JlRWFjaFxufSk7XG4vKiB2OCBpZ25vcmUgc3RvcCAqL1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFVQTtBQUFBLEVBQ0U7QUFBQSxFQUNBO0FBQUEsT0FDSztBQUVQLFNBQVMsbUNBQW1DO0FBRTVDLDRCQUE0QjtBQUFBLEVBQzFCO0FBQUEsRUFDQTtBQUNGLENBQUM7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/lib/esm/strict-proxy.d.mts

@@ -19,9 +19,10 @@ import type { GenericFunction } from './function.mjs';
  *
  * @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/strict-proxy.mjs

@@ -86,4 +86,4 @@ export {
   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": ";;;;;;;;;;;;;;;;;;;;;;;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": ";;;;;;;;;;;;;;;;;;;;;;;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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-dev-utils",
-  "version": "74.0.0",
+  "version": "74.2.0",
   "description": "This is the collection of useful functions that you can use for your Obsidian plugin development.",
   "keywords": [
     "obsidian"
@@ -577,6 +577,16 @@
         "default": "./dist/lib/cjs/script-utils/test-runners/*.cjs"
       }
     },
+    "./setup/*": {
+      "import": {
+        "types": "./dist/lib/esm/setup/*.d.mts",
+        "default": "./dist/lib/esm/setup/*.mjs"
+      },
+      "require": {
+        "types": "./dist/lib/cjs/setup/*.d.cts",
+        "default": "./dist/lib/cjs/setup/*.cjs"
+      }
+    },
     "./transformers": {
       "import": {
         "types": "./dist/lib/esm/transformers/index.d.mts",
@@ -662,8 +672,8 @@
     "@types/babel__core": "^7.20.5",
     "@types/doctrine": "^0.0.9",
     "@types/eslint": "^9.6.1",
-    "@types/luxon": "^3.7.1",
-    "@types/node": "^25.9.3",
+    "@types/luxon": "^3.7.2",
+    "@types/node": "^26.0.0",
     "@types/parsimmon": "^1.10.9",
     "@types/path-browserify": "^1.0.3",
     "@types/picomatch": "^4.0.3",
@@ -685,7 +695,7 @@
     "eslint": "^10.5.0",
     "eslint-import-resolver-typescript": "^4.4.5",
     "eslint-plugin-import-x": "^4.16.2",
-    "eslint-plugin-jsdoc": "^63.0.5",
+    "eslint-plugin-jsdoc": "^63.0.6",
     "eslint-plugin-no-unsanitized": "^4.1.5",
     "eslint-plugin-obsidianmd": "^0.3.0",
     "eslint-plugin-perfectionist": "^5.9.1",
@@ -710,7 +720,7 @@
     "remark-parse": "^11.0.0",
     "remark-wiki-link": "^2.0.1",
     "sass": "^1.101.0",
-    "semver": "^7.8.4",
+    "semver": "^7.8.5",
     "shell-quote": "^1.8.4",
     "svelte-check": "^4.6.0",
     "svelte-preprocess": "^6.0.5",
@@ -723,6 +733,7 @@
     "@commitlint/cli": "^21.0.2",
     "@commitlint/config-conventional": "^21.0.2",
     "@commitlint/types": "^21.0.1",
+    "@jest/globals": "^30.4.1",
     "@total-typescript/ts-reset": "^0.6.1",
     "@typescript-eslint/rule-tester": "^8.61.1",
     "@vitest/coverage-v8": "^4.1.9",
@@ -735,7 +746,7 @@
     "jsdom": "^29.1.1",
     "moment": "^2.30.1",
     "nano-staged": "^1.0.2",
-    "obsidian-integration-testing": "^4.2.4",
+    "obsidian-integration-testing": "^4.2.6",
     "obsidian-test-mocks": "^3.1.1",
     "ts-declaration-location": "^1.0.7",
     "vitest": "^4.1.9",

package/script-utils/linters/eslint-rules/no-unused-params-members/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../../../../dist/lib/cjs/script-utils/linters/eslint-rules/no-unused-params-members.cjs",
+  "module": "../../../../dist/lib/esm/script-utils/linters/eslint-rules/no-unused-params-members.mjs",
+  "type": "module",
+  "types": "../../../../dist/lib/cjs/script-utils/linters/eslint-rules/no-unused-params-members.d.cts"
+}

package/setup/async-operation-tracking-jest-setup/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../../dist/lib/cjs/setup/async-operation-tracking-jest-setup.cjs",
+  "module": "../../dist/lib/esm/setup/async-operation-tracking-jest-setup.mjs",
+  "type": "module",
+  "types": "../../dist/lib/cjs/setup/async-operation-tracking-jest-setup.d.cts"
+}

package/setup/async-operation-tracking-setup/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../../dist/lib/cjs/setup/async-operation-tracking-setup.cjs",
+  "module": "../../dist/lib/esm/setup/async-operation-tracking-setup.mjs",
+  "type": "module",
+  "types": "../../dist/lib/cjs/setup/async-operation-tracking-setup.d.cts"
+}

package/setup/async-operation-tracking-vitest-setup/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../../dist/lib/cjs/setup/async-operation-tracking-vitest-setup.cjs",
+  "module": "../../dist/lib/esm/setup/async-operation-tracking-vitest-setup.mjs",
+  "type": "module",
+  "types": "../../dist/lib/cjs/setup/async-operation-tracking-vitest-setup.d.cts"
+}