@mnaoumov/obsidian-dev-toolkit 0.0.0 → 1.1.0

package/dist/lib/esm/linters/eslint-rules/manifest-name.mjs

@@ -0,0 +1,110 @@
+/*
+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 ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import {
+  findManifestMember,
+  getManifestObject,
+  getStringValue,
+  toReportNode
+} from "./manifest-helpers.mjs";
+const MESSAGE_ID_CONTAINS_OBSIDIAN = "nameContainsObsidian";
+const MESSAGE_ID_CONTAINS_PLUGIN = "nameContainsPlugin";
+const MESSAGE_ID_INVALID_CHARACTERS = "nameInvalidCharacters";
+const ALLOWED_NAME_CHARACTERS = /^[A-Za-z0-9 \-+()]+$/;
+const OBSIDIAN_VARIANTS = /obsi|sidian/i;
+const manifestName = {
+  create(context) {
+    return {
+      Document(node) {
+        const manifestObject = getManifestObject(node);
+        if (!manifestObject) {
+          return;
+        }
+        const member = findManifestMember(manifestObject, "name");
+        if (!member) {
+          return;
+        }
+        const name = getStringValue(member.value);
+        if (name === null) {
+          return;
+        }
+        const reportNode = toReportNode(member.value);
+        if (OBSIDIAN_VARIANTS.test(name)) {
+          context.report({
+            messageId: MESSAGE_ID_CONTAINS_OBSIDIAN,
+            node: reportNode
+          });
+        }
+        if (name.toLowerCase().includes("plugin")) {
+          context.report({
+            messageId: MESSAGE_ID_CONTAINS_PLUGIN,
+            node: reportNode
+          });
+        }
+        if (!ALLOWED_NAME_CHARACTERS.test(name)) {
+          context.report({
+            messageId: MESSAGE_ID_INVALID_CHARACTERS,
+            node: reportNode
+          });
+        }
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Enforce the Community directory's constraints on a plugin's `manifest.json` `name`"
+    },
+    messages: {
+      [MESSAGE_ID_CONTAINS_OBSIDIAN]: "The `name` must not contain `Obsidian` or a variant of it. It is implied by the context of the plugin directory.",
+      [MESSAGE_ID_CONTAINS_PLUGIN]: "The `name` must not contain `Plugin`.",
+      [MESSAGE_ID_INVALID_CHARACTERS]: "The `name` must use Basic Latin only, with hyphens, plus signs and parentheses the only permitted punctuation."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+export {
+  MESSAGE_ID_CONTAINS_OBSIDIAN,
+  MESSAGE_ID_CONTAINS_PLUGIN,
+  MESSAGE_ID_INVALID_CHARACTERS,
+  manifestName
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/linters/eslint-rules/manifest-schema.d.mts

@@ -0,0 +1,45 @@
+/// <reference path="../../index.d.mts" />
+/**
+ * @file
+ *
+ * ESLint rule: manifest-schema
+ *
+ * Validates the structure of a plugin's root `manifest.json` - the required keys, the keys the Community
+ * directory does not allow, duplicate keys, each value's type, and the shape of `fundingUrl`.
+ *
+ * Runs on the `@eslint/json` `json/json` language; see `manifest-helpers.ts` for why the AST is Momoa
+ * rather than ESTree.
+ */
+import type { Rule } from 'eslint';
+/**
+Message ID reported when a key the Community directory does not allow is present.
+ */
+export declare const MESSAGE_ID_DISALLOWED_KEY = "disallowedKey";
+/**
+Message ID reported when the same key appears more than once.
+ */
+export declare const MESSAGE_ID_DUPLICATE_KEY = "duplicateKey";
+/**
+Message ID reported when `fundingUrl` is an empty string, an empty object, or an object with an empty value.
+ */
+export declare const MESSAGE_ID_EMPTY_FUNDING_URL = "emptyFundingUrl";
+/**
+Message ID reported when a value has the wrong type.
+ */
+export declare const MESSAGE_ID_INVALID_TYPE = "invalidType";
+/**
+Message ID reported when a `fundingUrl` object holds a non-string value.
+ */
+export declare const MESSAGE_ID_INVALID_FUNDING_URL = "invalidFundingUrl";
+/**
+Message ID reported when a required key is missing.
+ */
+export declare const MESSAGE_ID_MISSING_KEY = "missingKey";
+/**
+Message ID reported when the manifest's top-level value is not an object.
+ */
+export declare const MESSAGE_ID_MUST_BE_ROOT_OBJECT = "mustBeRootObject";
+/**
+ * ESLint rule validating the structure of a plugin's root `manifest.json`.
+ */
+export declare const manifestSchema: Rule.RuleModule;

