@mnaoumov/obsidian-dev-toolkit 0.0.0 → 1.1.0

package/dist/lib/cjs/linters/eslint-config.cjs

@@ -0,0 +1,403 @@
+/*
+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 __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var eslint_config_exports = {};
+__export(eslint_config_exports, {
+  EslintConfigContext: () => import_eslint_config.EslintConfigContext,
+  defineEslintConfigs: () => defineEslintConfigs
+});
+module.exports = __toCommonJS(eslint_config_exports);
+var import_eslint_config = require('@mnaoumov/typescript-dev-toolkit/linters/eslint-config');
+var import_path = require('@mnaoumov/typescript-lib/path');
+var import_eslint_plugin_obsidianmd = __toESM(__extractDefault(require('eslint-plugin-obsidianmd')), 1);
+var import_plainTextParser = require('eslint-plugin-obsidianmd/dist/lib/plainTextParser.js');
+var import_config = require('eslint/config');
+var import_obsidian_plugin_repo_paths = require('../obsidian-plugin-repo-paths.cjs');
+var import_manifest_helpers = require('./eslint-rules/manifest-helpers.cjs');
+var import_obsidian_dev_utils_plugin = require('./eslint-rules/obsidian-dev-utils-plugin.cjs');
+var import_obsidianmd_rule_custom_message = require('./obsidianmd-rule-custom-message.cjs');
+const MINIMUM_NODE_VERSION = ">=16.16.0";
+function defineEslintConfigs(options = {}) {
+  const context = (0, import_eslint_config.createDefaultEslintConfigContext)();
+  if (options.editContext) {
+    options.editContext(context);
+  }
+  const customConfigs = options.customConfigs?.(context) ?? [];
+  return (0, import_config.defineConfig)(
+    ...(0, import_eslint_config.getGlobalIgnoreConfigs)(),
+    ...getObsidianLintConfigs(context),
+    ...(0, import_eslint_config.getTypeScriptEslintConfigs)({ context, inHousePlugin: import_obsidian_dev_utils_plugin.obsidianDevUtilsPlugin, minimumNodeVersion: MINIMUM_NODE_VERSION }),
+    ...getObsidianOverrideConfigs(context),
+    ...getNodeBuiltinsConfigs(context),
+    ...getIntegrationTestConfigs(context),
+    ...getManifestConfigs(),
+    ...getLicenseConfigs(),
+    ...customConfigs
+  );
+}
+function getIntegrationTestConfigs(context) {
+  return (0, import_config.defineConfig)([
+    {
+      /*
+       * An integration test that drives the UI with `dispatchEvent(new KeyboardEvent(...))` produces an
+       * UNTRUSTED event, and Obsidian and CodeMirror gate on `isTrusted` — so the test can exercise
+       * nothing while still passing. Only integration tests are covered: a unit test has no real input
+       * pipeline to reach, so dispatching is the only thing it can do.
+       *
+       * Android files used to be exempt BY FILENAME, on the grounds that the trusted helpers were built on
+       * `window.electron` and so could not be reached from a phone at all. That exemption is gone: the
+       * harness gained a mobile trusted-input path, and `clickElement`, `clickMouse`, `pressKey` and
+       * `typeIntoEditor` all work there. Only the hover helpers still throw, because `:hover` has no touch
+       * equivalent — a file reaching for those has to branch on `Platform.isDesktopApp`, which is the same
+       * thing a `*.cross-platform.*` file has always had to do.
+       */
+      files: context.sourceFolders.map((sourceFolder) => (0, import_path.join)(sourceFolder, import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.AnyPath, import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.AnyIntegrationTestTs)),
+      rules: {
+        "obsidian-dev-utils/no-untrusted-input-events": "error"
+      }
+    }
+  ]);
+}
+function getLicenseConfigs() {
+  return (0, import_config.defineConfig)([
+    {
+      files: [import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.License],
+      languageOptions: {
+        parser: import_plainTextParser.PlainTextParser
+      },
+      plugins: {
+        obsidianmd: import_eslint_plugin_obsidianmd.default
+      },
+      rules: {
+        "obsidianmd/validate-license": "error"
+      }
+    }
+  ]);
+}
+function getManifestConfigs() {
+  return (0, import_config.defineConfig)([
+    {
+      files: [import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.ManifestJson],
+      language: "json/json",
+      plugins: {
+        "json": import_manifest_helpers.jsonPlugin,
+        "obsidian-dev-utils": import_obsidian_dev_utils_plugin.obsidianDevUtilsPlugin
+      },
+      rules: {
+        "obsidian-dev-utils/manifest-description": "error",
+        "obsidian-dev-utils/manifest-id": "error",
+        "obsidian-dev-utils/manifest-name": "error",
+        "obsidian-dev-utils/manifest-schema": "error"
+      }
+    }
+  ]);
+}
+function getNodeBuiltinsConfigs(context) {
+  return (0, import_config.defineConfig)([
+    {
+      // Integration tests run in a Node environment and legitimately read files / paths, so the Node-builtins bans do not apply to them.
+      files: context.sourceFolders.map((sourceFolder) => (0, import_path.join)(sourceFolder, import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.AnyPath, import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.AnyIntegrationTestTs)),
+      rules: {
+        "import-x/no-nodejs-modules": "off",
+        "obsidianmd/no-nodejs-modules": "off"
+      }
+    },
+    {
+      /*
+       * A `desktop-` prefixed module is desktop-only by convention: it is reached only through a
+       * `Platform.isDesktopApp`-gated dynamic `import()` in its caller, so its static Node imports never
+       * load on mobile. Neither rule can see that gate, because it sits one file up — the correctly-written pattern
+       * reports anyway, and no author-side rewrite silences it.
+       *
+       * Exempting BY FILENAME rather than by a disable comment carries a trade-off knowingly: the exemption keys
+       * off what the file is NAMED rather than what it does, so the prefix is load-bearing. A desktop-only module
+       * that skips the prefix keeps reporting, and a cross-platform module that wrongly takes it gets an exemption
+       * it should not have.
+       */
+      files: context.sourceFolders.map((sourceFolder) => (0, import_path.join)(sourceFolder, import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.AnyPath, import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.AnyDesktopTs)),
+      rules: {
+        "import-x/no-nodejs-modules": "off",
+        "obsidianmd/no-nodejs-modules": "off"
+      }
+    },
+    {
+      /*
+       * A unit test runs under vitest in Node and is never bundled into `main.js`, so the Node-builtins bans do not
+       * apply to it either — the identical argument the integration-test block above already accepts. This also
+       * covers the SUT-grouped `*.desktop.test.ts` shape, which names the platform as a dot segment after the
+       * subject under test rather than as a `desktop-` prefix.
+       */
+      files: context.testFiles,
+      rules: {
+        "import-x/no-nodejs-modules": "off",
+        "obsidianmd/no-nodejs-modules": "off"
+      }
+    }
+  ]);
+}
+function getObsidianLintConfigs(context) {
+  const obsidianRecommendedConfigs = import_eslint_plugin_obsidianmd.default.configs.recommended;
+  const ownedRuleNames = new Set((0, import_eslint_config.getEslintCoreConfigs)(context).flatMap((config) => Object.keys(config.rules ?? {})));
+  const scopedObsidianRecommendedConfigs = obsidianRecommendedConfigs.map((config) => {
+    return config.files?.includes("package.json") ? config : {
+      ...(0, import_obsidianmd_rule_custom_message.stripOwnedRuleCustomMessageEntries)({ config, ownedRuleNames }),
+      files: context.sourceFiles
+    };
+  });
+  return (0, import_config.defineConfig)([
+    {
+      extends: [scopedObsidianRecommendedConfigs],
+      plugins: {
+        obsidianmd: import_eslint_plugin_obsidianmd.default
+      }
+    }
+  ]);
+}
+function getObsidianOverrideConfigs(context) {
+  return (0, import_config.defineConfig)([
+    {
+      files: context.sourceFolders.map((sourceFolder) => (0, import_path.join)(sourceFolder, import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.MainTs)),
+      rules: {
+        "import-x/no-default-export": "off"
+      }
+    },
+    {
+      files: context.allFiles(),
+      plugins: {
+        "obsidian-dev-utils": import_obsidian_dev_utils_plugin.obsidianDevUtilsPlugin
+      },
+      rules: {
+        /*
+         * Deliberately here, on `allFiles()`, rather than beside `no-untrusted-input-events` in
+         * `getIntegrationTestConfigs()` (owner, 2026-09-09). An `evalInObsidian` call is unmistakable, so a
+         * file that makes none is untouched and a broad glob costs nothing -- while script code that drives
+         * a real Obsidian outside a test (`demo-vault-buttons.ts`) is under the same transport cap and would
+         * otherwise be enforced nowhere.
+         */
+        "obsidian-dev-utils/no-over-cap-wait-in-eval-in-obsidian": "error",
+        "obsidian-dev-utils/require-component-suffix": "error",
+        /*
+         * Obsidian's `Component` has its own `removeChild(component)` for the component lifecycle, unrelated
+         * to `Node#removeChild`. The rule matches on the method name alone, so every report here is a
+         * component being unloaded, and following the advice calls a `remove()` that does not exist -- which
+         * is what `tsc` said when the fixer was let loose on them.
+         */
+        "unicorn/prefer-dom-node-remove": "off",
+        /*
+         * Directly contradicts `obsidianmd/no-global-this`: this rule rewrites `window.x` to `globalThis.x`, and
+         * that one forbids `globalThis` outright. With both enabled, `--fix` applies one and then the other
+         * reverts it, which ESLint reports as `ESLintCircularFixesWarning` across 29 files. Obsidian's own
+         * guidance wins in an Obsidian library, so this is the rule that gives way.
+         */
+        "unicorn/prefer-global-this": "off"
+      }
+    },
+    {
+      /*
+       * Obsidian's internal API is typed in `obsidian-typings`, so a `declare module 'obsidian'` augmentation in
+       * shipped source may carry only the plugin's own custom-event overloads. Tests are exempt: a mock shape or a
+       * harness global never ships.
+       */
+      files: context.sourceFiles,
+      ignores: context.testFiles,
+      plugins: {
+        "obsidian-dev-utils": import_obsidian_dev_utils_plugin.obsidianDevUtilsPlugin
+      },
+      rules: {
+        "obsidian-dev-utils/no-local-obsidian-internals": "error"
+      }
+    },
+    {
+      /*
+       * Every method entry of a plugin API contract carries an `input` and an `output` schema, so a `{}` entry that
+       * validates nothing cannot come back where the contract type is untyped and the compiler does not refuse it.
+       * Tests are exempt: they may publish a deliberately broken contract.
+       *
+       * Registered but OFF: several providers and consumers still carry `{}` entries, and turning it on first would
+       * make their lint red. Switch it to `'error'` once none is left.
+       */
+      files: context.sourceFiles,
+      ignores: context.testFiles,
+      plugins: {
+        "obsidian-dev-utils": import_obsidian_dev_utils_plugin.obsidianDevUtilsPlugin
+      },
+      rules: {
+        "obsidian-dev-utils/require-plugin-api-contract-schemas": "off"
+      }
+    },
+    {
+      /*
+       * A plugin's display name is marked as code: backticks in a comment (`plugin-name-as-code`, autofixed), a
+       * `<code>` element in UI (`plugin-name-as-code-in-ui`, reported only).
+       *
+       * Registered but OFF: repositories still carry plain plugin names from before the rules existed, and turning
+       * them on first would make their lint red. Switch them to `'error'` once those are fixed. Both take
+       * `{ additionalPluginNames: [...] }` for names the shared list lacks.
+       */
+      files: context.allFiles(),
+      plugins: {
+        "obsidian-dev-utils": import_obsidian_dev_utils_plugin.obsidianDevUtilsPlugin
+      },
+      rules: {
+        "obsidian-dev-utils/plugin-name-as-code": "off",
+        "obsidian-dev-utils/plugin-name-as-code-in-ui": "off"
+      }
+    }
+  ]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EslintConfigContext,
+  defineEslintConfigs
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/linters/eslint-config.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * The shared ESLint configuration for Obsidian plugins.\n *\n * It is the generic configuration of `@mnaoumov/typescript-dev-toolkit` plus the Obsidian layers alone:\n * `eslint-plugin-obsidianmd`'s recommended rules, the root `manifest.json` and `LICENSE`, the Node-builtins exemptions\n * of desktop-only modules and tests, the integration-test rules and the Obsidian in-house rules.\n */\n\n/* v8 ignore start -- Declarative ESLint rule/plugin configuration; correctness is verified by running ESLint, not unit tests. */\n\nimport type { DefineEslintConfigsOptions } from '@mnaoumov/typescript-dev-toolkit/linters/eslint-config';\nimport type { Linter } from 'eslint';\n\nimport {\n  createDefaultEslintConfigContext,\n  EslintConfigContext,\n  getEslintCoreConfigs,\n  getGlobalIgnoreConfigs,\n  getTypeScriptEslintConfigs\n} from '@mnaoumov/typescript-dev-toolkit/linters/eslint-config';\nimport { join } from '@mnaoumov/typescript-lib/path';\n// eslint-disable-next-line import-x/no-rename-default -- The default export name `plugin` is too confusing.\nimport obsidianmd from 'eslint-plugin-obsidianmd';\nimport { PlainTextParser } from 'eslint-plugin-obsidianmd/dist/lib/plainTextParser.js';\nimport { defineConfig } from 'eslint/config';\n\nimport { ObsidianPluginRepoPaths } from '../obsidian-plugin-repo-paths.ts';\nimport { jsonPlugin } from './eslint-rules/manifest-helpers.ts';\nimport { obsidianDevUtilsPlugin } from './eslint-rules/obsidian-dev-utils-plugin.ts';\nimport { stripOwnedRuleCustomMessageEntries } from './obsidianmd-rule-custom-message.ts';\n\n// eslint-disable-next-line unicorn/prefer-export-from -- Re-exported so a plugin's `scripts/eslint-config.ts` keeps importing both from here.\nexport type { DefineEslintConfigsOptions };\n// eslint-disable-next-line unicorn/prefer-export-from -- Re-exported so a plugin's `scripts/eslint-config.ts` keeps importing both from here.\nexport { EslintConfigContext };\n\n/*\n * The minimum Obsidian installer that still receives app updates and works is 1.1.9, which ships Electron\n * 21.3.3 and runs Node 16.16.0. Shipped source must therefore avoid Node/ES runtime builtins unavailable in\n * that version. Tests and scripts are dev-only and exempt.\n *\n * Source of truth: `obsidian-integration-testing/metadata.json` \u2014 the newest release carrying the field\n * (1.13.1) declares `minRunnableInstallerVersion: \"1.1.9\"`, and that installer's `runtimeVersions` gives the\n * Electron and Node versions above. Re-derive from there rather than editing this number by hand.\n */\nconst MINIMUM_NODE_VERSION = '>=16.16.0';\n\n/**\n * Build ESLint configurations.\n *\n * This function builds the ESLint configurations of an Obsidian plugin: the generic configuration of\n * `@mnaoumov/typescript-dev-toolkit` plus the Obsidian layers.\n *\n * @param options - The parameters for defining ESLint configurations.\n * @returns The ESLint configurations.\n */\nexport function defineEslintConfigs(options: DefineEslintConfigsOptions = {}): Linter.Config[] {\n  const context = createDefaultEslintConfigContext();\n\n  if (options.editContext) {\n    options.editContext(context);\n  }\n\n  const customConfigs = options.customConfigs?.(context) ?? [];\n\n  return defineConfig(\n    ...getGlobalIgnoreConfigs(),\n    // Obsidianmd configs run first so our stricter rules override their relaxed defaults\n    ...getObsidianLintConfigs(context),\n    ...getTypeScriptEslintConfigs({ context, inHousePlugin: obsidianDevUtilsPlugin, minimumNodeVersion: MINIMUM_NODE_VERSION }),\n    ...getObsidianOverrideConfigs(context),\n    ...getNodeBuiltinsConfigs(context),\n    ...getIntegrationTestConfigs(context),\n    ...getManifestConfigs(),\n    ...getLicenseConfigs(),\n    ...customConfigs\n  );\n}\nfunction getIntegrationTestConfigs(context: EslintConfigContext): Linter.Config[] {\n  return defineConfig([\n    {\n      /*\n       * An integration test that drives the UI with `dispatchEvent(new KeyboardEvent(...))` produces an\n       * UNTRUSTED event, and Obsidian and CodeMirror gate on `isTrusted` \u2014 so the test can exercise\n       * nothing while still passing. Only integration tests are covered: a unit test has no real input\n       * pipeline to reach, so dispatching is the only thing it can do.\n       *\n       * Android files used to be exempt BY FILENAME, on the grounds that the trusted helpers were built on\n       * `window.electron` and so could not be reached from a phone at all. That exemption is gone: the\n       * harness gained a mobile trusted-input path, and `clickElement`, `clickMouse`, `pressKey` and\n       * `typeIntoEditor` all work there. Only the hover helpers still throw, because `:hover` has no touch\n       * equivalent \u2014 a file reaching for those has to branch on `Platform.isDesktopApp`, which is the same\n       * thing a `*.cross-platform.*` file has always had to do.\n       */\n      files: context.sourceFolders.map((sourceFolder) => join(sourceFolder, ObsidianPluginRepoPaths.AnyPath, ObsidianPluginRepoPaths.AnyIntegrationTestTs)),\n      rules: {\n        'obsidian-dev-utils/no-untrusted-input-events': 'error'\n      }\n    }\n  ]);\n}\n\n/*\n * The Community directory requires a root `LICENSE`, and `obsidianmd/validate-license` is the only check\n * on what it says: the copyright holder must not still be the sample plugin's, and the year must be\n * current. Both need `PlainTextParser`, which the plugin does not export, so it is reached through its\n * build output -- the package declares no `exports` map and ships a declaration beside the module, so the\n * deep path resolves, but it is the one import here that a patch release upstream could break.\n *\n * The rule compares the year against `new Date().getFullYear()` at lint time, so a repo goes red at the\n * turn of the year until its LICENSE is bumped. `.github/workflows/update-license-year.yml` does that on\n * 1 January; a repo adopting this config needs the same workflow, or the year check will fail its CI.\n */\nfunction getLicenseConfigs(): Linter.Config[] {\n  return defineConfig([\n    {\n      files: [ObsidianPluginRepoPaths.License],\n      languageOptions: {\n        parser: PlainTextParser\n      },\n      plugins: {\n        obsidianmd\n      },\n      rules: {\n        'obsidianmd/validate-license': 'error'\n      }\n    }\n  ]);\n}\n\n/*\n * The root `manifest.json` is what the Community directory's automated review actually reads, and until\n * this config existed no linter read it at all: `obsidianmd/validate-manifest` registers a `Program`\n * visitor and expects an ESTree `ObjectExpression`, while every JSON parser that ships produces something\n * else -- `@eslint/json` produces Momoa (`Document`), `jsonc-eslint-parser` produces\n * `JSONObjectExpression` -- so the rule silently matches nothing no matter which files it is scoped to.\n * The in-house rules below visit the Momoa AST instead.\n *\n * `manifest.json` is strict JSON, so an `eslint-disable` comment in it is a parse error AND would stop\n * Obsidian loading the plugin. That makes the config the only place a check can be waived, which is why\n * these are four rules rather than one: a repo with a grandfathered `id` can turn off `manifest-id` alone\n * and keep the rest.\n */\nfunction getManifestConfigs(): Linter.Config[] {\n  return defineConfig([\n    {\n      files: [ObsidianPluginRepoPaths.ManifestJson],\n      language: 'json/json',\n      plugins: {\n        'json': jsonPlugin,\n        'obsidian-dev-utils': obsidianDevUtilsPlugin\n      },\n      rules: {\n        'obsidian-dev-utils/manifest-description': 'error',\n        'obsidian-dev-utils/manifest-id': 'error',\n        'obsidian-dev-utils/manifest-name': 'error',\n        'obsidian-dev-utils/manifest-schema': 'error'\n      }\n    }\n  ]);\n}\n\n/*\n * Every file set that is exempt from the Node-builtins bans, in one place.\n *\n * Two rules ban Node builtins, and they are NOT interchangeable. `import-x/no-nodejs-modules` is ours, it is\n * an error, and its waivers are tolerated by the community-directory review runner. `obsidianmd/no-nodejs-modules`\n * arrives via `obsidianmd.configs.recommended` (see `getObsidianLintConfigs`) and is strictly weaker on static\n * imports \u2014 its own source says \"Static import declarations can never be guarded at runtime\", so it reports every\n * `ImportDeclaration` of a builtin unconditionally and only `import()` / `require()` get guard-awareness. It is\n * also one the consumer CANNOT WAIVE: the directory runner sets\n * `eslint-comments/no-restricted-disable: ['error', 'obsidianmd/*', ...]`, whitelisting only\n * `obsidianmd/ui/sentence-case`, so an inline disable of it trades a warning for an error in a review. That is why\n * every exemption below has to live here in the shared config rather than as a comment at the call site.\n *\n * One further exemption deliberately lives elsewhere: `getImportXConfigs` turns off only `import-x/no-nodejs-modules`\n * for `context.scriptFiles`. It needs no `obsidianmd` twin, because `getObsidianLintConfigs` scopes the obsidianmd\n * rules to `context.sourceFiles`, so they never reach scripts in the first place.\n */\nfunction getNodeBuiltinsConfigs(context: EslintConfigContext): Linter.Config[] {\n  return defineConfig([\n    {\n      // Integration tests run in a Node environment and legitimately read files / paths, so the Node-builtins bans do not apply to them.\n      files: context.sourceFolders.map((sourceFolder) => join(sourceFolder, ObsidianPluginRepoPaths.AnyPath, ObsidianPluginRepoPaths.AnyIntegrationTestTs)),\n      rules: {\n        'import-x/no-nodejs-modules': 'off',\n        'obsidianmd/no-nodejs-modules': 'off'\n      }\n    },\n    {\n      /*\n       * A `desktop-` prefixed module is desktop-only by convention: it is reached only through a\n       * `Platform.isDesktopApp`-gated dynamic `import()` in its caller, so its static Node imports never\n       * load on mobile. Neither rule can see that gate, because it sits one file up \u2014 the correctly-written pattern\n       * reports anyway, and no author-side rewrite silences it.\n       *\n       * Exempting BY FILENAME rather than by a disable comment carries a trade-off knowingly: the exemption keys\n       * off what the file is NAMED rather than what it does, so the prefix is load-bearing. A desktop-only module\n       * that skips the prefix keeps reporting, and a cross-platform module that wrongly takes it gets an exemption\n       * it should not have.\n       */\n      files: context.sourceFolders.map((sourceFolder) => join(sourceFolder, ObsidianPluginRepoPaths.AnyPath, ObsidianPluginRepoPaths.AnyDesktopTs)),\n      rules: {\n        'import-x/no-nodejs-modules': 'off',\n        'obsidianmd/no-nodejs-modules': 'off'\n      }\n    },\n    {\n      /*\n       * A unit test runs under vitest in Node and is never bundled into `main.js`, so the Node-builtins bans do not\n       * apply to it either \u2014 the identical argument the integration-test block above already accepts. This also\n       * covers the SUT-grouped `*.desktop.test.ts` shape, which names the platform as a dot segment after the\n       * subject under test rather than as a `desktop-` prefix.\n       */\n      files: context.testFiles,\n      rules: {\n        'import-x/no-nodejs-modules': 'off',\n        'obsidianmd/no-nodejs-modules': 'off'\n      }\n    }\n  ]);\n}\n\nfunction getObsidianLintConfigs(context: EslintConfigContext): Linter.Config[] {\n  const obsidianRecommendedConfigs = obsidianmd.configs.recommended;\n\n  /*\n   * A builtin this config sets itself must not ALSO run through `obsidianmd/rule-custom-message`, or a consumer's own\n   * `'no-console': 'off'` is inert and every console line is reported twice. See `obsidianmd-rule-custom-message.ts`.\n   */\n  const ownedRuleNames = new Set(getEslintCoreConfigs(context).flatMap((config) => Object.keys(config.rules ?? {})));\n\n  const scopedObsidianRecommendedConfigs = obsidianRecommendedConfigs.map((config) => {\n    return config.files?.includes('package.json')\n      ? config\n      : {\n        ...stripOwnedRuleCustomMessageEntries({ config, ownedRuleNames }),\n        files: context.sourceFiles\n      };\n  });\n\n  return defineConfig([\n    {\n      extends: [scopedObsidianRecommendedConfigs],\n      plugins: {\n        obsidianmd\n      }\n    }\n  ]);\n}\n\nfunction getObsidianOverrideConfigs(context: EslintConfigContext): Linter.Config[] {\n  return defineConfig([\n    {\n      files: context.sourceFolders.map((sourceFolder) => join(sourceFolder, ObsidianPluginRepoPaths.MainTs)),\n      rules: {\n        'import-x/no-default-export': 'off'\n      }\n    },\n    {\n      files: context.allFiles(),\n      plugins: {\n        'obsidian-dev-utils': obsidianDevUtilsPlugin\n      },\n      rules: {\n        /*\n         * Deliberately here, on `allFiles()`, rather than beside `no-untrusted-input-events` in\n         * `getIntegrationTestConfigs()` (owner, 2026-09-09). An `evalInObsidian` call is unmistakable, so a\n         * file that makes none is untouched and a broad glob costs nothing -- while script code that drives\n         * a real Obsidian outside a test (`demo-vault-buttons.ts`) is under the same transport cap and would\n         * otherwise be enforced nowhere.\n         */\n        'obsidian-dev-utils/no-over-cap-wait-in-eval-in-obsidian': 'error',\n        'obsidian-dev-utils/require-component-suffix': 'error',\n        /*\n         * Obsidian's `Component` has its own `removeChild(component)` for the component lifecycle, unrelated\n         * to `Node#removeChild`. The rule matches on the method name alone, so every report here is a\n         * component being unloaded, and following the advice calls a `remove()` that does not exist -- which\n         * is what `tsc` said when the fixer was let loose on them.\n         */\n        'unicorn/prefer-dom-node-remove': 'off',\n        /*\n         * Directly contradicts `obsidianmd/no-global-this`: this rule rewrites `window.x` to `globalThis.x`, and\n         * that one forbids `globalThis` outright. With both enabled, `--fix` applies one and then the other\n         * reverts it, which ESLint reports as `ESLintCircularFixesWarning` across 29 files. Obsidian's own\n         * guidance wins in an Obsidian library, so this is the rule that gives way.\n         */\n        'unicorn/prefer-global-this': 'off'\n      }\n    },\n    {\n      /*\n       * Obsidian's internal API is typed in `obsidian-typings`, so a `declare module 'obsidian'` augmentation in\n       * shipped source may carry only the plugin's own custom-event overloads. Tests are exempt: a mock shape or a\n       * harness global never ships.\n       */\n      files: context.sourceFiles,\n      ignores: context.testFiles,\n      plugins: {\n        'obsidian-dev-utils': obsidianDevUtilsPlugin\n      },\n      rules: {\n        'obsidian-dev-utils/no-local-obsidian-internals': 'error'\n      }\n    },\n    {\n      /*\n       * Every method entry of a plugin API contract carries an `input` and an `output` schema, so a `{}` entry that\n       * validates nothing cannot come back where the contract type is untyped and the compiler does not refuse it.\n       * Tests are exempt: they may publish a deliberately broken contract.\n       *\n       * Registered but OFF: several providers and consumers still carry `{}` entries, and turning it on first would\n       * make their lint red. Switch it to `'error'` once none is left.\n       */\n      files: context.sourceFiles,\n      ignores: context.testFiles,\n      plugins: {\n        'obsidian-dev-utils': obsidianDevUtilsPlugin\n      },\n      rules: {\n        'obsidian-dev-utils/require-plugin-api-contract-schemas': 'off'\n      }\n    },\n    {\n      /*\n       * A plugin's display name is marked as code: backticks in a comment (`plugin-name-as-code`, autofixed), a\n       * `<code>` element in UI (`plugin-name-as-code-in-ui`, reported only).\n       *\n       * Registered but OFF: repositories still carry plain plugin names from before the rules existed, and turning\n       * them on first would make their lint red. Switch them to `'error'` once those are fixed. Both take\n       * `{ additionalPluginNames: [...] }` for names the shared list lacks.\n       */\n      files: context.allFiles(),\n      plugins: {\n        'obsidian-dev-utils': obsidianDevUtilsPlugin\n      },\n      rules: {\n        'obsidian-dev-utils/plugin-name-as-code': 'off',\n        'obsidian-dev-utils/plugin-name-as-code-in-ui': 'off'\n      }\n    }\n  ]);\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["obsidianmd"]
}


package/dist/lib/cjs/linters/eslint-config.d.cts

@@ -0,0 +1,25 @@
+/// <reference path="../index.d.cts" />
+/**
+ * @file
+ *
+ * The shared ESLint configuration for Obsidian plugins.
+ *
+ * It is the generic configuration of `@mnaoumov/typescript-dev-toolkit` plus the Obsidian layers alone:
+ * `eslint-plugin-obsidianmd`'s recommended rules, the root `manifest.json` and `LICENSE`, the Node-builtins exemptions
+ * of desktop-only modules and tests, the integration-test rules and the Obsidian in-house rules.
+ */
+import type { DefineEslintConfigsOptions } from '@mnaoumov/typescript-dev-toolkit/linters/eslint-config' with { 'resolution-mode': 'import' };
+import type { Linter } from 'eslint' with { 'resolution-mode': 'import' };
+import { EslintConfigContext } from '@mnaoumov/typescript-dev-toolkit/linters/eslint-config';
+export type { DefineEslintConfigsOptions };
+export { EslintConfigContext };
+/**
+ * Build ESLint configurations.
+ *
+ * This function builds the ESLint configurations of an Obsidian plugin: the generic configuration of
+ * `@mnaoumov/typescript-dev-toolkit` plus the Obsidian layers.
+ *
+ * @param options - The parameters for defining ESLint configurations.
+ * @returns The ESLint configurations.
+ */
+export declare function defineEslintConfigs(options?: DefineEslintConfigsOptions): Linter.Config[];