obsidian-dev-utils 101.7.0 → 102.0.0

package/dist/lib/cjs/script-utils/linters/eslint-rules/no-over-cap-wait-in-eval-in-obsidian.cjs

@@ -0,0 +1,408 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  globalThisRecord['__name'] ??= keepName;
+  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
+      }
+    );
+  }
+
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/highlight',
+  '@lezer/lr',
+  'obsidian']
+  );
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@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.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(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.`);
+
+        return 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 no_over_cap_wait_in_eval_in_obsidian_exports = {};
+__export(no_over_cap_wait_in_eval_in_obsidian_exports, {
+  MESSAGE_ID: () => MESSAGE_ID,
+  noOverCapWaitInEvalInObsidian: () => noOverCapWaitInEvalInObsidian
+});
+module.exports = __toCommonJS(no_over_cap_wait_in_eval_in_obsidian_exports);
+const MESSAGE_ID = "noOverCapWaitInEvalInObsidian";
+const DEFAULT_CAP_IN_MILLISECONDS = 3e4;
+const WAIT_UNTIL_DEFAULT_TIMEOUT_IN_MILLISECONDS = 5e3;
+const INPUT_PROPERTY_NAME = "input";
+const SLEEP_CALLEE_NAME = "sleep";
+const TIMEOUT_PROPERTY_NAME = "timeoutInMilliseconds";
+const WAIT_UNTIL_CALLEE_NAME = "waitUntil";
+const CLOSURE_NAMES_BY_CALLEE_NAME = /* @__PURE__ */ new Map([
+  ["evalInObsidian", ["callback"]],
+  ["pollInObsidian", ["poll", "start"]]
+]);
+const noOverCapWaitInEvalInObsidian = {
+  create(context) {
+    const options = context.options[0];
+    const capInMilliseconds = options?.capInMilliseconds ?? DEFAULT_CAP_IN_MILLISECONDS;
+    const budgetByClosureNode = /* @__PURE__ */ new Map();
+    return {
+      "CallExpression"(node) {
+        const callNode = node;
+        const budgetExpression = readWaitBudgetExpression(callNode);
+        if (budgetExpression === void 0) {
+          return;
+        }
+        const closure = findEnclosingEvalClosure(callNode);
+        if (!closure) {
+          return;
+        }
+        const waitInMilliseconds = budgetExpression === null ? WAIT_UNTIL_DEFAULT_TIMEOUT_IN_MILLISECONDS : resolveMilliseconds(budgetExpression, closure, context);
+        if (waitInMilliseconds === null) {
+          return;
+        }
+        const runningTotalInMilliseconds = budgetByClosureNode.get(closure.closureNode)?.totalInMilliseconds ?? 0;
+        budgetByClosureNode.set(closure.closureNode, {
+          reportNode: closure.reportNode,
+          totalInMilliseconds: runningTotalInMilliseconds + waitInMilliseconds
+        });
+      },
+      "Program:exit"() {
+        for (const budget of budgetByClosureNode.values()) {
+          if (budget.totalInMilliseconds < capInMilliseconds) {
+            continue;
+          }
+          context.report({
+            data: {
+              capInMilliseconds: String(capInMilliseconds),
+              totalInMilliseconds: String(budget.totalInMilliseconds)
+            },
+            messageId: MESSAGE_ID,
+            node: budget.reportNode
+          });
+        }
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Disallow an in-Obsidian closure declaring more waiting than the transport's script-timeout cap allows"
+    },
+    messages: {
+      [MESSAGE_ID]: "This closure declares {{ totalInMilliseconds }} ms of waiting, at or over the transport's {{ capInMilliseconds }} ms cap, so it can only ever die as a bare `script timeout`: wait in Node instead, with a short DOM-reading `pollInObsidian` `poll`, an `until` evaluated in Node, and the long budget in `timeoutInMilliseconds`."
+    },
+    schema: [{
+      additionalProperties: false,
+      properties: {
+        capInMilliseconds: {
+          minimum: 1,
+          type: "integer"
+        }
+      },
+      type: "object"
+    }],
+    type: "problem"
+  }
+};
+function findEnclosingEvalClosure(node) {
+  let currentNode = node.parent;
+  while (currentNode) {
+    const closure = readEvalClosure(currentNode);
+    if (closure) {
+      return closure;
+    }
+    currentNode = currentNode.parent;
+  }
+  return null;
+}
+function findVariable(scope, name) {
+  let currentScope = scope;
+  while (currentScope) {
+    const variable = currentScope.variables.find((candidate) => candidate.name === name);
+    if (variable) {
+      return variable;
+    }
+    currentScope = currentScope.upper;
+  }
+  return null;
+}
+function isBinaryExpression(node) {
+  return node.type === "BinaryExpression";
+}
+function isCallExpression(node) {
+  return node.type === "CallExpression";
+}
+function isClosureFunction(node) {
+  return node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+}
+function isIdentifier(node) {
+  return node.type === "Identifier";
+}
+function isNumericLiteral(node) {
+  return node.type === "Literal" && typeof node.value === "number";
+}
+function isObjectExpression(node) {
+  return node.type === "ObjectExpression";
+}
+function isObjectPattern(node) {
+  return node.type === "ObjectPattern";
+}
+function isProperty(node) {
+  return node.type === "Property";
+}
+function isVariableDeclarator(node) {
+  return node.type === "VariableDeclarator";
+}
+function readBoundExpression(node, closure, context) {
+  const variable = findVariable(context.sourceCode.getScope(node), node.name);
+  if (!variable) {
+    return null;
+  }
+  for (const definition of variable.defs) {
+    const definitionNode = definition.node;
+    if (isVariableDeclarator(definitionNode) && definitionNode.init) {
+      return definitionNode.init;
+    }
+    if (definitionNode === closure.closureNode) {
+      const inputKey = readParameterInputKey(closure.closureNode, node.name);
+      if (inputKey === null) {
+        return null;
+      }
+      return readInputPropertyValue(closure.paramsNode, inputKey);
+    }
+  }
+  return null;
+}
+function readClosureNames(callNode) {
+  if (!isIdentifier(callNode.callee)) {
+    return null;
+  }
+  return CLOSURE_NAMES_BY_CALLEE_NAME.get(callNode.callee.name) ?? null;
+}
+function readEvalClosure(node) {
+  if (!isClosureFunction(node)) {
+    return null;
+  }
+  const propertyNode = node.parent;
+  if (!isProperty(propertyNode)) {
+    return null;
+  }
+  const paramsNode = propertyNode.parent;
+  if (!isObjectExpression(paramsNode)) {
+    return null;
+  }
+  if (!isIdentifier(propertyNode.key)) {
+    return null;
+  }
+  const callNode = paramsNode.parent;
+  if (!isCallExpression(callNode) || callNode.arguments[0] !== paramsNode) {
+    return null;
+  }
+  const closureNames = readClosureNames(callNode);
+  if (!closureNames?.includes(propertyNode.key.name)) {
+    return null;
+  }
+  return {
+    closureNode: node,
+    paramsNode,
+    reportNode: propertyNode
+  };
+}
+function readInputPropertyValue(paramsNode, keyName) {
+  const inputProperty = paramsNode.properties.find(
+    (property) => isProperty(property) && isIdentifier(property.key) && property.key.name === INPUT_PROPERTY_NAME
+  );
+  const inputNode = inputProperty?.value;
+  if (!inputNode || !isObjectExpression(inputNode)) {
+    return null;
+  }
+  const valueProperty = inputNode.properties.find(
+    (property) => isProperty(property) && isIdentifier(property.key) && property.key.name === keyName
+  );
+  return valueProperty?.value ?? null;
+}
+function readParameterInputKey(closureNode, localName) {
+  for (const parameterNode of closureNode.params) {
+    if (!isObjectPattern(parameterNode)) {
+      continue;
+    }
+    for (const property of parameterNode.properties) {
+      if (!isProperty(property) || property.computed || !isIdentifier(property.key) || !isIdentifier(property.value)) {
+        continue;
+      }
+      if (property.value.name === localName) {
+        return property.key.name;
+      }
+    }
+  }
+  return null;
+}
+function readWaitBudgetExpression(callNode) {
+  if (!isIdentifier(callNode.callee)) {
+    return void 0;
+  }
+  const calleeName = callNode.callee.name;
+  if (calleeName === SLEEP_CALLEE_NAME) {
+    return callNode.arguments[0] ?? void 0;
+  }
+  if (calleeName !== WAIT_UNTIL_CALLEE_NAME) {
+    return void 0;
+  }
+  const paramsNode = callNode.arguments[0];
+  if (!paramsNode || !isObjectExpression(paramsNode)) {
+    return void 0;
+  }
+  const timeoutProperty = paramsNode.properties.find(
+    (property) => isProperty(property) && isIdentifier(property.key) && property.key.name === TIMEOUT_PROPERTY_NAME
+  );
+  return timeoutProperty?.value ?? null;
+}
+function resolveMilliseconds(node, closure, context) {
+  const visitedNodes = /* @__PURE__ */ new Set();
+  let currentNode = node;
+  while (!visitedNodes.has(currentNode)) {
+    visitedNodes.add(currentNode);
+    if (isNumericLiteral(currentNode)) {
+      return currentNode.value;
+    }
+    if (isBinaryExpression(currentNode) && currentNode.operator === "*") {
+      const leftInMilliseconds = resolveMilliseconds(currentNode.left, closure, context);
+      const rightInMilliseconds = resolveMilliseconds(currentNode.right, closure, context);
+      if (leftInMilliseconds === null || rightInMilliseconds === null) {
+        return null;
+      }
+      return leftInMilliseconds * rightInMilliseconds;
+    }
+    if (!isIdentifier(currentNode)) {
+      return null;
+    }
+    const boundNode = readBoundExpression(currentNode, closure, context);
+    if (!boundNode) {
+      return null;
+    }
+    currentNode = boundNode;
+  }
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MESSAGE_ID,
+  noOverCapWaitInEvalInObsidian
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../../src/script-utils/linters/eslint-rules/no-over-cap-wait-in-eval-in-obsidian.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * ESLint rule: no-over-cap-wait-in-eval-in-obsidian\n *\n * Reports an `evalInObsidian` / `pollInObsidian` closure that declares more waiting\n * than the transport can ever honour.\n *\n * A single closure is evaluated through one transport call, and that call is capped at\n * roughly 30 seconds \u2014 Appium surfaces the cap as a bare `WebDriverError: script timeout`\n * naming only `AppiumTransport.evaluate`, CDP as a command timeout. Neither names the wait\n * that actually blew the budget, so the failure reads as a broken device rather than as a\n * closure asking for more time than exists. That misdiagnosis cost `T796` two days.\n *\n * A closure declaring a 30 000 ms `waitUntil`, or two 20 000 ms ones, therefore cannot\n * succeed on any machine slow enough to need the time it asks for. The fix is to move the\n * waiting to Node: `pollInObsidian` runs a SHORT DOM-reading `poll` closure repeatedly,\n * evaluates `until` in Node, and carries the long budget in `timeoutInMilliseconds`, so no\n * single transport call is ever long.\n *\n * WHAT COUNTS toward a closure's budget, summed lexically: every `waitUntil` inside it \u2014\n * taking the helper's documented 5 000 ms default when `timeoutInMilliseconds` is omitted,\n * which is what makes several small sibling waits add up honestly \u2014 plus every `sleep(n)`\n * settle. Waits inside a helper declared within the closure count too; the enclosing\n * closure is found by walking outwards, so a nested function attributes to the closure it\n * runs inside.\n *\n * WHAT DOES NOT. A budget that cannot be resolved to a number contributes nothing and is\n * never reported (owner, 2026-09-09). Scope analysis resolves the shapes that actually\n * occur \u2014 a literal, a `const` in any enclosing scope, and a destructured callback\n * parameter followed back through the call's own `input` object \u2014 and resolving through\n * scope rather than by regex is the whole reason this is a rule and not a script. But a\n * value arriving from a caller (`options.timeout ?? DEFAULT`, threaded through a\n * parameter) would need analysis across call boundaries, and reporting every such site would\n * make each legitimately parameterized helper red across thirty repos. A LOOP is out of scope\n * for the same reason: a `sleep` in a `while` has no statically declared ceiling, so the\n * sum below is per-iteration and says nothing about the whole.\n *\n * Not every over-cap closure can become a `poll` / `until` pair, so the rule is meant to be\n * disabled \u2014 with a reason \u2014 at the sites that have one. `require-description` makes that\n * reason mandatory, which is the point: it turns an invisible assumption into a written one.\n */\nimport type { TSESTree } from '@typescript-eslint/utils';\nimport type {\n  Rule,\n  Scope\n} from 'eslint';\n\n/**\n * Message ID reported when an in-Obsidian closure declares more waiting than the transport's cap allows.\n */\nexport const MESSAGE_ID = 'noOverCapWaitInEvalInObsidian';\n\n/**\n * The cap assumed when the rule is configured without one, matching the transport's own script timeout.\n */\nconst DEFAULT_CAP_IN_MILLISECONDS = 30_000;\n\n/**\n * The budget a `waitUntil` takes when it omits `timeoutInMilliseconds`, per `WaitUntilParams`.\n */\nconst WAIT_UNTIL_DEFAULT_TIMEOUT_IN_MILLISECONDS = 5000;\n\nconst INPUT_PROPERTY_NAME = 'input';\nconst SLEEP_CALLEE_NAME = 'sleep';\nconst TIMEOUT_PROPERTY_NAME = 'timeoutInMilliseconds';\nconst WAIT_UNTIL_CALLEE_NAME = 'waitUntil';\n\n/**\n * Which properties of each helper's parameter object hold a closure that runs INSIDE Obsidian, and is\n * therefore subject to the cap. `pollInObsidian`'s `until` is deliberately absent: it is evaluated in\n * Node, which is the entire point of converting to it.\n */\nconst CLOSURE_NAMES_BY_CALLEE_NAME = new Map<string, readonly string[]>([\n  ['evalInObsidian', ['callback']],\n  ['pollInObsidian', ['poll', 'start']]\n]);\n\n/**\n * The rule's single option object.\n */\ninterface CapOptions {\n  /**\n   * The budget at or over which a closure is reported, in milliseconds.\n   */\n  readonly capInMilliseconds?: number;\n}\n\n/**\n * The waiting summed so far for one closure.\n */\ninterface ClosureBudget {\n  /**\n   * The node to report on.\n   */\n  readonly reportNode: TSESTree.Node;\n\n  /**\n   * The sum of every resolvable wait declared inside the closure.\n   */\n  readonly totalInMilliseconds: number;\n}\n\n/**\n * A function written as an object property, which is the only form either helper's closures take.\n */\ntype ClosureFunction = TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression;\n\n/**\n * An in-Obsidian closure, together with the call it belongs to (needed to resolve a budget threaded\n * through that call's `input`) and the node to report on.\n */\ninterface EvalClosure {\n  /**\n   * The closure's function node, which identifies the closure across sibling waits and carries the\n   * parameter pattern a budget threaded through `input` is destructured by.\n   */\n  readonly closureNode: ClosureFunction;\n\n  /**\n   * The helper's parameter object, carried so a budget threaded through `input` is read from the object\n   * the closure was already found in rather than re-derived from the call.\n   */\n  readonly paramsNode: TSESTree.ObjectExpression;\n\n  /**\n   * The property the closure is written as, reported on so the message points at `callback` / `poll`\n   * rather than at whichever wait happened to come first.\n   */\n  readonly reportNode: TSESTree.Node;\n}\n\n/**\n * ESLint rule disallowing an in-Obsidian closure whose declared waiting exceeds the transport's script-timeout cap.\n */\nexport const noOverCapWaitInEvalInObsidian: Rule.RuleModule = {\n  create(context) {\n    const options = context.options[0] as CapOptions | undefined;\n    const capInMilliseconds = options?.capInMilliseconds ?? DEFAULT_CAP_IN_MILLISECONDS;\n    const budgetByClosureNode = new Map<TSESTree.Node, ClosureBudget>();\n\n    return {\n      'CallExpression'(node: Rule.Node): void {\n        const callNode = node as TSESTree.CallExpression;\n\n        const budgetExpression = readWaitBudgetExpression(callNode);\n        if (budgetExpression === undefined) {\n          return;\n        }\n\n        const closure = findEnclosingEvalClosure(callNode);\n        if (!closure) {\n          return;\n        }\n\n        const waitInMilliseconds = budgetExpression === null\n          ? WAIT_UNTIL_DEFAULT_TIMEOUT_IN_MILLISECONDS\n          : resolveMilliseconds(budgetExpression, closure, context);\n        if (waitInMilliseconds === null) {\n          return;\n        }\n\n        const runningTotalInMilliseconds = budgetByClosureNode.get(closure.closureNode)?.totalInMilliseconds ?? 0;\n        budgetByClosureNode.set(closure.closureNode, {\n          reportNode: closure.reportNode,\n          totalInMilliseconds: runningTotalInMilliseconds + waitInMilliseconds\n        });\n      },\n      'Program:exit'(): void {\n        for (const budget of budgetByClosureNode.values()) {\n          if (budget.totalInMilliseconds < capInMilliseconds) {\n            continue;\n          }\n\n          context.report({\n            data: {\n              capInMilliseconds: String(capInMilliseconds),\n              totalInMilliseconds: String(budget.totalInMilliseconds)\n            },\n            messageId: MESSAGE_ID,\n            node: budget.reportNode\n          });\n        }\n      }\n    };\n  },\n  meta: {\n    docs: {\n      description: 'Disallow an in-Obsidian closure declaring more waiting than the transport\\'s script-timeout cap allows'\n    },\n    messages: {\n      [MESSAGE_ID]: 'This closure declares {{ totalInMilliseconds }} ms of waiting, at or over the transport\\'s {{ capInMilliseconds }} ms cap, so it can only ever die as a bare `script timeout`: wait in Node instead, with a short DOM-reading `pollInObsidian` `poll`, an `until` evaluated in Node, and the long budget in `timeoutInMilliseconds`.'\n    },\n    schema: [{\n      additionalProperties: false,\n      properties: {\n        capInMilliseconds: {\n          minimum: 1,\n          type: 'integer'\n        }\n      },\n      type: 'object'\n    }],\n    type: 'problem'\n  }\n};\n\n/**\n * Finds the in-Obsidian closure a node runs inside, walking outwards.\n *\n * The walk does not stop at the first enclosing function: a wait inside a helper declared within the\n * callback still runs inside the callback, so it keeps going until it reaches a function that IS one of\n * the helper's in-Obsidian closures.\n *\n * @param node - The node to start from.\n * @returns The enclosing closure, or `null` when the node does not run inside one.\n */\nfunction findEnclosingEvalClosure(node: TSESTree.Node): EvalClosure | null {\n  let currentNode: TSESTree.Node | undefined = node.parent;\n\n  while (currentNode) {\n    const closure = readEvalClosure(currentNode);\n    if (closure) {\n      return closure;\n    }\n    currentNode = currentNode.parent;\n  }\n\n  return null;\n}\n\n/**\n * Finds a variable by name, walking outwards from the given scope.\n *\n * @param scope - The scope to start from.\n * @param name - The variable's name.\n * @returns The variable, or `null` when nothing in scope declares that name.\n */\nfunction findVariable(scope: Scope.Scope, name: string): null | Scope.Variable {\n  let currentScope: null | Scope.Scope = scope;\n\n  while (currentScope) {\n    const variable = currentScope.variables.find((candidate) => candidate.name === name);\n    if (variable) {\n      return variable;\n    }\n    currentScope = currentScope.upper;\n  }\n\n  return null;\n}\n\n/**\n * Checks whether a node is a binary expression.\n *\n * @param node - The node to check.\n * @returns `true` if the node is a `BinaryExpression`.\n */\nfunction isBinaryExpression(node: TSESTree.Node): node is TSESTree.BinaryExpression {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return node.type === 'BinaryExpression';\n}\n\n/**\n * Checks whether a node is a call expression.\n *\n * @param node - The node to check.\n * @returns `true` if the node is a `CallExpression`.\n */\nfunction isCallExpression(node: TSESTree.Node): node is TSESTree.CallExpression {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return node.type === 'CallExpression';\n}\n\n/**\n * Checks whether a node is a function written as an object property's value.\n *\n * @param node - The node to check.\n * @returns `true` if the node is a `FunctionExpression` or an `ArrowFunctionExpression`.\n */\nfunction isClosureFunction(node: TSESTree.Node): node is ClosureFunction {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression';\n}\n\n/**\n * Checks whether a node is an identifier.\n *\n * @param node - The node to check.\n * @returns `true` if the node is an `Identifier`.\n */\nfunction isIdentifier(node: TSESTree.Node): node is TSESTree.Identifier {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return node.type === 'Identifier';\n}\n\n/**\n * Checks whether a node is a numeric literal.\n *\n * @param node - The node to check.\n * @returns `true` if the node is a `Literal` holding a number.\n */\nfunction isNumericLiteral(node: TSESTree.Node): node is TSESTree.NumberLiteral {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return node.type === 'Literal' && typeof node.value === 'number';\n}\n\n/**\n * Checks whether a node is an object literal.\n *\n * @param node - The node to check.\n * @returns `true` if the node is an `ObjectExpression`.\n */\nfunction isObjectExpression(node: TSESTree.Node): node is TSESTree.ObjectExpression {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return node.type === 'ObjectExpression';\n}\n\n/**\n * Checks whether a node is an object destructuring pattern.\n *\n * @param node - The node to check.\n * @returns `true` if the node is an `ObjectPattern`.\n */\nfunction isObjectPattern(node: TSESTree.Node): node is TSESTree.ObjectPattern {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return node.type === 'ObjectPattern';\n}\n\n/**\n * Checks whether a node is an object-literal or object-pattern property.\n *\n * @param node - The node to check.\n * @returns `true` if the node is a `Property`.\n */\nfunction isProperty(node: TSESTree.Node): node is TSESTree.Property {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return node.type === 'Property';\n}\n\n/**\n * Checks whether a node is a variable declarator.\n *\n * @param node - The node to check.\n * @returns `true` if the node is a `VariableDeclarator`.\n */\nfunction isVariableDeclarator(node: TSESTree.Node): node is TSESTree.VariableDeclarator {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return node.type === 'VariableDeclarator';\n}\n\n/**\n * Reads the expression an identifier is bound to.\n *\n * A `const` answers with its initializer; a destructured parameter of THIS closure answers with what the\n * call's own `input` supplies for the key it was destructured by, which is how a budget written once at\n * the call site reaches a closure that can close over nothing.\n *\n * @param node - The identifier to resolve.\n * @param closure - The closure the identifier was written inside.\n * @param context - The rule context, used to resolve the identifier through scope.\n * @returns The expression it is bound to, or `null` when nothing statically binds it.\n */\nfunction readBoundExpression(node: TSESTree.Identifier, closure: EvalClosure, context: Rule.RuleContext): null | TSESTree.Node {\n  const variable = findVariable(context.sourceCode.getScope(node), node.name);\n  if (!variable) {\n    return null;\n  }\n\n  for (const definition of variable.defs) {\n    const definitionNode = definition.node as TSESTree.Node;\n\n    if (isVariableDeclarator(definitionNode) && definitionNode.init) {\n      return definitionNode.init;\n    }\n\n    if (definitionNode === closure.closureNode) {\n      const inputKey = readParameterInputKey(closure.closureNode, node.name);\n      if (inputKey === null) {\n        return null;\n      }\n\n      return readInputPropertyValue(closure.paramsNode, inputKey);\n    }\n  }\n\n  return null;\n}\n\n/**\n * Reads the closure property names a call's parameter object may carry, by the helper it calls.\n *\n * @param callNode - The call expression.\n * @returns The in-Obsidian closure property names, or `null` when the callee is not one of the helpers.\n */\nfunction readClosureNames(callNode: TSESTree.CallExpression): null | readonly string[] {\n  if (!isIdentifier(callNode.callee)) {\n    return null;\n  }\n\n  return CLOSURE_NAMES_BY_CALLEE_NAME.get(callNode.callee.name) ?? null;\n}\n\n/**\n * Reads the in-Obsidian closure a function node is, if it is one.\n *\n * A closure qualifies when it is the value of a `callback` / `poll` / `start` property of the object\n * literal passed as the helper's first argument \u2014 which covers both the method shorthand\n * (`async callback({ \u2026 }) { \u2026 }`) and an arrow (`callback: async ({ \u2026 }) => { \u2026 }`).\n *\n * @param node - The node to check.\n * @returns The closure, or `null` when the node is not an in-Obsidian closure.\n */\nfunction readEvalClosure(node: TSESTree.Node): EvalClosure | null {\n  if (!isClosureFunction(node)) {\n    return null;\n  }\n\n  const propertyNode = node.parent;\n  if (!isProperty(propertyNode)) {\n    return null;\n  }\n\n  /*\n   * The object check comes BEFORE the key check because a function can reach a property through its\n   * COMPUTED KEY as well as through its value -- `{ [() => 'a']: 1 }` is legal -- and a destructuring\n   * pattern can carry one too. Neither is a helper call's parameter object.\n   */\n  const paramsNode = propertyNode.parent;\n  if (!isObjectExpression(paramsNode)) {\n    return null;\n  }\n\n  if (!isIdentifier(propertyNode.key)) {\n    return null;\n  }\n\n  const callNode = paramsNode.parent;\n  if (!isCallExpression(callNode) || callNode.arguments[0] !== paramsNode) {\n    return null;\n  }\n\n  const closureNames = readClosureNames(callNode);\n  if (!closureNames?.includes(propertyNode.key.name)) {\n    return null;\n  }\n\n  return {\n    closureNode: node,\n    paramsNode,\n    reportNode: propertyNode\n  };\n}\n\n/**\n * Reads the value a call's own `input` object supplies for one key.\n *\n * This is how a budget declared once at the call site reaches the closure, which cannot close over\n * anything: `input: { settleTimeoutInMilliseconds: SETTLE }` arrives destructured in the callback's\n * parameter object.\n *\n * @param paramsNode - The helper's parameter object.\n * @param keyName - The `input` property to read.\n * @returns The expression supplying that key, or `null` when the call's `input` does not declare it.\n */\nfunction readInputPropertyValue(paramsNode: TSESTree.ObjectExpression, keyName: string): null | TSESTree.Node {\n  const inputProperty = paramsNode.properties.find((property) =>\n    isProperty(property as TSESTree.Node)\n    && isIdentifier((property as TSESTree.Property).key as TSESTree.Node)\n    && ((property as TSESTree.Property).key as TSESTree.Identifier).name === INPUT_PROPERTY_NAME\n  ) as TSESTree.Property | undefined;\n\n  const inputNode = inputProperty?.value as TSESTree.Node | undefined;\n  if (!inputNode || !isObjectExpression(inputNode)) {\n    return null;\n  }\n\n  const valueProperty = inputNode.properties.find((property) =>\n    isProperty(property as TSESTree.Node)\n    && isIdentifier((property as TSESTree.Property).key as TSESTree.Node)\n    && ((property as TSESTree.Property).key as TSESTree.Identifier).name === keyName\n  ) as TSESTree.Property | undefined;\n\n  return (valueProperty?.value as TSESTree.Node | undefined) ?? null;\n}\n\n/**\n * Reads the `input` key a destructured closure parameter is bound from.\n *\n * The binding may be renamed (`timeoutInMilliseconds: timeout`), so the KEY is what the call's `input`\n * is looked up by, never the local name.\n *\n * @param closureNode - The closure whose parameters to read.\n * @param localName - The name the budget is bound to inside the closure.\n * @returns The `input` key, or `null` when the name is not bound by a plain destructured property.\n */\nfunction readParameterInputKey(closureNode: ClosureFunction, localName: string): null | string {\n  for (const parameterNode of closureNode.params) {\n    if (!isObjectPattern(parameterNode)) {\n      continue;\n    }\n\n    for (const property of parameterNode.properties) {\n      if (!isProperty(property) || property.computed || !isIdentifier(property.key) || !isIdentifier(property.value)) {\n        continue;\n      }\n\n      if (property.value.name === localName) {\n        return property.key.name;\n      }\n    }\n  }\n\n  return null;\n}\n\n/**\n * Reads the expression carrying a wait call's declared budget.\n *\n * @param callNode - The call expression to inspect.\n * @returns The expression to resolve; `null` for a `waitUntil` that omits its timeout, which takes the\n * helper's default; or `undefined` when the call is not a wait at all.\n */\nfunction readWaitBudgetExpression(callNode: TSESTree.CallExpression): null | TSESTree.Node | undefined {\n  if (!isIdentifier(callNode.callee)) {\n    return undefined;\n  }\n\n  const calleeName = callNode.callee.name;\n\n  if (calleeName === SLEEP_CALLEE_NAME) {\n    return (callNode.arguments[0]) ?? undefined;\n  }\n\n  if (calleeName !== WAIT_UNTIL_CALLEE_NAME) {\n    return undefined;\n  }\n\n  const paramsNode = callNode.arguments[0] as TSESTree.Node | undefined;\n  if (!paramsNode || !isObjectExpression(paramsNode)) {\n    return undefined;\n  }\n\n  const timeoutProperty = paramsNode.properties.find((property) =>\n    isProperty(property as TSESTree.Node)\n    && isIdentifier((property as TSESTree.Property).key as TSESTree.Node)\n    && ((property as TSESTree.Property).key as TSESTree.Identifier).name === TIMEOUT_PROPERTY_NAME\n  ) as TSESTree.Property | undefined;\n\n  return (timeoutProperty?.value) ?? null;\n}\n\n/**\n * Resolves an expression to a millisecond count, through scope.\n *\n * Handles a numeric literal, a literal-only product (`60 * 1000`), an identifier bound to either in any\n * enclosing scope, and a destructured closure parameter followed back through the call's own `input`.\n * Anything else is unresolvable and answers `null`, which the caller treats as contributing nothing.\n *\n * Each identifier is resolved from ITS OWN scope rather than from the wait's, so a value supplied by the\n * call's `input` resolves at the call site \u2014 where it was written \u2014 and is not captured by a same-named\n * binding that happens to exist inside the closure.\n *\n * @param node - The expression to resolve.\n * @param closure - The closure the expression was written inside.\n * @param context - The rule context, used to resolve identifiers through scope.\n * @returns The millisecond count, or `null` when it cannot be resolved statically.\n */\nfunction resolveMilliseconds(node: TSESTree.Node, closure: EvalClosure, context: Rule.RuleContext): null | number {\n  const visitedNodes = new Set<TSESTree.Node>();\n  let currentNode = node;\n\n  while (!visitedNodes.has(currentNode)) {\n    visitedNodes.add(currentNode);\n\n    if (isNumericLiteral(currentNode)) {\n      return currentNode.value;\n    }\n\n    if (isBinaryExpression(currentNode) && currentNode.operator === '*') {\n      const leftInMilliseconds = resolveMilliseconds(currentNode.left, closure, context);\n      const rightInMilliseconds = resolveMilliseconds(currentNode.right, closure, context);\n\n      if (leftInMilliseconds === null || rightInMilliseconds === null) {\n        return null;\n      }\n\n      return leftInMilliseconds * rightInMilliseconds;\n    }\n\n    if (!isIdentifier(currentNode)) {\n      return null;\n    }\n\n    const boundNode = readBoundExpression(currentNode, closure, context);\n    if (!boundNode) {\n      return null;\n    }\n\n    currentNode = boundNode;\n  }\n\n  return null;\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/cjs/script-utils/linters/eslint-rules/no-over-cap-wait-in-eval-in-obsidian.d.cts

@@ -0,0 +1,10 @@
+/// <reference path="../../../library.d.cts" />
+import type { Rule } from 'eslint' with { 'resolution-mode': 'import' };
+/**
+ * Message ID reported when an in-Obsidian closure declares more waiting than the transport's cap allows.
+ */
+export declare const MESSAGE_ID = "noOverCapWaitInEvalInObsidian";
+/**
+ * ESLint rule disallowing an in-Obsidian closure whose declared waiting exceeds the transport's script-timeout cap.
+ */
+export declare const noOverCapWaitInEvalInObsidian: Rule.RuleModule;

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

@@ -150,6 +150,7 @@ var import_manifest_id = require('./manifest-id.cjs');
 var import_manifest_name = require('./manifest-name.cjs');
 var import_manifest_schema = require('./manifest-schema.cjs');
 var import_no_async_callback_to_unsafe_return = require('./no-async-callback-to-unsafe-return.cjs');
+var import_no_over_cap_wait_in_eval_in_obsidian = require('./no-over-cap-wait-in-eval-in-obsidian.cjs');
 var import_no_untrusted_input_events = require('./no-untrusted-input-events.cjs');
 var import_no_unused_params_members = require('./no-unused-params-members.cjs');
 var import_no_used_underscore_variables = require('./no-used-underscore-variables.cjs');
@@ -166,6 +167,7 @@ const obsidianDevUtilsPlugin = {
     "manifest-name": import_manifest_name.manifestName,
     "manifest-schema": import_manifest_schema.manifestSchema,
     "no-async-callback-to-unsafe-return": import_no_async_callback_to_unsafe_return.noAsyncCallbackToUnsafeReturn,
+    "no-over-cap-wait-in-eval-in-obsidian": import_no_over_cap_wait_in_eval_in_obsidian.noOverCapWaitInEvalInObsidian,
     "no-untrusted-input-events": import_no_untrusted_input_events.noUntrustedInputEvents,
     "no-unused-params-members": import_no_unused_params_members.noUnusedParamsMembers,
     "no-used-underscore-variables": import_no_used_underscore_variables.noUsedUnderscoreVariables,
@@ -181,4 +183,4 @@ const obsidianDevUtilsPlugin = {
 0 && (module.exports = {
   obsidianDevUtilsPlugin
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/desktop-zip-extractor.d.mts

@@ -8,9 +8,10 @@
  * roughly 34 KB of minified JavaScript into EVERY Obsidian plugin built with this library: a plugin
  * ships a single CJS `main.js`, esbuild has no code splitting to put a dependency behind, and a
  * `await import()` only defers evaluation — the module body is inlined either way. `node:zlib` is
- * already an esbuild external, so the same work now costs a plugin bundle nothing at all. Archives
- * are still WRITTEN with `adm-zip` at release time (`script-utils/demo-vault.ts`), which is Node-side
- * tooling and never reaches a plugin bundle.
+ * already an esbuild external, so the same work now costs a plugin bundle nothing at all. Archives are
+ * WRITTEN with `fflate` at release time (`script-utils/demo-vault.ts`), which is Node-side tooling and
+ * never reaches a plugin bundle — a third-party writer there is also what keeps this reader checked
+ * against an implementation that is not its own.
  *
  * Deliberately narrow: it reads exactly what that writer produces — stored and deflated entries in an
  * unencrypted archive below the 4 GB / 65535-entry ZIP64 threshold — and raises a named error for