package/dist/lib/esm/linters/eslint-rules/manifest-schema.mjs

@@ -0,0 +1,212 @@
+/*
+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 ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import {
+  findManifestMember,
+  getManifestObject,
+  getManifestStringValue,
+  getMemberKey,
+  getStringValue,
+  JSON_NODE_TYPE_BOOLEAN,
+  JSON_NODE_TYPE_OBJECT,
+  JSON_NODE_TYPE_STRING,
+  toReportNode,
+  UNRELEASED_VERSION
+} from "./manifest-helpers.mjs";
+const MESSAGE_ID_DISALLOWED_KEY = "disallowedKey";
+const MESSAGE_ID_DUPLICATE_KEY = "duplicateKey";
+const MESSAGE_ID_EMPTY_FUNDING_URL = "emptyFundingUrl";
+const MESSAGE_ID_INVALID_TYPE = "invalidType";
+const MESSAGE_ID_INVALID_FUNDING_URL = "invalidFundingUrl";
+const MESSAGE_ID_MISSING_KEY = "missingKey";
+const MESSAGE_ID_MUST_BE_ROOT_OBJECT = "mustBeRootObject";
+const ALWAYS_REQUIRED_KEYS = ["author", "description", "id", "isDesktopOnly", "name", "version"];
+const KEY_NODE_TYPES = /* @__PURE__ */ new Map([
+  ["author", [JSON_NODE_TYPE_STRING]],
+  ["authorUrl", [JSON_NODE_TYPE_STRING]],
+  ["description", [JSON_NODE_TYPE_STRING]],
+  ["fundingUrl", [JSON_NODE_TYPE_OBJECT, JSON_NODE_TYPE_STRING]],
+  ["id", [JSON_NODE_TYPE_STRING]],
+  ["isDesktopOnly", [JSON_NODE_TYPE_BOOLEAN]],
+  ["minAppVersion", [JSON_NODE_TYPE_STRING]],
+  ["name", [JSON_NODE_TYPE_STRING]],
+  ["version", [JSON_NODE_TYPE_STRING]]
+]);
+const manifestSchema = {
+  create(context) {
+    return {
+      Document(node) {
+        const manifestObject = getManifestObject(node);
+        if (!manifestObject) {
+          context.report({
+            messageId: MESSAGE_ID_MUST_BE_ROOT_OBJECT,
+            node: toReportNode(node)
+          });
+          return;
+        }
+        reportDuplicateKeys({ context, manifestObject });
+        reportMissingKeys({ context, manifestObject });
+        reportKeyValues({ context, manifestObject });
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Validate the structure of a plugin's root `manifest.json`"
+    },
+    messages: {
+      [MESSAGE_ID_DISALLOWED_KEY]: "The `{{ key }}` property is not allowed in the manifest.",
+      [MESSAGE_ID_DUPLICATE_KEY]: "The `{{ key }}` property is defined more than once.",
+      [MESSAGE_ID_EMPTY_FUNDING_URL]: "The `fundingUrl` property cannot be empty. Remove it instead when no donations are accepted.",
+      [MESSAGE_ID_INVALID_FUNDING_URL]: "The `fundingUrl` object must only contain string values.",
+      [MESSAGE_ID_INVALID_TYPE]: "The `{{ key }}` property must be of type `{{ expectedType }}`, but was `{{ actualType }}`.",
+      [MESSAGE_ID_MISSING_KEY]: "The manifest is missing the required `{{ key }}` property.",
+      [MESSAGE_ID_MUST_BE_ROOT_OBJECT]: "The manifest must be a single JSON object."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+function reportDuplicateKeys(params) {
+  const { context, manifestObject } = params;
+  const seenKeys = /* @__PURE__ */ new Set();
+  for (const member of manifestObject.members) {
+    const key = getMemberKey(member);
+    if (seenKeys.has(key)) {
+      context.report({
+        data: { key },
+        messageId: MESSAGE_ID_DUPLICATE_KEY,
+        node: toReportNode(member.name)
+      });
+    } else {
+      seenKeys.add(key);
+    }
+  }
+}
+function reportFundingUrl(params) {
+  const { context, member } = params;
+  const stringValue = getStringValue(member.value);
+  if (stringValue !== null) {
+    if (stringValue === "") {
+      context.report({
+        messageId: MESSAGE_ID_EMPTY_FUNDING_URL,
+        node: toReportNode(member.value)
+      });
+    }
+    return;
+  }
+  const fundingObject = member.value;
+  if (fundingObject.members.length === 0) {
+    context.report({
+      messageId: MESSAGE_ID_EMPTY_FUNDING_URL,
+      node: toReportNode(fundingObject)
+    });
+    return;
+  }
+  for (const fundingMember of fundingObject.members) {
+    const fundingValue = getStringValue(fundingMember.value);
+    if (fundingValue === null) {
+      context.report({
+        messageId: MESSAGE_ID_INVALID_FUNDING_URL,
+        node: toReportNode(fundingMember.value)
+      });
+    } else if (fundingValue === "") {
+      context.report({
+        messageId: MESSAGE_ID_EMPTY_FUNDING_URL,
+        node: toReportNode(fundingMember.value)
+      });
+    }
+  }
+}
+function reportKeyValues(params) {
+  const { context, manifestObject } = params;
+  for (const member of manifestObject.members) {
+    const key = getMemberKey(member);
+    const expectedNodeTypes = KEY_NODE_TYPES.get(key);
+    if (!expectedNodeTypes) {
+      context.report({
+        data: { key },
+        messageId: MESSAGE_ID_DISALLOWED_KEY,
+        node: toReportNode(member.name)
+      });
+      continue;
+    }
+    if (!expectedNodeTypes.includes(member.value.type)) {
+      context.report({
+        data: {
+          actualType: member.value.type,
+          expectedType: expectedNodeTypes.join(" or "),
+          key
+        },
+        messageId: MESSAGE_ID_INVALID_TYPE,
+        node: toReportNode(member.value)
+      });
+      continue;
+    }
+    if (key === "fundingUrl") {
+      reportFundingUrl({ context, member });
+    }
+  }
+}
+function reportMissingKeys(params) {
+  const { context, manifestObject } = params;
+  const requiredKeys = [...ALWAYS_REQUIRED_KEYS, ...getManifestStringValue(manifestObject, "version") === UNRELEASED_VERSION ? [] : ["minAppVersion"]];
+  for (const key of requiredKeys) {
+    if (!findManifestMember(manifestObject, key)) {
+      context.report({
+        data: { key },
+        messageId: MESSAGE_ID_MISSING_KEY,
+        node: toReportNode(manifestObject)
+      });
+    }
+  }
+}
+export {
+  MESSAGE_ID_DISALLOWED_KEY,
+  MESSAGE_ID_DUPLICATE_KEY,
+  MESSAGE_ID_EMPTY_FUNDING_URL,
+  MESSAGE_ID_INVALID_FUNDING_URL,
+  MESSAGE_ID_INVALID_TYPE,
+  MESSAGE_ID_MISSING_KEY,
+  MESSAGE_ID_MUST_BE_ROOT_OBJECT,
+  manifestSchema
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/linters/eslint-rules/manifest-schema.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * ESLint rule: manifest-schema\n *\n * Validates the structure of a plugin's root `manifest.json` - the required keys, the keys the Community\n * directory does not allow, duplicate keys, each value's type, and the shape of `fundingUrl`.\n *\n * Runs on the `@eslint/json` `json/json` language; see `manifest-helpers.ts` for why the AST is Momoa\n * rather than ESTree.\n */\n\nimport type { Rule } from 'eslint';\n\nimport type {\n  JsonMemberNode,\n  JsonObjectNode\n} from './manifest-helpers.ts';\n\nimport {\n  findManifestMember,\n  getManifestObject,\n  getManifestStringValue,\n  getMemberKey,\n  getStringValue,\n  JSON_NODE_TYPE_BOOLEAN,\n  JSON_NODE_TYPE_OBJECT,\n  JSON_NODE_TYPE_STRING,\n  toReportNode,\n  UNRELEASED_VERSION\n} from './manifest-helpers.ts';\n\n/**\nMessage ID reported when a key the Community directory does not allow is present.\n */\nexport const MESSAGE_ID_DISALLOWED_KEY = 'disallowedKey';\n\n/**\nMessage ID reported when the same key appears more than once.\n */\nexport const MESSAGE_ID_DUPLICATE_KEY = 'duplicateKey';\n\n/**\nMessage ID reported when `fundingUrl` is an empty string, an empty object, or an object with an empty value.\n */\nexport const MESSAGE_ID_EMPTY_FUNDING_URL = 'emptyFundingUrl';\n\n/**\nMessage ID reported when a value has the wrong type.\n */\nexport const MESSAGE_ID_INVALID_TYPE = 'invalidType';\n\n/**\nMessage ID reported when a `fundingUrl` object holds a non-string value.\n */\nexport const MESSAGE_ID_INVALID_FUNDING_URL = 'invalidFundingUrl';\n\n/**\nMessage ID reported when a required key is missing.\n */\nexport const MESSAGE_ID_MISSING_KEY = 'missingKey';\n\n/**\nMessage ID reported when the manifest's top-level value is not an object.\n */\nexport const MESSAGE_ID_MUST_BE_ROOT_OBJECT = 'mustBeRootObject';\n\n/**\nThe keys every manifest must carry, whether or not the plugin has been released.\n */\nconst ALWAYS_REQUIRED_KEYS = ['author', 'description', 'id', 'isDesktopOnly', 'name', 'version'];\n\n/**\nThe Momoa node type each allowed key's value may have. A key absent from this map is not allowed at all.\n */\nconst KEY_NODE_TYPES = new Map<string, readonly string[]>([\n  ['author', [JSON_NODE_TYPE_STRING]],\n  ['authorUrl', [JSON_NODE_TYPE_STRING]],\n  ['description', [JSON_NODE_TYPE_STRING]],\n  ['fundingUrl', [JSON_NODE_TYPE_OBJECT, JSON_NODE_TYPE_STRING]],\n  ['id', [JSON_NODE_TYPE_STRING]],\n  ['isDesktopOnly', [JSON_NODE_TYPE_BOOLEAN]],\n  ['minAppVersion', [JSON_NODE_TYPE_STRING]],\n  ['name', [JSON_NODE_TYPE_STRING]],\n  ['version', [JSON_NODE_TYPE_STRING]]\n]);\n\n/**\n * ESLint rule validating the structure of a plugin's root `manifest.json`.\n */\nexport const manifestSchema: Rule.RuleModule = {\n  create(context) {\n    return {\n      Document(node: unknown): void {\n        const manifestObject = getManifestObject(node);\n\n        if (!manifestObject) {\n          context.report({\n            messageId: MESSAGE_ID_MUST_BE_ROOT_OBJECT,\n            node: toReportNode(node)\n          });\n          return;\n        }\n\n        reportDuplicateKeys({ context, manifestObject });\n        reportMissingKeys({ context, manifestObject });\n        reportKeyValues({ context, manifestObject });\n      }\n    };\n  },\n  meta: {\n    docs: {\n      description: 'Validate the structure of a plugin\\'s root `manifest.json`'\n    },\n    messages: {\n      [MESSAGE_ID_DISALLOWED_KEY]: 'The `{{ key }}` property is not allowed in the manifest.',\n      [MESSAGE_ID_DUPLICATE_KEY]: 'The `{{ key }}` property is defined more than once.',\n      [MESSAGE_ID_EMPTY_FUNDING_URL]: 'The `fundingUrl` property cannot be empty. Remove it instead when no donations are accepted.',\n      [MESSAGE_ID_INVALID_FUNDING_URL]: 'The `fundingUrl` object must only contain string values.',\n      [MESSAGE_ID_INVALID_TYPE]: 'The `{{ key }}` property must be of type `{{ expectedType }}`, but was `{{ actualType }}`.',\n      [MESSAGE_ID_MISSING_KEY]: 'The manifest is missing the required `{{ key }}` property.',\n      [MESSAGE_ID_MUST_BE_ROOT_OBJECT]: 'The manifest must be a single JSON object.'\n    },\n    schema: [],\n    type: 'problem'\n  }\n};\n\n/**\n * Parameters for {@link reportFundingUrl}.\n */\ninterface ReportFundingUrlParams {\n  /**\n   * The ESLint rule context.\n   */\n  readonly context: Rule.RuleContext;\n\n  /**\n   * The `fundingUrl` member.\n   */\n  readonly member: JsonMemberNode;\n}\n\n/**\n * Parameters for the manifest reporting helpers.\n */\ninterface ReportParams {\n  /**\n   * The ESLint rule context.\n   */\n  readonly context: Rule.RuleContext;\n\n  /**\n   * The manifest's root object node.\n   */\n  readonly manifestObject: JsonObjectNode;\n}\n\n/**\n * Reports every key that appears more than once.\n *\n * @param params - The {@link ReportParams}.\n */\nfunction reportDuplicateKeys(params: ReportParams): void {\n  const { context, manifestObject } = params;\n  const seenKeys = new Set<string>();\n\n  for (const member of manifestObject.members) {\n    const key = getMemberKey(member);\n\n    if (seenKeys.has(key)) {\n      context.report({\n        data: { key },\n        messageId: MESSAGE_ID_DUPLICATE_KEY,\n        node: toReportNode(member.name)\n      });\n    } else {\n      seenKeys.add(key);\n    }\n  }\n}\n\n/**\n * Reports the ways a `fundingUrl` can be empty or hold a non-string value.\n *\n * @param params - The {@link ReportFundingUrlParams}.\n */\nfunction reportFundingUrl(params: ReportFundingUrlParams): void {\n  const { context, member } = params;\n\n  const stringValue = getStringValue(member.value);\n\n  if (stringValue !== null) {\n    if (stringValue === '') {\n      context.report({\n        messageId: MESSAGE_ID_EMPTY_FUNDING_URL,\n        node: toReportNode(member.value)\n      });\n    }\n\n    return;\n  }\n\n  const fundingObject = member.value as JsonObjectNode;\n\n  if (fundingObject.members.length === 0) {\n    context.report({\n      messageId: MESSAGE_ID_EMPTY_FUNDING_URL,\n      node: toReportNode(fundingObject)\n    });\n    return;\n  }\n\n  for (const fundingMember of fundingObject.members) {\n    const fundingValue = getStringValue(fundingMember.value);\n\n    if (fundingValue === null) {\n      context.report({\n        messageId: MESSAGE_ID_INVALID_FUNDING_URL,\n        node: toReportNode(fundingMember.value)\n      });\n    } else if (fundingValue === '') {\n      context.report({\n        messageId: MESSAGE_ID_EMPTY_FUNDING_URL,\n        node: toReportNode(fundingMember.value)\n      });\n    }\n  }\n}\n\n/**\n * Reports every key that is not allowed, and every allowed key whose value has the wrong type.\n *\n * @param params - The {@link ReportParams}.\n */\nfunction reportKeyValues(params: ReportParams): void {\n  const { context, manifestObject } = params;\n\n  for (const member of manifestObject.members) {\n    const key = getMemberKey(member);\n    const expectedNodeTypes = KEY_NODE_TYPES.get(key);\n\n    if (!expectedNodeTypes) {\n      context.report({\n        data: { key },\n        messageId: MESSAGE_ID_DISALLOWED_KEY,\n        node: toReportNode(member.name)\n      });\n      continue;\n    }\n\n    if (!expectedNodeTypes.includes(member.value.type)) {\n      context.report({\n        data: {\n          actualType: member.value.type,\n          expectedType: expectedNodeTypes.join(' or '),\n          key\n        },\n        messageId: MESSAGE_ID_INVALID_TYPE,\n        node: toReportNode(member.value)\n      });\n      continue;\n    }\n\n    if (key === 'fundingUrl') {\n      reportFundingUrl({ context, member });\n    }\n  }\n}\n\n/**\n * Reports every required key the manifest is missing.\n *\n * `minAppVersion` is required only once the plugin has been released. `updateVersionInFilesForPlugin`\n * writes it at release time, so a repo still at version `0.0.0` legitimately has none and must not be\n * reported for it.\n *\n * @param params - The {@link ReportParams}.\n */\nfunction reportMissingKeys(params: ReportParams): void {\n  const { context, manifestObject } = params;\n  const requiredKeys = [...ALWAYS_REQUIRED_KEYS, ...(getManifestStringValue(manifestObject, 'version') === UNRELEASED_VERSION ? [] : ['minAppVersion'])];\n\n  for (const key of requiredKeys) {\n    if (!findManifestMember(manifestObject, key)) {\n      context.report({\n        data: { key },\n        messageId: MESSAGE_ID_MISSING_KEY,\n        node: toReportNode(manifestObject)\n      });\n    }\n  }\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/linters/eslint-rules/no-local-obsidian-internals.d.mts

@@ -0,0 +1,10 @@
+/// <reference path="../../index.d.mts" />
+import type { Rule } from 'eslint';
+/**
+Message ID reported for a member a `declare module 'obsidian'` augmentation adds.
+ */
+export declare const MESSAGE_ID = "noLocalObsidianInternals";
+/**
+ * ESLint rule disallowing locally declared Obsidian internals in a `declare module 'obsidian'` augmentation.
+ */
+export declare const noLocalObsidianInternals: Rule.RuleModule;

package/dist/lib/esm/linters/eslint-rules/no-local-obsidian-internals.mjs

@@ -0,0 +1,150 @@
+/*
+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 ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { toTSESTreeNode } from "@mnaoumov/typescript-dev-toolkit/linters/eslint-rules/ts-estree-node";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+const MESSAGE_ID = "noLocalObsidianInternals";
+const OBSIDIAN_MODULE_NAME = "obsidian";
+const EVENT_METHOD_NAMES = /* @__PURE__ */ new Set(["off", "on", "trigger", "tryTrigger"]);
+const noLocalObsidianInternals = {
+  create(context) {
+    return {
+      "TSModuleDeclaration"(node) {
+        const moduleNode = toTSESTreeNode(node);
+        if (moduleNode.id.type !== AST_NODE_TYPES.Literal || moduleNode.id.value !== OBSIDIAN_MODULE_NAME || !moduleNode.body) {
+          return;
+        }
+        const isStringLiteralType = createStringLiteralTypeCheck(context);
+        for (const statement of moduleNode.body.body) {
+          for (const reported of collectReportedNodes(statement, isStringLiteralType)) {
+            context.report({
+              data: { name: describeNode(reported) },
+              loc: reported.loc,
+              messageId: MESSAGE_ID
+            });
+          }
+        }
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Disallow declaring Obsidian internals locally in a `declare module 'obsidian'` augmentation"
+    },
+    messages: {
+      [MESSAGE_ID]: "`{{ name }}` declares Obsidian API locally. Import it from `obsidian-typings` instead, adding it there first if it is missing or wrong. Only a custom-event overload of `on` / `off` / `trigger` / `tryTrigger` may stay here."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+function collectReportedNodes(statement, isStringLiteralType) {
+  const declaration = statement.type === AST_NODE_TYPES.ExportNamedDeclaration && statement.declaration ? statement.declaration : statement;
+  if (declaration.type !== AST_NODE_TYPES.TSInterfaceDeclaration) {
+    return [declaration];
+  }
+  return [
+    ...declaration.extends,
+    ...declaration.body.body.filter((member) => !isCustomEventOverload(member, isStringLiteralType))
+  ];
+}
+function createStringLiteralTypeCheck(context) {
+  const services = context.sourceCode.parserServices;
+  const checker = services.program?.getTypeChecker() ?? null;
+  return isStringLiteralType;
+  function isStringLiteralType(typeNode) {
+    if (typeNode.type === AST_NODE_TYPES.TSUnionType) {
+      return typeNode.types.every((member) => isStringLiteralType(member));
+    }
+    if (typeNode.type === AST_NODE_TYPES.TSLiteralType) {
+      return typeNode.literal.type === AST_NODE_TYPES.Literal && typeof typeNode.literal.value === "string";
+    }
+    if (!checker) {
+      return false;
+    }
+    const type = checker.getTypeFromTypeNode(services.esTreeNodeToTSNodeMap.get(typeNode));
+    return type.isUnion() ? type.types.every((member) => member.isStringLiteral()) : type.isStringLiteral();
+  }
+}
+function describeNode(node) {
+  switch (node.type) {
+    case AST_NODE_TYPES.ClassDeclaration:
+    case AST_NODE_TYPES.FunctionDeclaration:
+    case AST_NODE_TYPES.TSDeclareFunction:
+    case AST_NODE_TYPES.TSEnumDeclaration:
+    case AST_NODE_TYPES.TSModuleDeclaration:
+    case AST_NODE_TYPES.TSTypeAliasDeclaration: {
+      return node.id?.type === AST_NODE_TYPES.Identifier ? node.id.name : node.type;
+    }
+    case AST_NODE_TYPES.TSInterfaceHeritage: {
+      return node.expression.type === AST_NODE_TYPES.Identifier ? `extends ${node.expression.name}` : "extends";
+    }
+    case AST_NODE_TYPES.TSMethodSignature:
+    case AST_NODE_TYPES.TSPropertySignature: {
+      return readKeyName(node.key) ?? node.type;
+    }
+    default: {
+      return node.type;
+    }
+  }
+}
+function isCustomEventOverload(member, isStringLiteralType) {
+  if (member.type !== AST_NODE_TYPES.TSMethodSignature) {
+    return false;
+  }
+  const name = readKeyName(member.key);
+  if (name === null || !EVENT_METHOD_NAMES.has(name)) {
+    return false;
+  }
+  const firstParameter = member.params[0];
+  return firstParameter?.type === AST_NODE_TYPES.Identifier && firstParameter.typeAnnotation !== void 0 && isStringLiteralType(firstParameter.typeAnnotation.typeAnnotation);
+}
+function readKeyName(key) {
+  if (key.type === AST_NODE_TYPES.Identifier) {
+    return key.name;
+  }
+  return key.type === AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
+}
+export {
+  MESSAGE_ID,
+  noLocalObsidianInternals
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/linters/eslint-rules/no-local-obsidian-internals.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * ESLint rule: no-local-obsidian-internals\n *\n * Reports every member a `declare module 'obsidian'` augmentation adds to Obsidian's types.\n *\n * Obsidian's internal (undocumented) API is typed in `obsidian-typings`, where each member is checked against the\n * shipped `app.js` on every release that has it. A local augmentation is a second, unchecked copy of the same\n * claim: it drifts from what Obsidian actually ships, and when `obsidian-typings` gains the member the two\n * declarations merge silently, or clash. The fix for a member `obsidian-typings` lacks or declares wrongly goes\n * into `obsidian-typings`, and the consumer imports it from there.\n *\n * One shape is exempt: an overload of `on`, `off`, `trigger` or `tryTrigger` whose first parameter is a\n * string-literal type, or a union of them. That is how a plugin types its OWN custom events on `Workspace` or\n * another `Events` subclass, so it describes the plugin's code rather than Obsidian's. A name typed through an\n * alias (`name: MyEventName`) is recognized only when the file is linted with type information, which the shared\n * configuration always has.\n *\n * Only the module named exactly `obsidian` is read. A `declare module 'obsidian-typings'` augmentation of\n * `PluginsPluginsRecord` is `obsidian-typings`' designed extension point for third-party plugin types, and is\n * not reported.\n *\n * Not attempted: a local interface or an inline cast that spells an internal shape cannot be told apart from a\n * repository's own types mechanically, so those are left to review.\n */\nimport type {\n  ParserServices,\n  TSESTree\n} from '@typescript-eslint/utils';\nimport type { Rule } from 'eslint';\nimport type { TypeNode } from 'typescript';\n\nimport { toTSESTreeNode } from '@mnaoumov/typescript-dev-toolkit/linters/eslint-rules/ts-estree-node';\nimport { AST_NODE_TYPES } from '@typescript-eslint/utils';\n\n/**\nMessage ID reported for a member a `declare module 'obsidian'` augmentation adds.\n */\nexport const MESSAGE_ID = 'noLocalObsidianInternals';\n\n/**\nThe module name whose augmentations are reported.\n */\nconst OBSIDIAN_MODULE_NAME = 'obsidian';\n\n/**\nThe `Events` methods a custom-event overload may be declared on.\n */\nconst EVENT_METHOD_NAMES = new Set(['off', 'on', 'trigger', 'tryTrigger']);\n\n/**\n * Checks whether a type is a string-literal type, or a union made only of them.\n */\ntype StringLiteralTypeCheck = (typeNode: TSESTree.TypeNode) => boolean;\n\n/**\n * ESLint rule disallowing locally declared Obsidian internals in a `declare module 'obsidian'` augmentation.\n */\nexport const noLocalObsidianInternals: Rule.RuleModule = {\n  create(context) {\n    return {\n      'TSModuleDeclaration'(node: Rule.Node): void {\n        const moduleNode = toTSESTreeNode(node) as TSESTree.TSModuleDeclaration;\n\n        if (moduleNode.id.type !== AST_NODE_TYPES.Literal || moduleNode.id.value !== OBSIDIAN_MODULE_NAME || !moduleNode.body) {\n          return;\n        }\n\n        const isStringLiteralType = createStringLiteralTypeCheck(context);\n\n        for (const statement of moduleNode.body.body) {\n          for (const reported of collectReportedNodes(statement, isStringLiteralType)) {\n            context.report({\n              data: { name: describeNode(reported) },\n              loc: reported.loc,\n              messageId: MESSAGE_ID\n            });\n          }\n        }\n      }\n    };\n  },\n  meta: {\n    docs: {\n      description: 'Disallow declaring Obsidian internals locally in a `declare module \\'obsidian\\'` augmentation'\n    },\n    messages: {\n      [MESSAGE_ID]: '`{{ name }}` declares Obsidian API locally. Import it from `obsidian-typings` instead, adding it there first if it is missing or wrong. Only a custom-event overload of `on` / `off` / `trigger` / `tryTrigger` may stay here.'\n    },\n    schema: [],\n    type: 'problem'\n  }\n};\n\n/**\n * Collects the nodes to report for one statement of a `declare module 'obsidian'` block.\n *\n * An interface is reported member by member, so a custom-event overload can sit beside a reported member, and its\n * `extends` clause is reported too, since that bolts members on as surely as declaring them. Any other statement\n * (a class, a function, a type alias, a variable) is reported whole.\n *\n * @param statement - A statement of the module block.\n * @param isStringLiteralType - The check of whether a type is a string-literal type or a union of them.\n * @returns The nodes to report.\n */\nfunction collectReportedNodes(statement: TSESTree.ProgramStatement, isStringLiteralType: StringLiteralTypeCheck): TSESTree.Node[] {\n  const declaration = statement.type === AST_NODE_TYPES.ExportNamedDeclaration && statement.declaration ? statement.declaration : statement;\n\n  if (declaration.type !== AST_NODE_TYPES.TSInterfaceDeclaration) {\n    return [declaration];\n  }\n\n  return [\n    ...declaration.extends,\n    ...declaration.body.body.filter((member) => !isCustomEventOverload(member, isStringLiteralType))\n  ];\n}\n\n/**\n * Creates the check of whether a type is a string-literal type, or a union made only of them.\n *\n * A type written out as literals (`'my-event' | 'other-event'`) is recognized from the syntax alone. A type reached\n * through an alias (`name: MyEventName`) needs the type checker, so it is recognized only when the file is linted\n * with type information, and reported otherwise.\n *\n * @param context - The rule context.\n * @returns The check.\n */\nfunction createStringLiteralTypeCheck(context: Rule.RuleContext): StringLiteralTypeCheck {\n  const services = context.sourceCode.parserServices as ParserServices;\n  const checker = services.program?.getTypeChecker() ?? null;\n\n  return isStringLiteralType;\n\n  function isStringLiteralType(typeNode: TSESTree.TypeNode): boolean {\n    if (typeNode.type === AST_NODE_TYPES.TSUnionType) {\n      return typeNode.types.every((member) => isStringLiteralType(member));\n    }\n\n    if (typeNode.type === AST_NODE_TYPES.TSLiteralType) {\n      return typeNode.literal.type === AST_NODE_TYPES.Literal && typeof typeNode.literal.value === 'string';\n    }\n\n    if (!checker) {\n      return false;\n    }\n\n    const type = checker.getTypeFromTypeNode(services.esTreeNodeToTSNodeMap.get(typeNode) as TypeNode);\n    return type.isUnion() ? type.types.every((member) => member.isStringLiteral()) : type.isStringLiteral();\n  }\n}\n\n/**\n * Names a reported node for the message.\n *\n * @param node - The reported node.\n * @returns The name to show.\n */\nfunction describeNode(node: TSESTree.Node): string {\n  switch (node.type) {\n    case AST_NODE_TYPES.ClassDeclaration:\n    case AST_NODE_TYPES.FunctionDeclaration:\n    case AST_NODE_TYPES.TSDeclareFunction:\n    case AST_NODE_TYPES.TSEnumDeclaration:\n    case AST_NODE_TYPES.TSModuleDeclaration:\n    case AST_NODE_TYPES.TSTypeAliasDeclaration: {\n      return node.id?.type === AST_NODE_TYPES.Identifier ? node.id.name : node.type;\n    }\n    case AST_NODE_TYPES.TSInterfaceHeritage: {\n      return node.expression.type === AST_NODE_TYPES.Identifier ? `extends ${node.expression.name}` : 'extends';\n    }\n    case AST_NODE_TYPES.TSMethodSignature:\n    case AST_NODE_TYPES.TSPropertySignature: {\n      return readKeyName(node.key) ?? node.type;\n    }\n    default: {\n      return node.type;\n    }\n  }\n}\n\n/**\n * Checks whether an interface member is a custom-event overload: an `on` / `off` / `trigger` / `tryTrigger` method\n * whose first parameter is typed as a string-literal type or a union of them.\n *\n * @param member - The interface member.\n * @param isStringLiteralType - The check of whether a type is a string-literal type or a union of them.\n * @returns `true` when the member is exempt.\n */\nfunction isCustomEventOverload(member: TSESTree.TypeElement, isStringLiteralType: StringLiteralTypeCheck): boolean {\n  if (member.type !== AST_NODE_TYPES.TSMethodSignature) {\n    return false;\n  }\n\n  const name = readKeyName(member.key);\n  if (name === null || !EVENT_METHOD_NAMES.has(name)) {\n    return false;\n  }\n\n  const firstParameter = member.params[0];\n  return firstParameter?.type === AST_NODE_TYPES.Identifier && firstParameter.typeAnnotation !== undefined\n    && isStringLiteralType(firstParameter.typeAnnotation.typeAnnotation);\n}\n\n/**\n * Reads the name of a member key written as an identifier or a string literal.\n *\n * @param key - The member key.\n * @returns The name, or `null` for a computed key.\n */\nfunction readKeyName(key: TSESTree.PropertyName): null | string {\n  if (key.type === AST_NODE_TYPES.Identifier) {\n    return key.name;\n  }\n\n  return key.type === AST_NODE_TYPES.Literal && typeof key.value === 'string' ? key.value : null;\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/linters/eslint-rules/no-over-cap-wait-in-eval-in-obsidian.d.mts

@@ -0,0 +1,10 @@
+/// <reference path="../../index.d.mts" />
+import type { Rule } from 'eslint';
+/**
+ * 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;