@mnaoumov/obsidian-dev-toolkit 1.0.0 → 1.1.0

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

@@ -0,0 +1,259 @@
+/*
+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 keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord["__name"] ??= keepName;
+  globalThisRecord["__extractDefault"] ??= extractDefault;
+  ensureBrowserProcess();
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+})();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+
+  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_local_obsidian_internals_exports = {};
+__export(no_local_obsidian_internals_exports, {
+  MESSAGE_ID: () => MESSAGE_ID,
+  noLocalObsidianInternals: () => noLocalObsidianInternals
+});
+module.exports = __toCommonJS(no_local_obsidian_internals_exports);
+var import_ts_estree_node = require('@mnaoumov/typescript-dev-toolkit/linters/eslint-rules/ts-estree-node');
+var import_utils = require('@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 = (0, import_ts_estree_node.toTSESTreeNode)(node);
+        if (moduleNode.id.type !== import_utils.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 === import_utils.AST_NODE_TYPES.ExportNamedDeclaration && statement.declaration ? statement.declaration : statement;
+  if (declaration.type !== import_utils.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 === import_utils.AST_NODE_TYPES.TSUnionType) {
+      return typeNode.types.every((member) => isStringLiteralType(member));
+    }
+    if (typeNode.type === import_utils.AST_NODE_TYPES.TSLiteralType) {
+      return typeNode.literal.type === import_utils.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 import_utils.AST_NODE_TYPES.ClassDeclaration:
+    case import_utils.AST_NODE_TYPES.FunctionDeclaration:
+    case import_utils.AST_NODE_TYPES.TSDeclareFunction:
+    case import_utils.AST_NODE_TYPES.TSEnumDeclaration:
+    case import_utils.AST_NODE_TYPES.TSModuleDeclaration:
+    case import_utils.AST_NODE_TYPES.TSTypeAliasDeclaration: {
+      return node.id?.type === import_utils.AST_NODE_TYPES.Identifier ? node.id.name : node.type;
+    }
+    case import_utils.AST_NODE_TYPES.TSInterfaceHeritage: {
+      return node.expression.type === import_utils.AST_NODE_TYPES.Identifier ? `extends ${node.expression.name}` : "extends";
+    }
+    case import_utils.AST_NODE_TYPES.TSMethodSignature:
+    case import_utils.AST_NODE_TYPES.TSPropertySignature: {
+      return readKeyName(node.key) ?? node.type;
+    }
+    default: {
+      return node.type;
+    }
+  }
+}
+function isCustomEventOverload(member, isStringLiteralType) {
+  if (member.type !== import_utils.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 === import_utils.AST_NODE_TYPES.Identifier && firstParameter.typeAnnotation !== void 0 && isStringLiteralType(firstParameter.typeAnnotation.typeAnnotation);
+}
+function readKeyName(key) {
+  if (key.type === import_utils.AST_NODE_TYPES.Identifier) {
+    return key.name;
+  }
+  return key.type === import_utils.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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/cjs/linters/eslint-rules/no-local-obsidian-internals.d.cts

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