@mnaoumov/obsidian-dev-toolkit 0.0.0 → 1.1.0

package/dist/lib/esm/linters/eslint-rules/no-untrusted-input-events.d.mts

@@ -0,0 +1,10 @@
+/// <reference path="../../index.d.mts" />
+import type { Rule } from 'eslint';
+/**
+Message ID reported when an integration test drives the UI with a dispatched input event.
+ */
+export declare const MESSAGE_ID = "noUntrustedInputEvents";
+/**
+ * ESLint rule disallowing untrusted input events in integration tests, where they can silently exercise nothing.
+ */
+export declare const noUntrustedInputEvents: Rule.RuleModule;

package/dist/lib/esm/linters/eslint-rules/no-untrusted-input-events.mjs

@@ -0,0 +1,138 @@
+/*
+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";
+const MESSAGE_ID = "noUntrustedInputEvents";
+const ADVICE_BY_EVENT_NAME = /* @__PURE__ */ new Map([
+  ["DragEvent", "there is no trusted equivalent, because `sendInputEvent` cannot express a drag, so keep the dispatch and disable this rule with the reason"],
+  ["KeyboardEvent", "use `pressKey`, focusing the target first, since a trusted key press goes to whatever holds DOM focus"],
+  ["MouseEvent", "use `clickElement`, or `clickMouse` when the point to click is not an element centre"],
+  ["PointerEvent", "use `clickElement`, or `clickMouse` when the point to click is not an element centre"],
+  ["TouchEvent", "there is no trusted equivalent, so keep the dispatch and disable this rule with the reason"],
+  ["WheelEvent", "there is no trusted equivalent, so keep the dispatch and disable this rule with the reason"]
+]);
+const noUntrustedInputEvents = {
+  create(context) {
+    return {
+      "CallExpression"(node) {
+        const callNode = toTSESTreeNode(node);
+        if (!isDispatchEventCall(callNode)) {
+          return;
+        }
+        const argument = callNode.arguments[0];
+        if (!argument) {
+          return;
+        }
+        const eventName = resolveEventName(argument, node, context);
+        if (eventName === null) {
+          return;
+        }
+        const advice = ADVICE_BY_EVENT_NAME.get(eventName);
+        if (advice === void 0) {
+          return;
+        }
+        context.report({
+          data: {
+            advice,
+            eventName
+          },
+          messageId: MESSAGE_ID,
+          node
+        });
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Disallow driving integration tests with dispatched (untrusted) input events"
+    },
+    messages: {
+      [MESSAGE_ID]: "A dispatched {{ eventName }} is untrusted (`isTrusted === false`) and Obsidian may ignore it, so this can exercise nothing while still passing: {{ advice }}."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+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 isDispatchEventCall(node) {
+  const callee = node.callee;
+  return callee.type === "MemberExpression" && callee.property.type === "Identifier" && callee.property.name === "dispatchEvent";
+}
+function readConstructorName(node) {
+  return node.callee.type === "Identifier" ? node.callee.name : null;
+}
+function resolveEventName(argument, node, context) {
+  if (argument.type === "NewExpression") {
+    return readConstructorName(argument);
+  }
+  if (argument.type !== "Identifier") {
+    return null;
+  }
+  const variable = findVariable(context.sourceCode.getScope(node), argument.name);
+  if (!variable) {
+    return null;
+  }
+  for (const definition of variable.defs) {
+    const definitionNode = toTSESTreeNode(definition.node);
+    if (definitionNode.type !== "VariableDeclarator" || !definitionNode.init) {
+      continue;
+    }
+    if (definitionNode.init.type === "NewExpression") {
+      return readConstructorName(definitionNode.init);
+    }
+  }
+  return null;
+}
+export {
+  MESSAGE_ID,
+  noUntrustedInputEvents
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/linters/eslint-rules/no-untrusted-input-events.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * ESLint rule: no-untrusted-input-events\n *\n * Reports an integration test that drives the UI by dispatching an INPUT event \u2014\n * `el.dispatchEvent(new KeyboardEvent(...))`, `new MouseEvent(...)`, and friends.\n *\n * Such an event is untrusted (`isTrusted === false`), and Obsidian and CodeMirror\n * routinely gate on exactly that: Obsidian 1.13's markdown viewport menu opens from\n * a listener guarded by `e.isTrusted`, so a dispatched `contextmenu` reaches nothing.\n * The test then exercises NOTHING while still passing whatever weaker assertion it\n * makes \u2014 a false-confidence failure, not a flake.\n *\n * The trusted alternatives \u2014 `pressKey`, `clickElement`, `clickMouse`, `hoverElement`,\n * `typeIntoEditor` \u2014 are seeded into the `evalInObsidian` callback's `lib` bag, and are\n * also importable from `obsidian-dev-utils/obsidian/trusted-input`, which picks the\n * desktop or mobile injector itself. All of them work on Android except the hover\n * helpers, which throw there because `:hover` has no touch equivalent.\n *\n * NOTIFICATION events are deliberately NOT reported. `new Event('input')` after setting\n * an element's `.value` is telling the app about a change rather than pretending to be a\n * user, and nothing gates it on `isTrusted`.\n *\n * Not every dispatch is wrong, so the rule is meant to be disabled \u2014 with a reason \u2014 at\n * the sites that have one: a drag sequence, which `sendInputEvent` cannot express at all;\n * the mobile arm of a hover gesture, which has no touch equivalent; and a listener that\n * is the plugin's own and checks nothing but the key. `require-description`\n * makes that reason mandatory, which is the point: the rule turns an invisible assumption\n * into a written one.\n */\nimport type { TSESTree } from '@typescript-eslint/utils';\nimport type {\n  Rule,\n  Scope\n} from 'eslint';\n\nimport { toTSESTreeNode } from '@mnaoumov/typescript-dev-toolkit/linters/eslint-rules/ts-estree-node';\n\n/**\nMessage ID reported when an integration test drives the UI with a dispatched input event.\n */\nexport const MESSAGE_ID = 'noUntrustedInputEvents';\n\n/**\n * What to do instead, per event constructor. An event absent from this map is a\n * notification rather than simulated input, and is left alone.\n */\nconst ADVICE_BY_EVENT_NAME = new Map<string, string>([\n  ['DragEvent', 'there is no trusted equivalent, because `sendInputEvent` cannot express a drag, so keep the dispatch and disable this rule with the reason'],\n  ['KeyboardEvent', 'use `pressKey`, focusing the target first, since a trusted key press goes to whatever holds DOM focus'],\n  ['MouseEvent', 'use `clickElement`, or `clickMouse` when the point to click is not an element centre'],\n  ['PointerEvent', 'use `clickElement`, or `clickMouse` when the point to click is not an element centre'],\n  ['TouchEvent', 'there is no trusted equivalent, so keep the dispatch and disable this rule with the reason'],\n  ['WheelEvent', 'there is no trusted equivalent, so keep the dispatch and disable this rule with the reason']\n]);\n\n/**\n * ESLint rule disallowing untrusted input events in integration tests, where they can silently exercise nothing.\n */\nexport const noUntrustedInputEvents: Rule.RuleModule = {\n  create(context) {\n    return {\n      'CallExpression'(node: Rule.Node): void {\n        const callNode = toTSESTreeNode(node) as TSESTree.CallExpression;\n\n        if (!isDispatchEventCall(callNode)) {\n          return;\n        }\n\n        const argument = callNode.arguments[0];\n        if (!argument) {\n          return;\n        }\n\n        const eventName = resolveEventName(argument, node, context);\n        if (eventName === null) {\n          return;\n        }\n\n        const advice = ADVICE_BY_EVENT_NAME.get(eventName);\n        if (advice === undefined) {\n          return;\n        }\n\n        context.report({\n          data: {\n            advice,\n            eventName\n          },\n          messageId: MESSAGE_ID,\n          node\n        });\n      }\n    };\n  },\n  meta: {\n    docs: {\n      description: 'Disallow driving integration tests with dispatched (untrusted) input events'\n    },\n    messages: {\n      [MESSAGE_ID]: 'A dispatched {{ eventName }} is untrusted (`isTrusted === false`) and Obsidian may ignore it, so this can exercise nothing while still passing: {{ advice }}.'\n    },\n    schema: [],\n    type: 'problem'\n  }\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 call expression is a `.dispatchEvent(...)` call.\n *\n * @param node - The call expression node.\n * @returns `true` if the call is `<something>.dispatchEvent(...)`.\n */\nfunction isDispatchEventCall(node: TSESTree.CallExpression): boolean {\n  const callee = node.callee;\n\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return callee.type === 'MemberExpression' && callee.property.type === 'Identifier' && callee.property.name === 'dispatchEvent';\n}\n\n/**\n * Reads the identifier a `new ...()` expression constructs.\n *\n * @param node - The `NewExpression` node.\n * @returns The constructor's name, or `null` when the callee is not a bare identifier.\n */\nfunction readConstructorName(node: TSESTree.NewExpression): null | string {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return node.callee.type === 'Identifier' ? node.callee.name : null;\n}\n\n/**\n * Reads the constructor name of the event being dispatched.\n *\n * Handles the argument written inline (`dispatchEvent(new MouseEvent(...))`) and the\n * argument held in a variable (`const e = new DragEvent(...); el.dispatchEvent(e)`),\n * which is how a sequence sharing one `DataTransfer` is usually written.\n *\n * @param argument - The first argument of the `dispatchEvent` call.\n * @param node - The call node, used to resolve the enclosing scope.\n * @param context - The rule context.\n * @returns The constructor name, or `null` when it cannot be determined.\n */\nfunction resolveEventName(argument: TSESTree.Node, node: Rule.Node, context: Rule.RuleContext): null | string {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  if (argument.type === 'NewExpression') {\n    return readConstructorName(argument);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  if (argument.type !== 'Identifier') {\n    return null;\n  }\n\n  const variable = findVariable(context.sourceCode.getScope(node), argument.name);\n  if (!variable) {\n    return null;\n  }\n\n  for (const definition of variable.defs) {\n    const definitionNode = toTSESTreeNode(definition.node);\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n    if (definitionNode.type !== 'VariableDeclarator' || !definitionNode.init) {\n      continue;\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n    if (definitionNode.init.type === 'NewExpression') {\n      return readConstructorName(definitionNode.init);\n    }\n  }\n\n  return null;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,SAAS,sBAAsB;AAKxB,MAAM,aAAa;AAM1B,MAAM,uBAAuB,oBAAI,IAAoB;AAAA,EACnD,CAAC,aAAa,4IAA4I;AAAA,EAC1J,CAAC,iBAAiB,uGAAuG;AAAA,EACzH,CAAC,cAAc,sFAAsF;AAAA,EACrG,CAAC,gBAAgB,sFAAsF;AAAA,EACvG,CAAC,cAAc,4FAA4F;AAAA,EAC3G,CAAC,cAAc,4FAA4F;AAC7G,CAAC;AAKM,MAAM,yBAA0C;AAAA,EACrD,OAAO,SAAS;AACd,WAAO;AAAA,MACL,iBAAiB,MAAuB;AACtC,cAAM,WAAW,eAAe,IAAI;AAEpC,YAAI,CAAC,oBAAoB,QAAQ,GAAG;AAClC;AAAA,QACF;AAEA,cAAM,WAAW,SAAS,UAAU,CAAC;AACrC,YAAI,CAAC,UAAU;AACb;AAAA,QACF;AAEA,cAAM,YAAY,iBAAiB,UAAU,MAAM,OAAO;AAC1D,YAAI,cAAc,MAAM;AACtB;AAAA,QACF;AAEA,cAAM,SAAS,qBAAqB,IAAI,SAAS;AACjD,YAAI,WAAW,QAAW;AACxB;AAAA,QACF;AAEA,gBAAQ,OAAO;AAAA,UACb,MAAM;AAAA,YACJ;AAAA,YACA;AAAA,UACF;AAAA,UACA,WAAW;AAAA,UACX;AAAA,QACF,CAAC;AAAA,MACH;AAAA,IACF;AAAA,EACF;AAAA,EACA,MAAM;AAAA,IACJ,MAAM;AAAA,MACJ,aAAa;AAAA,IACf;AAAA,IACA,UAAU;AAAA,MACR,CAAC,UAAU,GAAG;AAAA,IAChB;AAAA,IACA,QAAQ,CAAC;AAAA,IACT,MAAM;AAAA,EACR;AACF;AASA,SAAS,aAAa,OAAoB,MAAqC;AAC7E,MAAI,eAAmC;AAEvC,SAAO,cAAc;AACnB,UAAM,WAAW,aAAa,UAAU,KAAK,CAAC,cAAc,UAAU,SAAS,IAAI;AACnF,QAAI,UAAU;AACZ,aAAO;AAAA,IACT;AACA,mBAAe,aAAa;AAAA,EAC9B;AAEA,SAAO;AACT;AAQA,SAAS,oBAAoB,MAAwC;AACnE,QAAM,SAAS,KAAK;AAGpB,SAAO,OAAO,SAAS,sBAAsB,OAAO,SAAS,SAAS,gBAAgB,OAAO,SAAS,SAAS;AACjH;AAQA,SAAS,oBAAoB,MAA6C;AAExE,SAAO,KAAK,OAAO,SAAS,eAAe,KAAK,OAAO,OAAO;AAChE;AAcA,SAAS,iBAAiB,UAAyB,MAAiB,SAA0C;AAE5G,MAAI,SAAS,SAAS,iBAAiB;AACrC,WAAO,oBAAoB,QAAQ;AAAA,EACrC;AAGA,MAAI,SAAS,SAAS,cAAc;AAClC,WAAO;AAAA,EACT;AAEA,QAAM,WAAW,aAAa,QAAQ,WAAW,SAAS,IAAI,GAAG,SAAS,IAAI;AAC9E,MAAI,CAAC,UAAU;AACb,WAAO;AAAA,EACT;AAEA,aAAW,cAAc,SAAS,MAAM;AACtC,UAAM,iBAAiB,eAAe,WAAW,IAAI;AAErD,QAAI,eAAe,SAAS,wBAAwB,CAAC,eAAe,MAAM;AACxE;AAAA,IACF;AAGA,QAAI,eAAe,KAAK,SAAS,iBAAiB;AAChD,aAAO,oBAAoB,eAAe,IAAI;AAAA,IAChD;AAAA,EACF;AAEA,SAAO;AACT;",
  "names": []
}


package/dist/lib/esm/linters/eslint-rules/obsidian-dev-utils-plugin.d.mts

@@ -0,0 +1,13 @@
+/// <reference path="../../index.d.mts" />
+/**
+ * @file
+ *
+ * ESLint plugin for Obsidian development utilities.
+ */
+import type { ESLint } from 'eslint';
+/**
+ * ESLint plugin bundling every `obsidian-dev-utils` custom rule, registered under the `obsidian-dev-utils` namespace:
+ * the generic rules of `@mnaoumov/typescript-dev-toolkit` and the Obsidian ones. It is ONE plugin carrying both,
+ * because ESLint refuses two different plugins under one namespace.
+ */
+export declare const obsidianDevUtilsPlugin: ESLint.Plugin;

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

@@ -0,0 +1,73 @@
+/*
+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 { genericInHouseEslintRules } from "@mnaoumov/typescript-dev-toolkit/linters/eslint-rules/in-house-plugin";
+import { manifestDescription } from "./manifest-description.mjs";
+import { manifestId } from "./manifest-id.mjs";
+import { manifestName } from "./manifest-name.mjs";
+import { manifestSchema } from "./manifest-schema.mjs";
+import { noLocalObsidianInternals } from "./no-local-obsidian-internals.mjs";
+import { noOverCapWaitInEvalInObsidian } from "./no-over-cap-wait-in-eval-in-obsidian.mjs";
+import { noUntrustedInputEvents } from "./no-untrusted-input-events.mjs";
+import { pluginNameAsCodeInUi } from "./plugin-name-as-code-in-ui.mjs";
+import { pluginNameAsCode } from "./plugin-name-as-code.mjs";
+import { requireComponentSuffix } from "./require-component-suffix.mjs";
+import { requirePluginApiContractSchemas } from "./require-plugin-api-contract-schemas.mjs";
+const obsidianDevUtilsPlugin = {
+  rules: {
+    ...genericInHouseEslintRules,
+    "manifest-description": manifestDescription,
+    "manifest-id": manifestId,
+    "manifest-name": manifestName,
+    "manifest-schema": manifestSchema,
+    "no-local-obsidian-internals": noLocalObsidianInternals,
+    "no-over-cap-wait-in-eval-in-obsidian": noOverCapWaitInEvalInObsidian,
+    "no-untrusted-input-events": noUntrustedInputEvents,
+    "plugin-name-as-code": pluginNameAsCode,
+    "plugin-name-as-code-in-ui": pluginNameAsCodeInUi,
+    "require-component-suffix": requireComponentSuffix,
+    "require-plugin-api-contract-schemas": requirePluginApiContractSchemas
+  }
+};
+export {
+  obsidianDevUtilsPlugin
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL2xpbnRlcnMvZXNsaW50LXJ1bGVzL29ic2lkaWFuLWRldi11dGlscy1wbHVnaW4udHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBFU0xpbnQgcGx1Z2luIGZvciBPYnNpZGlhbiBkZXZlbG9wbWVudCB1dGlsaXRpZXMuXG4gKi9cbmltcG9ydCB0eXBlIHsgRVNMaW50IH0gZnJvbSAnZXNsaW50JztcblxuaW1wb3J0IHsgZ2VuZXJpY0luSG91c2VFc2xpbnRSdWxlcyB9IGZyb20gJ0BtbmFvdW1vdi90eXBlc2NyaXB0LWRldi10b29sa2l0L2xpbnRlcnMvZXNsaW50LXJ1bGVzL2luLWhvdXNlLXBsdWdpbic7XG5cbmltcG9ydCB7IG1hbmlmZXN0RGVzY3JpcHRpb24gfSBmcm9tICcuL21hbmlmZXN0LWRlc2NyaXB0aW9uLnRzJztcbmltcG9ydCB7IG1hbmlmZXN0SWQgfSBmcm9tICcuL21hbmlmZXN0LWlkLnRzJztcbmltcG9ydCB7IG1hbmlmZXN0TmFtZSB9IGZyb20gJy4vbWFuaWZlc3QtbmFtZS50cyc7XG5pbXBvcnQgeyBtYW5pZmVzdFNjaGVtYSB9IGZyb20gJy4vbWFuaWZlc3Qtc2NoZW1hLnRzJztcbmltcG9ydCB7IG5vTG9jYWxPYnNpZGlhbkludGVybmFscyB9IGZyb20gJy4vbm8tbG9jYWwtb2JzaWRpYW4taW50ZXJuYWxzLnRzJztcbmltcG9ydCB7IG5vT3ZlckNhcFdhaXRJbkV2YWxJbk9ic2lkaWFuIH0gZnJvbSAnLi9uby1vdmVyLWNhcC13YWl0LWluLWV2YWwtaW4tb2JzaWRpYW4udHMnO1xuaW1wb3J0IHsgbm9VbnRydXN0ZWRJbnB1dEV2ZW50cyB9IGZyb20gJy4vbm8tdW50cnVzdGVkLWlucHV0LWV2ZW50cy50cyc7XG5pbXBvcnQgeyBwbHVnaW5OYW1lQXNDb2RlSW5VaSB9IGZyb20gJy4vcGx1Z2luLW5hbWUtYXMtY29kZS1pbi11aS50cyc7XG5pbXBvcnQgeyBwbHVnaW5OYW1lQXNDb2RlIH0gZnJvbSAnLi9wbHVnaW4tbmFtZS1hcy1jb2RlLnRzJztcbmltcG9ydCB7IHJlcXVpcmVDb21wb25lbnRTdWZmaXggfSBmcm9tICcuL3JlcXVpcmUtY29tcG9uZW50LXN1ZmZpeC50cyc7XG5pbXBvcnQgeyByZXF1aXJlUGx1Z2luQXBpQ29udHJhY3RTY2hlbWFzIH0gZnJvbSAnLi9yZXF1aXJlLXBsdWdpbi1hcGktY29udHJhY3Qtc2NoZW1hcy50cyc7XG5cbi8qKlxuICogRVNMaW50IHBsdWdpbiBidW5kbGluZyBldmVyeSBgb2JzaWRpYW4tZGV2LXV0aWxzYCBjdXN0b20gcnVsZSwgcmVnaXN0ZXJlZCB1bmRlciB0aGUgYG9ic2lkaWFuLWRldi11dGlsc2AgbmFtZXNwYWNlOlxuICogdGhlIGdlbmVyaWMgcnVsZXMgb2YgYEBtbmFvdW1vdi90eXBlc2NyaXB0LWRldi10b29sa2l0YCBhbmQgdGhlIE9ic2lkaWFuIG9uZXMuIEl0IGlzIE9ORSBwbHVnaW4gY2FycnlpbmcgYm90aCxcbiAqIGJlY2F1c2UgRVNMaW50IHJlZnVzZXMgdHdvIGRpZmZlcmVudCBwbHVnaW5zIHVuZGVyIG9uZSBuYW1lc3BhY2UuXG4gKi9cbmV4cG9ydCBjb25zdCBvYnNpZGlhbkRldlV0aWxzUGx1Z2luOiBFU0xpbnQuUGx1Z2luID0ge1xuICBydWxlczoge1xuICAgIC4uLmdlbmVyaWNJbkhvdXNlRXNsaW50UnVsZXMsXG4gICAgJ21hbmlmZXN0LWRlc2NyaXB0aW9uJzogbWFuaWZlc3REZXNjcmlwdGlvbixcbiAgICAnbWFuaWZlc3QtaWQnOiBtYW5pZmVzdElkLFxuICAgICdtYW5pZmVzdC1uYW1lJzogbWFuaWZlc3ROYW1lLFxuICAgICdtYW5pZmVzdC1zY2hlbWEnOiBtYW5pZmVzdFNjaGVtYSxcbiAgICAnbm8tbG9jYWwtb2JzaWRpYW4taW50ZXJuYWxzJzogbm9Mb2NhbE9ic2lkaWFuSW50ZXJuYWxzLFxuICAgICduby1vdmVyLWNhcC13YWl0LWluLWV2YWwtaW4tb2JzaWRpYW4nOiBub092ZXJDYXBXYWl0SW5FdmFsSW5PYnNpZGlhbixcbiAgICAnbm8tdW50cnVzdGVkLWlucHV0LWV2ZW50cyc6IG5vVW50cnVzdGVkSW5wdXRFdmVudHMsXG4gICAgJ3BsdWdpbi1uYW1lLWFzLWNvZGUnOiBwbHVnaW5OYW1lQXNDb2RlLFxuICAgICdwbHVnaW4tbmFtZS1hcy1jb2RlLWluLXVpJzogcGx1Z2luTmFtZUFzQ29kZUluVWksXG4gICAgJ3JlcXVpcmUtY29tcG9uZW50LXN1ZmZpeCc6IHJlcXVpcmVDb21wb25lbnRTdWZmaXgsXG4gICAgJ3JlcXVpcmUtcGx1Z2luLWFwaS1jb250cmFjdC1zY2hlbWFzJzogcmVxdWlyZVBsdWdpbkFwaUNvbnRyYWN0U2NoZW1hc1xuICB9XG59O1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFPQSxTQUFTLGlDQUFpQztBQUUxQyxTQUFTLDJCQUEyQjtBQUNwQyxTQUFTLGtCQUFrQjtBQUMzQixTQUFTLG9CQUFvQjtBQUM3QixTQUFTLHNCQUFzQjtBQUMvQixTQUFTLGdDQUFnQztBQUN6QyxTQUFTLHFDQUFxQztBQUM5QyxTQUFTLDhCQUE4QjtBQUN2QyxTQUFTLDRCQUE0QjtBQUNyQyxTQUFTLHdCQUF3QjtBQUNqQyxTQUFTLDhCQUE4QjtBQUN2QyxTQUFTLHVDQUF1QztBQU96QyxNQUFNLHlCQUF3QztBQUFBLEVBQ25ELE9BQU87QUFBQSxJQUNMLEdBQUc7QUFBQSxJQUNILHdCQUF3QjtBQUFBLElBQ3hCLGVBQWU7QUFBQSxJQUNmLGlCQUFpQjtBQUFBLElBQ2pCLG1CQUFtQjtBQUFBLElBQ25CLCtCQUErQjtBQUFBLElBQy9CLHdDQUF3QztBQUFBLElBQ3hDLDZCQUE2QjtBQUFBLElBQzdCLHVCQUF1QjtBQUFBLElBQ3ZCLDZCQUE2QjtBQUFBLElBQzdCLDRCQUE0QjtBQUFBLElBQzVCLHVDQUF1QztBQUFBLEVBQ3pDO0FBQ0Y7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/lib/esm/linters/eslint-rules/plugin-name-as-code-in-ui.d.mts

@@ -0,0 +1,30 @@
+/// <reference path="../../index.d.mts" />
+/**
+ * @file
+ *
+ * ESLint rule: plugin-name-as-code-in-ui
+ *
+ * Reports an Obsidian plugin's display name inside a string that is shown in UI as plain text. In UI the name is
+ * built as a `<code>` element instead: `appendCodeBlock()` into a `DocumentFragment`, or `createFragmentWithCodeBlocks()`
+ * with `asCodeBlock()`, from `@mnaoumov/obsidian-lib`'s `html-element.ts`, and the fragment is what is passed on.
+ *
+ * Detection is best effort, by call shape, without type information. A string literal or template literal (or a
+ * `+` concatenation or `? :` branch made of them) is read when it is:
+ *
+ * - the first argument of `new Notice(...)`;
+ * - the first argument of `setName`, `setDesc`, `setText`, `appendText` or `setTitle` called on anything;
+ * - the `text` property of an options object passed to `createEl`, `createDiv` or `createSpan`.
+ *
+ * There is no autofix: splitting a string around the name and building a fragment is a rewrite of the call, and
+ * often of a translation key, which needs judgement. A command name, a ribbon tooltip and a window title cannot hold
+ * markup, so the calls that set them (`addCommand`, `addRibbonIcon`, `document.title`) are not read at all.
+ */
+import type { Rule } from 'eslint';
+/**
+ * Message ID reported for a plugin name inside a UI string.
+ */
+export declare const MESSAGE_ID = "pluginNameAsCodeInUi";
+/**
+ * ESLint rule requiring a plugin name shown in UI to be built as a `<code>` element.
+ */
+export declare const pluginNameAsCodeInUi: Rule.RuleModule;

package/dist/lib/esm/linters/eslint-rules/plugin-name-as-code-in-ui.mjs

@@ -0,0 +1,157 @@
+/*
+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 {
+  findPluginNameMatches,
+  getPluginNames
+} from "../plugin-names.mjs";
+import { PLUGIN_NAME_RULE_SCHEMA } from "./plugin-name-as-code.mjs";
+const MESSAGE_ID = "pluginNameAsCodeInUi";
+const UI_TEXT_METHOD_NAMES = /* @__PURE__ */ new Set(["appendText", "setDesc", "setName", "setText", "setTitle"]);
+const ELEMENT_FACTORY_NAMES = /* @__PURE__ */ new Set(["createDiv", "createEl", "createSpan"]);
+const pluginNameAsCodeInUi = {
+  create(context) {
+    const options = context.options[0];
+    const pluginNames = getPluginNames({ additionalPluginNames: options?.additionalPluginNames, cwd: context.cwd });
+    return {
+      CallExpression(node) {
+        const calleeName = getCalleeName(node);
+        if (calleeName === null) {
+          return;
+        }
+        if (UI_TEXT_METHOD_NAMES.has(calleeName) && node.callee.type === "MemberExpression") {
+          inspectArgument(node.arguments[0]);
+          return;
+        }
+        if (!ELEMENT_FACTORY_NAMES.has(calleeName)) {
+          return;
+        }
+        for (const argument of node.arguments) {
+          if (argument.type !== "ObjectExpression") {
+            continue;
+          }
+          for (const property of argument.properties) {
+            if (property.type === "Property" && !property.computed && getKeyName(property.key) === "text") {
+              inspectExpression(property.value);
+            }
+          }
+        }
+      },
+      NewExpression(node) {
+        if (node.callee.type === "Identifier" && node.callee.name === "Notice") {
+          inspectArgument(node.arguments[0]);
+        }
+      }
+    };
+    function inspectArgument(argument) {
+      if (argument && argument.type !== "SpreadElement") {
+        inspectExpression(argument);
+      }
+    }
+    function inspectExpression(node) {
+      switch (node.type) {
+        case "BinaryExpression": {
+          if (node.operator === "+") {
+            inspectExpression(node.left);
+            inspectExpression(node.right);
+          }
+          break;
+        }
+        case "ConditionalExpression": {
+          inspectExpression(node.consequent);
+          inspectExpression(node.alternate);
+          break;
+        }
+        case "Literal": {
+          if (typeof node.value === "string") {
+            reportText(node, node.value);
+          }
+          break;
+        }
+        case "TemplateLiteral": {
+          for (const templateElement of node.quasis) {
+            reportText(templateElement, templateElement.value.raw);
+          }
+          break;
+        }
+        default: {
+          break;
+        }
+      }
+    }
+    function reportText(node, text) {
+      for (const match of findPluginNameMatches(text, pluginNames)) {
+        context.report({
+          data: { name: match.name },
+          messageId: MESSAGE_ID,
+          node
+        });
+      }
+    }
+  },
+  meta: {
+    docs: {
+      description: "Require a plugin name shown in UI to be built as a `<code>` element"
+    },
+    messages: {
+      [MESSAGE_ID]: "The plugin name `{{ name }}` is shown in UI as plain text. Build it as a `<code>` element instead: `appendCodeBlock()` into a `DocumentFragment`, or `createFragmentWithCodeBlocks()` with `asCodeBlock()`, from `@mnaoumov/obsidian-lib`'s `html-element.ts`."
+    },
+    schema: PLUGIN_NAME_RULE_SCHEMA,
+    type: "suggestion"
+  }
+};
+function getCalleeName(node) {
+  if (node.callee.type === "Identifier") {
+    return node.callee.name;
+  }
+  return node.callee.type === "MemberExpression" && !node.callee.computed && node.callee.property.type === "Identifier" ? node.callee.property.name : null;
+}
+function getKeyName(key) {
+  if (key.type === "Identifier") {
+    return key.name;
+  }
+  return key.type === "Literal" && typeof key.value === "string" ? key.value : null;
+}
+export {
+  MESSAGE_ID,
+  pluginNameAsCodeInUi
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/linters/eslint-rules/plugin-name-as-code-in-ui.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * ESLint rule: plugin-name-as-code-in-ui\n *\n * Reports an Obsidian plugin's display name inside a string that is shown in UI as plain text. In UI the name is\n * built as a `<code>` element instead: `appendCodeBlock()` into a `DocumentFragment`, or `createFragmentWithCodeBlocks()`\n * with `asCodeBlock()`, from `@mnaoumov/obsidian-lib`'s `html-element.ts`, and the fragment is what is passed on.\n *\n * Detection is best effort, by call shape, without type information. A string literal or template literal (or a\n * `+` concatenation or `? :` branch made of them) is read when it is:\n *\n * - the first argument of `new Notice(...)`;\n * - the first argument of `setName`, `setDesc`, `setText`, `appendText` or `setTitle` called on anything;\n * - the `text` property of an options object passed to `createEl`, `createDiv` or `createSpan`.\n *\n * There is no autofix: splitting a string around the name and building a fragment is a rewrite of the call, and\n * often of a translation key, which needs judgement. A command name, a ribbon tooltip and a window title cannot hold\n * markup, so the calls that set them (`addCommand`, `addRibbonIcon`, `document.title`) are not read at all.\n */\n\nimport type { Rule } from 'eslint';\nimport type {\n  CallExpression,\n  Expression,\n  NewExpression,\n  Node,\n  SpreadElement\n} from 'estree';\n\nimport type { PluginNameRuleOptions } from '../plugin-names.ts';\n\nimport {\n  findPluginNameMatches,\n  getPluginNames\n} from '../plugin-names.ts';\nimport { PLUGIN_NAME_RULE_SCHEMA } from './plugin-name-as-code.ts';\n\n/**\n * Message ID reported for a plugin name inside a UI string.\n */\nexport const MESSAGE_ID = 'pluginNameAsCodeInUi';\n\n/**\n * The methods whose first argument is shown in UI and may be a `DocumentFragment`.\n */\nconst UI_TEXT_METHOD_NAMES = new Set(['appendText', 'setDesc', 'setName', 'setText', 'setTitle']);\n\n/**\n * The element factories whose options object carries UI text in `text`.\n */\nconst ELEMENT_FACTORY_NAMES = new Set(['createDiv', 'createEl', 'createSpan']);\n\n/**\n * ESLint rule requiring a plugin name shown in UI to be built as a `<code>` element.\n */\nexport const pluginNameAsCodeInUi: Rule.RuleModule = {\n  create(context) {\n    const options = context.options[0] as PluginNameRuleOptions | undefined;\n    const pluginNames = getPluginNames({ additionalPluginNames: options?.additionalPluginNames, cwd: context.cwd });\n\n    return {\n      CallExpression(node: CallExpression): void {\n        const calleeName = getCalleeName(node);\n        if (calleeName === null) {\n          return;\n        }\n\n        if (UI_TEXT_METHOD_NAMES.has(calleeName) && node.callee.type === 'MemberExpression') {\n          inspectArgument(node.arguments[0]);\n          return;\n        }\n\n        if (!ELEMENT_FACTORY_NAMES.has(calleeName)) {\n          return;\n        }\n\n        for (const argument of node.arguments) {\n          if (argument.type !== 'ObjectExpression') {\n            continue;\n          }\n          for (const property of argument.properties) {\n            if (property.type === 'Property' && !property.computed && getKeyName(property.key) === 'text') {\n              inspectExpression(property.value);\n            }\n          }\n        }\n      },\n      NewExpression(node: NewExpression): void {\n        if (node.callee.type === 'Identifier' && node.callee.name === 'Notice') {\n          inspectArgument(node.arguments[0]);\n        }\n      }\n    };\n\n    function inspectArgument(argument: Expression | SpreadElement | undefined): void {\n      if (argument && argument.type !== 'SpreadElement') {\n        inspectExpression(argument);\n      }\n    }\n\n    function inspectExpression(node: Node): void {\n      switch (node.type) {\n        case 'BinaryExpression': {\n          if (node.operator === '+') {\n            inspectExpression(node.left);\n            inspectExpression(node.right);\n          }\n          break;\n        }\n        case 'ConditionalExpression': {\n          inspectExpression(node.consequent);\n          inspectExpression(node.alternate);\n          break;\n        }\n        case 'Literal': {\n          if (typeof node.value === 'string') {\n            reportText(node, node.value);\n          }\n          break;\n        }\n        case 'TemplateLiteral': {\n          for (const templateElement of node.quasis) {\n            reportText(templateElement, templateElement.value.raw);\n          }\n          break;\n        }\n        default: {\n          break;\n        }\n      }\n    }\n\n    function reportText(node: Node, text: string): void {\n      for (const match of findPluginNameMatches(text, pluginNames)) {\n        context.report({\n          data: { name: match.name },\n          messageId: MESSAGE_ID,\n          node\n        });\n      }\n    }\n  },\n  meta: {\n    docs: {\n      description: 'Require a plugin name shown in UI to be built as a `<code>` element'\n    },\n    messages: {\n      [MESSAGE_ID]: 'The plugin name `{{ name }}` is shown in UI as plain text. Build it as a `<code>` element instead: `appendCodeBlock()` into a `DocumentFragment`, or `createFragmentWithCodeBlocks()` with `asCodeBlock()`, from `@mnaoumov/obsidian-lib`\\'s `html-element.ts`.'\n    },\n    schema: PLUGIN_NAME_RULE_SCHEMA,\n    type: 'suggestion'\n  }\n};\n\n/**\n * Reads the name a call is made by: the function's name, or the method's for a member call.\n *\n * @param node - The call.\n * @returns The name, or `null` for a computed or otherwise unnamed callee.\n */\nfunction getCalleeName(node: CallExpression): null | string {\n  if (node.callee.type === 'Identifier') {\n    return node.callee.name;\n  }\n\n  return node.callee.type === 'MemberExpression' && !node.callee.computed && node.callee.property.type === 'Identifier'\n    ? node.callee.property.name\n    : null;\n}\n\n/**\n * Reads the name of an object property key written as an identifier or a string literal.\n *\n * @param key - The key.\n * @returns The name, or `null` for any other key.\n */\nfunction getKeyName(key: Node): null | string {\n  if (key.type === 'Identifier') {\n    return key.name;\n  }\n\n  return key.type === 'Literal' && typeof key.value === 'string' ? key.value : null;\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/linters/eslint-rules/plugin-name-as-code.d.mts

@@ -0,0 +1,29 @@
+/// <reference path="../../index.d.mts" />
+/**
+ * @file
+ *
+ * ESLint rule: plugin-name-as-code
+ *
+ * Reports an Obsidian plugin's display name written as plain text in a code comment, and autofixes it by wrapping
+ * the name in backticks. TSDoc renders a name in backticks as code, so a doc comment reads the same as the README.
+ *
+ * Every comment is read: `//`, `/* *\/` and JSDoc / TSDoc. A name already inside a code span, an inline `@link` tag
+ * (whose target is an identifier) or a URL is left alone. The names come from `plugin-names.ts`: the shared list,
+ * the project's own `manifest.json` `name`, and the rule's `additionalPluginNames` option.
+ *
+ * Not attempted: a multi-word name broken across two comment lines, which a reader cannot tell from two unrelated
+ * words without understanding the prose.
+ */
+import type { Rule } from 'eslint';
+/**
+ * Message ID reported for a plugin name written as plain text in a comment.
+ */
+export declare const MESSAGE_ID = "pluginNameAsCode";
+/**
+ * The JSON schema of the options the plugin-name rules take.
+ */
+export declare const PLUGIN_NAME_RULE_SCHEMA: Rule.RuleMetaData['schema'];
+/**
+ * ESLint rule requiring a plugin name in a comment to be marked as code.
+ */
+export declare const pluginNameAsCode: Rule.RuleModule;

package/dist/lib/esm/linters/eslint-rules/plugin-name-as-code.mjs

@@ -0,0 +1,108 @@
+/*
+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 {
+  findPluginNameMatches,
+  getPluginNames
+} from "../plugin-names.mjs";
+const MESSAGE_ID = "pluginNameAsCode";
+const EXCLUDED_COMMENT_PATTERNS = [
+  /(?<ticks>`+)[\s\S]*?\k<ticks>/g,
+  /\{@link\w*[^}]*\}/g,
+  /\b[a-z][\w+.-]*:\/\/\S+/gi
+];
+const COMMENT_OPENING_LENGTH = 2;
+const PLUGIN_NAME_RULE_SCHEMA = [
+  {
+    additionalProperties: false,
+    properties: {
+      additionalPluginNames: {
+        items: { type: "string" },
+        type: "array"
+      }
+    },
+    type: "object"
+  }
+];
+const pluginNameAsCode = {
+  create(context) {
+    const options = context.options[0];
+    const pluginNames = getPluginNames({ additionalPluginNames: options?.additionalPluginNames, cwd: context.cwd });
+    const sourceCode = context.sourceCode;
+    return {
+      Program() {
+        for (const comment of sourceCode.getAllComments()) {
+          const [valueStart] = sourceCode.getRange(comment);
+          for (const match of findPluginNameMatches(comment.value, pluginNames, EXCLUDED_COMMENT_PATTERNS)) {
+            const start = valueStart + COMMENT_OPENING_LENGTH + match.index;
+            const end = start + match.name.length;
+            context.report({
+              data: { name: match.name },
+              fix: (fixer) => fixer.replaceTextRange([start, end], `\`${match.name}\``),
+              loc: {
+                end: sourceCode.getLocFromIndex(end),
+                start: sourceCode.getLocFromIndex(start)
+              },
+              messageId: MESSAGE_ID
+            });
+          }
+        }
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Require a plugin name in a comment to be marked as code with backticks"
+    },
+    fixable: "code",
+    messages: {
+      [MESSAGE_ID]: "Mark the plugin name `{{ name }}` as code: wrap it in backticks."
+    },
+    schema: PLUGIN_NAME_RULE_SCHEMA,
+    type: "suggestion"
+  }
+};
+export {
+  MESSAGE_ID,
+  PLUGIN_NAME_RULE_SCHEMA,
+  pluginNameAsCode
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/linters/eslint-rules/require-component-suffix.d.mts

@@ -0,0 +1,18 @@
+/// <reference path="../../index.d.mts" />
+import type { Rule } from 'eslint';
+/**
+Message ID reported when a class extends `Component` but its name does not end with `Component`.
+ */
+export declare const MESSAGE_ID_MISSING_SUFFIX = "requireComponentSuffix";
+/**
+Message ID reported when an abstract class extends `Component` but its name does not end with `ComponentBase`.
+ */
+export declare const MESSAGE_ID_ABSTRACT_NEEDS_BASE = "abstractNeedsComponentBase";
+/**
+Message ID reported when a class name ends with `ComponentBase` but the class is not abstract.
+ */
+export declare const MESSAGE_ID_BASE_NOT_ABSTRACT = "componentBaseNotAbstract";
+/**
+ * ESLint rule requiring classes that extend `Component` to be named with a `Component` suffix, and abstract ones with a `ComponentBase` suffix.
+ */
+export declare const requireComponentSuffix: Rule.RuleModule;