@mnaoumov/obsidian-dev-toolkit 0.0.0 → 1.1.0

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

@@ -0,0 +1,167 @@
+/*
+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_MISSING_SUFFIX = "requireComponentSuffix";
+const MESSAGE_ID_ABSTRACT_NEEDS_BASE = "abstractNeedsComponentBase";
+const MESSAGE_ID_BASE_NOT_ABSTRACT = "componentBaseNotAbstract";
+const EXCLUDED_ANCESTORS = /* @__PURE__ */ new Set(["HoverPopover", "MarkdownRenderChild", "Menu", "Plugin", "QueryController", "View"]);
+const REQUIRED_ANCESTOR = "Component";
+const requireComponentSuffix = {
+  create(context) {
+    const services = context.sourceCode.parserServices;
+    const checker = services.program.getTypeChecker();
+    return {
+      "ClassDeclaration[id]"(node) {
+        reportClass({
+          checker,
+          context,
+          node,
+          services
+        });
+      },
+      "ClassExpression[id]"(node) {
+        reportClass({
+          checker,
+          context,
+          node,
+          services
+        });
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Require classes extending `Component` to have names ending with `Component`"
+    },
+    messages: {
+      [MESSAGE_ID_ABSTRACT_NEEDS_BASE]: "Abstract class `{{ className }}` extends `Component` but its name does not end with `ComponentBase`.",
+      [MESSAGE_ID_BASE_NOT_ABSTRACT]: "Class `{{ className }}` ends with `ComponentBase` but is not abstract. Only abstract classes may use the `ComponentBase` suffix.",
+      [MESSAGE_ID_MISSING_SUFFIX]: "Class `{{ className }}` extends `Component` but its name does not end with `Component`."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+function collectAncestorNames(type) {
+  const names = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  walkAncestors({
+    collectedNames: names,
+    currentType: type,
+    visitedTypes: visited
+  });
+  return names;
+  function walkAncestors(params) {
+    const { collectedNames, currentType, visitedTypes } = params;
+    if (visitedTypes.has(currentType)) {
+      return;
+    }
+    visitedTypes.add(currentType);
+    const baseTypes = currentType.getBaseTypes?.();
+    if (!baseTypes) {
+      return;
+    }
+    for (const baseType of baseTypes) {
+      const $symbol = baseType.getSymbol();
+      if ($symbol) {
+        collectedNames.add($symbol.getName());
+      }
+      walkAncestors({
+        collectedNames,
+        currentType: baseType,
+        visitedTypes
+      });
+    }
+  }
+}
+function reportClass(params) {
+  const { checker, context, node, services } = params;
+  const classNode = toTSESTreeNode(node);
+  const classId = classNode.id;
+  if (!classId) {
+    return;
+  }
+  const className = classId.name;
+  const { abstract: isAbstract } = classNode;
+  const hasComponentBaseSuffix = className.endsWith("ComponentBase");
+  const hasComponentSuffix = !hasComponentBaseSuffix && className.endsWith("Component");
+  if (hasComponentSuffix && !isAbstract || hasComponentBaseSuffix && isAbstract) {
+    return;
+  }
+  const tsNode = services.esTreeNodeToTSNodeMap.get(classNode);
+  const classType = checker.getTypeAtLocation(tsNode);
+  const ancestors = collectAncestorNames(classType);
+  if (!ancestors.has(REQUIRED_ANCESTOR)) {
+    return;
+  }
+  for (const excluded of EXCLUDED_ANCESTORS) {
+    if (ancestors.has(excluded)) {
+      return;
+    }
+  }
+  if (hasComponentBaseSuffix && !isAbstract) {
+    context.report({
+      data: { className },
+      messageId: MESSAGE_ID_BASE_NOT_ABSTRACT,
+      node
+    });
+  } else if (isAbstract) {
+    context.report({
+      data: { className },
+      messageId: MESSAGE_ID_ABSTRACT_NEEDS_BASE,
+      node
+    });
+  } else {
+    context.report({
+      data: { className },
+      messageId: MESSAGE_ID_MISSING_SUFFIX,
+      node
+    });
+  }
+}
+export {
+  MESSAGE_ID_ABSTRACT_NEEDS_BASE,
+  MESSAGE_ID_BASE_NOT_ABSTRACT,
+  MESSAGE_ID_MISSING_SUFFIX,
+  requireComponentSuffix
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/linters/eslint-rules/require-component-suffix.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * ESLint rule: require-component-suffix\n *\n * Reports an error when a class that extends `Component` (from Obsidian,\n * directly or transitively) does not have a name ending with `Component`\n * (or `ComponentBase` for abstract base classes).\n *\n * Classes whose inheritance chain includes any of the Obsidian framework\n * classes that extend `Component` (e.g. `Plugin`, `View`,\n * `MarkdownRenderChild`, `Menu`, `HoverPopover`, `QueryController`)\n * are excluded because they follow Obsidian's own naming conventions.\n *\n * The rule uses the TypeScript type checker to walk the full inheritance\n * chain, so it works regardless of how many intermediate classes sit\n * between the user's class and `Component`.\n */\nimport type {\n  ParserServicesWithTypeInformation,\n  TSESTree\n} from '@typescript-eslint/utils';\nimport type { Rule } from 'eslint';\nimport type { Type } from 'typescript';\n\nimport { toTSESTreeNode } from '@mnaoumov/typescript-dev-toolkit/linters/eslint-rules/ts-estree-node';\n\n/**\nMessage ID reported when a class extends `Component` but its name does not end with `Component`.\n */\nexport const MESSAGE_ID_MISSING_SUFFIX = 'requireComponentSuffix';\n\n/**\nMessage ID reported when an abstract class extends `Component` but its name does not end with `ComponentBase`.\n */\nexport const MESSAGE_ID_ABSTRACT_NEEDS_BASE = 'abstractNeedsComponentBase';\n\n/**\nMessage ID reported when a class name ends with `ComponentBase` but the class is not abstract.\n */\nexport const MESSAGE_ID_BASE_NOT_ABSTRACT = 'componentBaseNotAbstract';\n\n/**\nAncestor class names that opt a subtree out of the suffix requirement.\n */\nconst EXCLUDED_ANCESTORS = new Set(['HoverPopover', 'MarkdownRenderChild', 'Menu', 'Plugin', 'QueryController', 'View']);\n\n/**\nThe ancestor class name that triggers the suffix requirement.\n */\nconst REQUIRED_ANCESTOR = 'Component';\n\ninterface TypeWithBaseTypes {\n  getBaseTypes?: () => Type[] | undefined;\n}\n\n/**\n * ESLint rule requiring classes that extend `Component` to be named with a `Component` suffix, and abstract ones with a `ComponentBase` suffix.\n */\nexport const requireComponentSuffix: Rule.RuleModule = {\n  create(context) {\n    const services = context.sourceCode.parserServices as ParserServicesWithTypeInformation;\n    const checker = services.program.getTypeChecker();\n\n    return {\n      'ClassDeclaration[id]'(node: Rule.Node): void {\n        reportClass({\n          checker,\n          context,\n          node,\n          services\n        });\n      },\n      'ClassExpression[id]'(node: Rule.Node): void {\n        reportClass({\n          checker,\n          context,\n          node,\n          services\n        });\n      }\n    };\n  },\n  meta: {\n    docs: {\n      description: 'Require classes extending `Component` to have names ending with `Component`'\n    },\n    messages: {\n      [MESSAGE_ID_ABSTRACT_NEEDS_BASE]: 'Abstract class `{{ className }}` extends `Component` but its name does not end with `ComponentBase`.',\n      [MESSAGE_ID_BASE_NOT_ABSTRACT]: 'Class `{{ className }}` ends with `ComponentBase` but is not abstract. Only abstract classes may use the `ComponentBase` suffix.',\n      [MESSAGE_ID_MISSING_SUFFIX]: 'Class `{{ className }}` extends `Component` but its name does not end with `Component`.'\n    },\n    schema: [],\n    type: 'problem'\n  }\n};\n\n/**\n * Parameters for {@link reportClass}.\n */\ninterface ReportClassParams {\n  /**\n   * The TypeScript type checker.\n   */\n  readonly checker: ReturnType<ParserServicesWithTypeInformation['program']['getTypeChecker']>;\n\n  /**\n   * The ESLint rule context.\n   */\n  readonly context: Rule.RuleContext;\n\n  /**\n   * The class AST node.\n   */\n  readonly node: Rule.Node;\n\n  /**\n   * The parser services with type information.\n   */\n  readonly services: ParserServicesWithTypeInformation;\n}\n\n/**\n * Parameters for {@link walkAncestors}.\n */\ninterface WalkAncestorsParams {\n  /**\n   * The set to add discovered ancestor names to.\n   */\n  readonly collectedNames: Set<string>;\n\n  /**\n   * The current type to inspect.\n   */\n  readonly currentType: Type;\n\n  /**\n   * Types already visited, to prevent infinite loops.\n   */\n  readonly visitedTypes: Set<Type>;\n}\n\n/**\n * Collects the names of all ancestor types in the inheritance chain.\n *\n * @param type - The TypeScript type to start from.\n * @returns A set of ancestor class names.\n */\nfunction collectAncestorNames(type: Type): Set<string> {\n  const names = new Set<string>();\n  const visited = new Set<Type>();\n\n  walkAncestors({\n    collectedNames: names,\n    currentType: type,\n    visitedTypes: visited\n  });\n\n  return names;\n\n  /**\n   * Recursively walks the base types of a type, collecting their names.\n   *\n   * @param params - The parameters for the walk.\n   */\n  function walkAncestors(params: WalkAncestorsParams): void {\n    const { collectedNames, currentType, visitedTypes } = params;\n    if (visitedTypes.has(currentType)) {\n      return;\n    }\n\n    visitedTypes.add(currentType);\n\n    const baseTypes = (currentType as TypeWithBaseTypes).getBaseTypes?.();\n\n    if (!baseTypes) {\n      return;\n    }\n\n    for (const baseType of baseTypes) {\n      const $symbol = baseType.getSymbol();\n\n      if ($symbol) {\n        collectedNames.add($symbol.getName());\n      }\n\n      walkAncestors({\n        collectedNames,\n        currentType: baseType,\n        visitedTypes\n      });\n    }\n  }\n}\n\n/**\n * Checks a single class declaration or expression.\n *\n * @param params - The parameters for the check.\n */\nfunction reportClass(params: ReportClassParams): void {\n  const { checker, context, node, services } = params;\n  const classNode = toTSESTreeNode(node) as TSESTree.ClassDeclaration | TSESTree.ClassExpression;\n  const classId = classNode.id;\n\n  /* v8 ignore start -- ESLint selector `[id]` guarantees classId is present. */\n  if (!classId) {\n    return;\n  }\n  /* v8 ignore stop */\n\n  const className = classId.name;\n  const { abstract: isAbstract } = classNode;\n  const hasComponentBaseSuffix = className.endsWith('ComponentBase');\n  const hasComponentSuffix = !hasComponentBaseSuffix && className.endsWith('Component');\n\n  // Correct: non-abstract ending with Component, or abstract ending with ComponentBase\n  if ((hasComponentSuffix && !isAbstract) || (hasComponentBaseSuffix && isAbstract)) {\n    return;\n  }\n\n  const tsNode = services.esTreeNodeToTSNodeMap.get(classNode);\n  const classType = checker.getTypeAtLocation(tsNode);\n  const ancestors = collectAncestorNames(classType);\n\n  if (!ancestors.has(REQUIRED_ANCESTOR)) {\n    return;\n  }\n\n  for (const excluded of EXCLUDED_ANCESTORS) {\n    if (ancestors.has(excluded)) {\n      return;\n    }\n  }\n\n  if (hasComponentBaseSuffix && !isAbstract) {\n    context.report({\n      data: { className },\n      messageId: MESSAGE_ID_BASE_NOT_ABSTRACT,\n      node\n    });\n  } else if (isAbstract) {\n    context.report({\n      data: { className },\n      messageId: MESSAGE_ID_ABSTRACT_NEEDS_BASE,\n      node\n    });\n  } else {\n    context.report({\n      data: { className },\n      messageId: MESSAGE_ID_MISSING_SUFFIX,\n      node\n    });\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAS,sBAAsB;AAKxB,MAAM,4BAA4B;AAKlC,MAAM,iCAAiC;AAKvC,MAAM,+BAA+B;AAK5C,MAAM,qBAAqB,oBAAI,IAAI,CAAC,gBAAgB,uBAAuB,QAAQ,UAAU,mBAAmB,MAAM,CAAC;AAKvH,MAAM,oBAAoB;AASnB,MAAM,yBAA0C;AAAA,EACrD,OAAO,SAAS;AACd,UAAM,WAAW,QAAQ,WAAW;AACpC,UAAM,UAAU,SAAS,QAAQ,eAAe;AAEhD,WAAO;AAAA,MACL,uBAAuB,MAAuB;AAC5C,oBAAY;AAAA,UACV;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,QACF,CAAC;AAAA,MACH;AAAA,MACA,sBAAsB,MAAuB;AAC3C,oBAAY;AAAA,UACV;AAAA,UACA;AAAA,UACA;AAAA,UACA;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,8BAA8B,GAAG;AAAA,MAClC,CAAC,4BAA4B,GAAG;AAAA,MAChC,CAAC,yBAAyB,GAAG;AAAA,IAC/B;AAAA,IACA,QAAQ,CAAC;AAAA,IACT,MAAM;AAAA,EACR;AACF;AAqDA,SAAS,qBAAqB,MAAyB;AACrD,QAAM,QAAQ,oBAAI,IAAY;AAC9B,QAAM,UAAU,oBAAI,IAAU;AAE9B,gBAAc;AAAA,IACZ,gBAAgB;AAAA,IAChB,aAAa;AAAA,IACb,cAAc;AAAA,EAChB,CAAC;AAED,SAAO;AAOP,WAAS,cAAc,QAAmC;AACxD,UAAM,EAAE,gBAAgB,aAAa,aAAa,IAAI;AACtD,QAAI,aAAa,IAAI,WAAW,GAAG;AACjC;AAAA,IACF;AAEA,iBAAa,IAAI,WAAW;AAE5B,UAAM,YAAa,YAAkC,eAAe;AAEpE,QAAI,CAAC,WAAW;AACd;AAAA,IACF;AAEA,eAAW,YAAY,WAAW;AAChC,YAAM,UAAU,SAAS,UAAU;AAEnC,UAAI,SAAS;AACX,uBAAe,IAAI,QAAQ,QAAQ,CAAC;AAAA,MACtC;AAEA,oBAAc;AAAA,QACZ;AAAA,QACA,aAAa;AAAA,QACb;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AACF;AAOA,SAAS,YAAY,QAAiC;AACpD,QAAM,EAAE,SAAS,SAAS,MAAM,SAAS,IAAI;AAC7C,QAAM,YAAY,eAAe,IAAI;AACrC,QAAM,UAAU,UAAU;AAG1B,MAAI,CAAC,SAAS;AACZ;AAAA,EACF;AAGA,QAAM,YAAY,QAAQ;AAC1B,QAAM,EAAE,UAAU,WAAW,IAAI;AACjC,QAAM,yBAAyB,UAAU,SAAS,eAAe;AACjE,QAAM,qBAAqB,CAAC,0BAA0B,UAAU,SAAS,WAAW;AAGpF,MAAK,sBAAsB,CAAC,cAAgB,0BAA0B,YAAa;AACjF;AAAA,EACF;AAEA,QAAM,SAAS,SAAS,sBAAsB,IAAI,SAAS;AAC3D,QAAM,YAAY,QAAQ,kBAAkB,MAAM;AAClD,QAAM,YAAY,qBAAqB,SAAS;AAEhD,MAAI,CAAC,UAAU,IAAI,iBAAiB,GAAG;AACrC;AAAA,EACF;AAEA,aAAW,YAAY,oBAAoB;AACzC,QAAI,UAAU,IAAI,QAAQ,GAAG;AAC3B;AAAA,IACF;AAAA,EACF;AAEA,MAAI,0BAA0B,CAAC,YAAY;AACzC,YAAQ,OAAO;AAAA,MACb,MAAM,EAAE,UAAU;AAAA,MAClB,WAAW;AAAA,MACX;AAAA,IACF,CAAC;AAAA,EACH,WAAW,YAAY;AACrB,YAAQ,OAAO;AAAA,MACb,MAAM,EAAE,UAAU;AAAA,MAClB,WAAW;AAAA,MACX;AAAA,IACF,CAAC;AAAA,EACH,OAAO;AACL,YAAQ,OAAO;AAAA,MACb,MAAM,EAAE,UAAU;AAAA,MAClB,WAAW;AAAA,MACX;AAAA,IACF,CAAC;AAAA,EACH;AACF;",
  "names": []
}


package/dist/lib/esm/linters/eslint-rules/require-plugin-api-contract-schemas.d.mts

@@ -0,0 +1,10 @@
+/// <reference path="../../index.d.mts" />
+import type { Rule } from 'eslint';
+/**
+ * Message ID reported for a method entry that lacks a schema.
+ */
+export declare const MESSAGE_ID = "requirePluginApiContractSchemas";
+/**
+ * ESLint rule requiring both an `input` and an `output` schema on every method entry of a plugin API contract.
+ */
+export declare const requirePluginApiContractSchemas: Rule.RuleModule;

package/dist/lib/esm/linters/eslint-rules/require-plugin-api-contract-schemas.mjs

@@ -0,0 +1,197 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { toTSESTreeNode } from "@mnaoumov/typescript-dev-toolkit/linters/eslint-rules/ts-estree-node";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+const MESSAGE_ID = "requirePluginApiContractSchemas";
+const CONTRACT_TYPE_NAMES = /* @__PURE__ */ new Set(["PluginApiContract", "TypedPluginApiContract"]);
+const CONTRACT_VARIABLE_NAME_PATTERN = /_API_CONTRACT(?:_V\d+)?$/;
+const CONTRACT_PROPERTY_NAME = "contract";
+const REQUIRED_SCHEMA_NAMES = ["input", "output"];
+const requirePluginApiContractSchemas = {
+  create(context) {
+    const checkedContracts = /* @__PURE__ */ new Set();
+    return {
+      "Property"(node) {
+        const propertyNode = toTSESTreeNode(node);
+        if (propertyNode.parent.type === AST_NODE_TYPES.ObjectExpression && !propertyNode.computed && readKeyName(propertyNode.key) === CONTRACT_PROPERTY_NAME) {
+          reportContractEntries(propertyNode.value);
+        }
+      },
+      "TSAsExpression, TSSatisfiesExpression"(node) {
+        const expressionNode = toTSESTreeNode(node);
+        if (isContractType(expressionNode.typeAnnotation)) {
+          reportContractEntries(expressionNode.expression);
+        }
+      },
+      "VariableDeclarator"(node) {
+        const declaratorNode = toTSESTreeNode(node);
+        if (declaratorNode.id.type !== AST_NODE_TYPES.Identifier || !declaratorNode.init) {
+          return;
+        }
+        const typeNode = declaratorNode.id.typeAnnotation?.typeAnnotation;
+        if (CONTRACT_VARIABLE_NAME_PATTERN.test(declaratorNode.id.name) || typeNode !== void 0 && isContractType(typeNode)) {
+          reportContractEntries(declaratorNode.init);
+        }
+      }
+    };
+    function reportContractEntries(node) {
+      const contractNode = resolveObjectLiteral(node, context);
+      if (!contractNode || checkedContracts.has(contractNode)) {
+        return;
+      }
+      checkedContracts.add(contractNode);
+      for (const entry of contractNode.properties) {
+        if (entry.type !== AST_NODE_TYPES.Property) {
+          continue;
+        }
+        const missingSchemaNames = readMissingSchemaNames(entry.value, context);
+        if (missingSchemaNames.length === 0) {
+          continue;
+        }
+        context.report({
+          data: {
+            method: (entry.computed ? null : readKeyName(entry.key)) ?? "[computed]",
+            missing: missingSchemaNames.map((name) => `\`${name}\``).join(" and ")
+          },
+          loc: entry.key.loc,
+          messageId: MESSAGE_ID
+        });
+      }
+    }
+  },
+  meta: {
+    docs: {
+      description: "Require an `input` and an `output` schema on every method entry of a plugin API contract"
+    },
+    messages: {
+      [MESSAGE_ID]: "The plugin API contract entry `{{ method }}` declares no {{ missing }} schema. Give every method entry both an `input` schema over its argument list and an `output` schema over its awaited return value."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+function findVariable(scope, name) {
+  let currentScope = scope;
+  while (currentScope) {
+    const variable = currentScope.set.get(name);
+    if (variable) {
+      return variable;
+    }
+    currentScope = currentScope.upper;
+  }
+  return null;
+}
+function isContractType(typeNode) {
+  if (typeNode.type !== AST_NODE_TYPES.TSTypeReference) {
+    return false;
+  }
+  const typeName = typeNode.typeName;
+  return typeName.type === AST_NODE_TYPES.Identifier ? CONTRACT_TYPE_NAMES.has(typeName.name) : typeName.type === AST_NODE_TYPES.TSQualifiedName && CONTRACT_TYPE_NAMES.has(typeName.right.name);
+}
+function readKeyName(key) {
+  if (key.type === AST_NODE_TYPES.Identifier) {
+    return key.name;
+  }
+  return key.type === AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
+}
+function readMissingSchemaNames(node, context) {
+  const entryNode = resolveObjectLiteral(node, context);
+  if (!entryNode) {
+    return [];
+  }
+  const keyNames = /* @__PURE__ */ new Set();
+  for (const member of entryNode.properties) {
+    if (member.type !== AST_NODE_TYPES.Property) {
+      return [];
+    }
+    const keyName = member.computed ? null : readKeyName(member.key);
+    if (keyName !== null) {
+      keyNames.add(keyName);
+    }
+  }
+  return REQUIRED_SCHEMA_NAMES.filter((name) => !keyNames.has(name));
+}
+function resolveConstInit(node, context) {
+  const variable = findVariable(context.sourceCode.getScope(node), node.name);
+  const definition = variable?.defs.length === 1 ? variable.defs[0] : void 0;
+  if (definition?.type !== "Variable") {
+    return null;
+  }
+  const declaratorNode = toTSESTreeNode(definition.node);
+  const declarationNode = declaratorNode.parent;
+  return declarationNode.kind === "const" ? declaratorNode.init : null;
+}
+function resolveObjectLiteral(node, context) {
+  const visitedNodes = /* @__PURE__ */ new Set();
+  let currentNode = node;
+  while (!visitedNodes.has(currentNode)) {
+    visitedNodes.add(currentNode);
+    switch (currentNode.type) {
+      case AST_NODE_TYPES.Identifier: {
+        const initNode = resolveConstInit(currentNode, context);
+        if (!initNode) {
+          return null;
+        }
+        currentNode = initNode;
+        break;
+      }
+      case AST_NODE_TYPES.ObjectExpression: {
+        return currentNode;
+      }
+      case AST_NODE_TYPES.TSAsExpression:
+      case AST_NODE_TYPES.TSNonNullExpression:
+      case AST_NODE_TYPES.TSSatisfiesExpression: {
+        currentNode = currentNode.expression;
+        break;
+      }
+      default: {
+        return null;
+      }
+    }
+  }
+  return null;
+}
+export {
+  MESSAGE_ID,
+  requirePluginApiContractSchemas
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/linters/eslint-rules/require-plugin-api-contract-schemas.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * ESLint rule: require-plugin-api-contract-schemas\n *\n * Reports a method entry of a plugin API contract that lacks an `input` or an `output` schema.\n *\n * A typed `PluginApiContract<MyApi>` already refuses such an entry at compile time. The untyped default, the\n * structurally typed contracts a provider ships beside its `api.d.ts`, and every repository still on\n * `obsidian-dev-utils` get no such check, so a `{}` entry there compiles, declares only that the method exists, and\n * validates nothing. This rule closes that gap for every contract it can recognize.\n *\n * An object literal is read as a contract when it is:\n *\n * - the initializer of a variable typed `PluginApiContract` (or `TypedPluginApiContract`);\n * - the operand of `satisfies PluginApiContract` or `as PluginApiContract`;\n * - the value of a `contract` property of an object literal, as passed to `publishPluginApi`, `watchPluginApi` or\n *   `findPluginApi`;\n * - the initializer of a variable named `*_API_CONTRACT`, optionally followed by a `_V<n>` version suffix.\n *\n * Each of its entries is a method entry. An entry, or a contract, written as the name of a `const` is followed to\n * that constant's object literal, so a method contract shared by several entries is checked once per entry.\n *\n * Not attempted: an entry built by a call, read from another module, or carrying a spread cannot be read\n * statically, so it is skipped. The rule under-reports rather than guessing.\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';\nimport { AST_NODE_TYPES } from '@typescript-eslint/utils';\n\n/**\n * Message ID reported for a method entry that lacks a schema.\n */\nexport const MESSAGE_ID = 'requirePluginApiContractSchemas';\n\n/**\n * The type names that mark an object literal as a plugin API contract.\n */\nconst CONTRACT_TYPE_NAMES = new Set(['PluginApiContract', 'TypedPluginApiContract']);\n\n/**\n * The name of a variable holding a plugin API contract, such as `MY_API_CONTRACT` or `MY_API_CONTRACT_V2`.\n */\nconst CONTRACT_VARIABLE_NAME_PATTERN = /_API_CONTRACT(?:_V\\d+)?$/;\n\n/**\n * The property a contract is passed under.\n */\nconst CONTRACT_PROPERTY_NAME = 'contract';\n\n/**\n * The schemas every method entry must declare.\n */\nconst REQUIRED_SCHEMA_NAMES = ['input', 'output'] as const;\n\n/**\n * ESLint rule requiring both an `input` and an `output` schema on every method entry of a plugin API contract.\n */\nexport const requirePluginApiContractSchemas: Rule.RuleModule = {\n  create(context) {\n    const checkedContracts = new Set<TSESTree.ObjectExpression>();\n\n    return {\n      'Property'(node: Rule.Node): void {\n        const propertyNode = toTSESTreeNode(node) as TSESTree.Property;\n        if (\n          propertyNode.parent.type === AST_NODE_TYPES.ObjectExpression && !propertyNode.computed\n          && readKeyName(propertyNode.key) === CONTRACT_PROPERTY_NAME\n        ) {\n          reportContractEntries(propertyNode.value);\n        }\n      },\n      'TSAsExpression, TSSatisfiesExpression'(node: Rule.Node): void {\n        const expressionNode = toTSESTreeNode(node) as TSESTree.TSAsExpression | TSESTree.TSSatisfiesExpression;\n        if (isContractType(expressionNode.typeAnnotation)) {\n          reportContractEntries(expressionNode.expression);\n        }\n      },\n      'VariableDeclarator'(node: Rule.Node): void {\n        const declaratorNode = toTSESTreeNode(node) as TSESTree.VariableDeclarator;\n        if (declaratorNode.id.type !== AST_NODE_TYPES.Identifier || !declaratorNode.init) {\n          return;\n        }\n\n        const typeNode = declaratorNode.id.typeAnnotation?.typeAnnotation;\n        if (CONTRACT_VARIABLE_NAME_PATTERN.test(declaratorNode.id.name) || (typeNode !== undefined && isContractType(typeNode))) {\n          reportContractEntries(declaratorNode.init);\n        }\n      }\n    };\n\n    function reportContractEntries(node: TSESTree.Node): void {\n      const contractNode = resolveObjectLiteral(node, context);\n      if (!contractNode || checkedContracts.has(contractNode)) {\n        return;\n      }\n\n      checkedContracts.add(contractNode);\n\n      for (const entry of contractNode.properties) {\n        if (entry.type !== AST_NODE_TYPES.Property) {\n          continue;\n        }\n\n        const missingSchemaNames = readMissingSchemaNames(entry.value, context);\n        if (missingSchemaNames.length === 0) {\n          continue;\n        }\n\n        context.report({\n          data: {\n            method: (entry.computed ? null : readKeyName(entry.key)) ?? '[computed]',\n            missing: missingSchemaNames.map((name) => `\\`${name}\\``).join(' and ')\n          },\n          loc: entry.key.loc,\n          messageId: MESSAGE_ID\n        });\n      }\n    }\n  },\n  meta: {\n    docs: {\n      description: 'Require an `input` and an `output` schema on every method entry of a plugin API contract'\n    },\n    messages: {\n      [MESSAGE_ID]: 'The plugin API contract entry `{{ method }}` declares no {{ missing }} schema. Give every method entry both an `input` schema over its argument list and an `output` schema over its awaited return value.'\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.set.get(name);\n    if (variable) {\n      return variable;\n    }\n    currentScope = currentScope.upper;\n  }\n\n  return null;\n}\n\n/**\n * Checks whether a type names a plugin API contract, directly or through a namespace.\n *\n * @param typeNode - The type.\n * @returns `true` when the type is a contract type.\n */\nfunction isContractType(typeNode: TSESTree.TypeNode): boolean {\n  if (typeNode.type !== AST_NODE_TYPES.TSTypeReference) {\n    return false;\n  }\n\n  const typeName = typeNode.typeName;\n  return typeName.type === AST_NODE_TYPES.Identifier ? CONTRACT_TYPE_NAMES.has(typeName.name) : typeName.type === AST_NODE_TYPES.TSQualifiedName && CONTRACT_TYPE_NAMES.has(typeName.right.name);\n}\n\n/**\n * Reads the name of a property key written as an identifier or a string literal.\n *\n * @param key - The property key.\n * @returns The name, or `null` for any other key.\n */\nfunction readKeyName(key: TSESTree.Node): 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\n/**\n * Reads which required schemas a method entry lacks.\n *\n * @param node - The entry's value.\n * @param context - The rule context, used to follow a constant.\n * @returns The missing schema names, empty when none is missing or the entry cannot be read statically.\n */\nfunction readMissingSchemaNames(node: TSESTree.Node, context: Rule.RuleContext): string[] {\n  const entryNode = resolveObjectLiteral(node, context);\n  if (!entryNode) {\n    return [];\n  }\n\n  const keyNames = new Set<string>();\n  for (const member of entryNode.properties) {\n    if (member.type !== AST_NODE_TYPES.Property) {\n      return [];\n    }\n\n    const keyName = member.computed ? null : readKeyName(member.key);\n    if (keyName !== null) {\n      keyNames.add(keyName);\n    }\n  }\n\n  return REQUIRED_SCHEMA_NAMES.filter((name) => !keyNames.has(name));\n}\n\n/**\n * Resolves an identifier to the initializer of the `const` it names.\n *\n * @param node - The identifier.\n * @param context - The rule context, used to resolve the identifier through scope.\n * @returns The initializer, or `null` when the identifier names anything else.\n */\nfunction resolveConstInit(node: TSESTree.Identifier, context: Rule.RuleContext): null | TSESTree.Expression {\n  const variable = findVariable(context.sourceCode.getScope(node), node.name);\n  const definition = variable?.defs.length === 1 ? variable.defs[0] : undefined;\n  if (definition?.type !== 'Variable') {\n    return null;\n  }\n\n  const declaratorNode = toTSESTreeNode(definition.node) as TSESTree.VariableDeclarator;\n  const declarationNode = declaratorNode.parent;\n  return declarationNode.kind === 'const' ? declaratorNode.init : null;\n}\n\n/**\n * Resolves an expression to the object literal it is, stepping through `as` / `satisfies` / `!` and following a\n * `const` it names.\n *\n * @param node - The expression.\n * @param context - The rule context, used to resolve an identifier through scope.\n * @returns The object literal, or `null` when the expression is not one statically.\n */\nfunction resolveObjectLiteral(node: TSESTree.Node, context: Rule.RuleContext): null | TSESTree.ObjectExpression {\n  const visitedNodes = new Set<TSESTree.Node>();\n  let currentNode: TSESTree.Node = node;\n\n  while (!visitedNodes.has(currentNode)) {\n    visitedNodes.add(currentNode);\n\n    switch (currentNode.type) {\n      case AST_NODE_TYPES.Identifier: {\n        const initNode = resolveConstInit(currentNode, context);\n        if (!initNode) {\n          return null;\n        }\n        currentNode = initNode;\n        break;\n      }\n      case AST_NODE_TYPES.ObjectExpression: {\n        return currentNode;\n      }\n      case AST_NODE_TYPES.TSAsExpression:\n      case AST_NODE_TYPES.TSNonNullExpression:\n      case AST_NODE_TYPES.TSSatisfiesExpression: {\n        currentNode = currentNode.expression;\n        break;\n      }\n      default: {\n        return null;\n      }\n    }\n  }\n\n  return null;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,SAAS,sBAAsB;AAC/B,SAAS,sBAAsB;AAKxB,MAAM,aAAa;AAK1B,MAAM,sBAAsB,oBAAI,IAAI,CAAC,qBAAqB,wBAAwB,CAAC;AAKnF,MAAM,iCAAiC;AAKvC,MAAM,yBAAyB;AAK/B,MAAM,wBAAwB,CAAC,SAAS,QAAQ;AAKzC,MAAM,kCAAmD;AAAA,EAC9D,OAAO,SAAS;AACd,UAAM,mBAAmB,oBAAI,IAA+B;AAE5D,WAAO;AAAA,MACL,WAAW,MAAuB;AAChC,cAAM,eAAe,eAAe,IAAI;AACxC,YACE,aAAa,OAAO,SAAS,eAAe,oBAAoB,CAAC,aAAa,YAC3E,YAAY,aAAa,GAAG,MAAM,wBACrC;AACA,gCAAsB,aAAa,KAAK;AAAA,QAC1C;AAAA,MACF;AAAA,MACA,wCAAwC,MAAuB;AAC7D,cAAM,iBAAiB,eAAe,IAAI;AAC1C,YAAI,eAAe,eAAe,cAAc,GAAG;AACjD,gCAAsB,eAAe,UAAU;AAAA,QACjD;AAAA,MACF;AAAA,MACA,qBAAqB,MAAuB;AAC1C,cAAM,iBAAiB,eAAe,IAAI;AAC1C,YAAI,eAAe,GAAG,SAAS,eAAe,cAAc,CAAC,eAAe,MAAM;AAChF;AAAA,QACF;AAEA,cAAM,WAAW,eAAe,GAAG,gBAAgB;AACnD,YAAI,+BAA+B,KAAK,eAAe,GAAG,IAAI,KAAM,aAAa,UAAa,eAAe,QAAQ,GAAI;AACvH,gCAAsB,eAAe,IAAI;AAAA,QAC3C;AAAA,MACF;AAAA,IACF;AAEA,aAAS,sBAAsB,MAA2B;AACxD,YAAM,eAAe,qBAAqB,MAAM,OAAO;AACvD,UAAI,CAAC,gBAAgB,iBAAiB,IAAI,YAAY,GAAG;AACvD;AAAA,MACF;AAEA,uBAAiB,IAAI,YAAY;AAEjC,iBAAW,SAAS,aAAa,YAAY;AAC3C,YAAI,MAAM,SAAS,eAAe,UAAU;AAC1C;AAAA,QACF;AAEA,cAAM,qBAAqB,uBAAuB,MAAM,OAAO,OAAO;AACtE,YAAI,mBAAmB,WAAW,GAAG;AACnC;AAAA,QACF;AAEA,gBAAQ,OAAO;AAAA,UACb,MAAM;AAAA,YACJ,SAAS,MAAM,WAAW,OAAO,YAAY,MAAM,GAAG,MAAM;AAAA,YAC5D,SAAS,mBAAmB,IAAI,CAAC,SAAS,KAAK,IAAI,IAAI,EAAE,KAAK,OAAO;AAAA,UACvE;AAAA,UACA,KAAK,MAAM,IAAI;AAAA,UACf,WAAW;AAAA,QACb,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,IAAI,IAAI,IAAI;AAC1C,QAAI,UAAU;AACZ,aAAO;AAAA,IACT;AACA,mBAAe,aAAa;AAAA,EAC9B;AAEA,SAAO;AACT;AAQA,SAAS,eAAe,UAAsC;AAC5D,MAAI,SAAS,SAAS,eAAe,iBAAiB;AACpD,WAAO;AAAA,EACT;AAEA,QAAM,WAAW,SAAS;AAC1B,SAAO,SAAS,SAAS,eAAe,aAAa,oBAAoB,IAAI,SAAS,IAAI,IAAI,SAAS,SAAS,eAAe,mBAAmB,oBAAoB,IAAI,SAAS,MAAM,IAAI;AAC/L;AAQA,SAAS,YAAY,KAAmC;AACtD,MAAI,IAAI,SAAS,eAAe,YAAY;AAC1C,WAAO,IAAI;AAAA,EACb;AAEA,SAAO,IAAI,SAAS,eAAe,WAAW,OAAO,IAAI,UAAU,WAAW,IAAI,QAAQ;AAC5F;AASA,SAAS,uBAAuB,MAAqB,SAAqC;AACxF,QAAM,YAAY,qBAAqB,MAAM,OAAO;AACpD,MAAI,CAAC,WAAW;AACd,WAAO,CAAC;AAAA,EACV;AAEA,QAAM,WAAW,oBAAI,IAAY;AACjC,aAAW,UAAU,UAAU,YAAY;AACzC,QAAI,OAAO,SAAS,eAAe,UAAU;AAC3C,aAAO,CAAC;AAAA,IACV;AAEA,UAAM,UAAU,OAAO,WAAW,OAAO,YAAY,OAAO,GAAG;AAC/D,QAAI,YAAY,MAAM;AACpB,eAAS,IAAI,OAAO;AAAA,IACtB;AAAA,EACF;AAEA,SAAO,sBAAsB,OAAO,CAAC,SAAS,CAAC,SAAS,IAAI,IAAI,CAAC;AACnE;AASA,SAAS,iBAAiB,MAA2B,SAAuD;AAC1G,QAAM,WAAW,aAAa,QAAQ,WAAW,SAAS,IAAI,GAAG,KAAK,IAAI;AAC1E,QAAM,aAAa,UAAU,KAAK,WAAW,IAAI,SAAS,KAAK,CAAC,IAAI;AACpE,MAAI,YAAY,SAAS,YAAY;AACnC,WAAO;AAAA,EACT;AAEA,QAAM,iBAAiB,eAAe,WAAW,IAAI;AACrD,QAAM,kBAAkB,eAAe;AACvC,SAAO,gBAAgB,SAAS,UAAU,eAAe,OAAO;AAClE;AAUA,SAAS,qBAAqB,MAAqB,SAA6D;AAC9G,QAAM,eAAe,oBAAI,IAAmB;AAC5C,MAAI,cAA6B;AAEjC,SAAO,CAAC,aAAa,IAAI,WAAW,GAAG;AACrC,iBAAa,IAAI,WAAW;AAE5B,YAAQ,YAAY,MAAM;AAAA,MACxB,KAAK,eAAe,YAAY;AAC9B,cAAM,WAAW,iBAAiB,aAAa,OAAO;AACtD,YAAI,CAAC,UAAU;AACb,iBAAO;AAAA,QACT;AACA,sBAAc;AACd;AAAA,MACF;AAAA,MACA,KAAK,eAAe,kBAAkB;AACpC,eAAO;AAAA,MACT;AAAA,MACA,KAAK,eAAe;AAAA,MACpB,KAAK,eAAe;AAAA,MACpB,KAAK,eAAe,uBAAuB;AACzC,sBAAc,YAAY;AAC1B;AAAA,MACF;AAAA,MACA,SAAS;AACP,eAAO;AAAA,MACT;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;",
  "names": []
}


package/dist/lib/esm/linters/eslint.d.mts

@@ -0,0 +1,15 @@
+/// <reference path="../index.d.mts" />
+/**
+ * @file
+ *
+ * Lints an Obsidian plugin with ESLint: the generic runner from `@mnaoumov/typescript-dev-toolkit`, which copies
+ * this package's `eslint.config.mts` template into a project that has no configuration yet.
+ */
+import type { LintOptions } from '@mnaoumov/typescript-dev-toolkit/linters/eslint';
+/**
+ * Lints the project with ESLint.
+ *
+ * @param options - The {@link LintOptions}.
+ */
+export declare function lint(options?: LintOptions): Promise<void>;
+export { type LintOptions } from '@mnaoumov/typescript-dev-toolkit/linters/eslint';

package/dist/lib/esm/linters/eslint.mjs

@@ -0,0 +1,52 @@
+/*
+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 { lint as lintGeneric } from "@mnaoumov/typescript-dev-toolkit/linters/eslint";
+import { RepoPaths } from "@mnaoumov/typescript-dev-toolkit/repo-paths";
+import { getTemplateFilePath } from "../templates.mjs";
+import {} from "@mnaoumov/typescript-dev-toolkit/linters/eslint";
+async function lint(options) {
+  await lintGeneric({ defaultConfigFilePath: getTemplateFilePath(RepoPaths.EslintConfigMts), ...options });
+}
+export {
+  lint
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL2xpbnRlcnMvZXNsaW50LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogTGludHMgYW4gT2JzaWRpYW4gcGx1Z2luIHdpdGggRVNMaW50OiB0aGUgZ2VuZXJpYyBydW5uZXIgZnJvbSBgQG1uYW91bW92L3R5cGVzY3JpcHQtZGV2LXRvb2xraXRgLCB3aGljaCBjb3BpZXNcbiAqIHRoaXMgcGFja2FnZSdzIGBlc2xpbnQuY29uZmlnLm10c2AgdGVtcGxhdGUgaW50byBhIHByb2plY3QgdGhhdCBoYXMgbm8gY29uZmlndXJhdGlvbiB5ZXQuXG4gKi9cblxuaW1wb3J0IHR5cGUgeyBMaW50T3B0aW9ucyB9IGZyb20gJ0BtbmFvdW1vdi90eXBlc2NyaXB0LWRldi10b29sa2l0L2xpbnRlcnMvZXNsaW50JztcblxuaW1wb3J0IHsgbGludCBhcyBsaW50R2VuZXJpYyB9IGZyb20gJ0BtbmFvdW1vdi90eXBlc2NyaXB0LWRldi10b29sa2l0L2xpbnRlcnMvZXNsaW50JztcbmltcG9ydCB7IFJlcG9QYXRocyB9IGZyb20gJ0BtbmFvdW1vdi90eXBlc2NyaXB0LWRldi10b29sa2l0L3JlcG8tcGF0aHMnO1xuXG5pbXBvcnQgeyBnZXRUZW1wbGF0ZUZpbGVQYXRoIH0gZnJvbSAnLi4vdGVtcGxhdGVzLnRzJztcblxuLyoqXG4gKiBMaW50cyB0aGUgcHJvamVjdCB3aXRoIEVTTGludC5cbiAqXG4gKiBAcGFyYW0gb3B0aW9ucyAtIFRoZSB7QGxpbmsgTGludE9wdGlvbnN9LlxuICovXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gbGludChvcHRpb25zPzogTGludE9wdGlvbnMpOiBQcm9taXNlPHZvaWQ+IHtcbiAgYXdhaXQgbGludEdlbmVyaWMoeyBkZWZhdWx0Q29uZmlnRmlsZVBhdGg6IGdldFRlbXBsYXRlRmlsZVBhdGgoUmVwb1BhdGhzLkVzbGludENvbmZpZ010cyksIC4uLm9wdGlvbnMgfSk7XG59XG5leHBvcnQgeyB0eXBlIExpbnRPcHRpb25zIH0gZnJvbSAnQG1uYW91bW92L3R5cGVzY3JpcHQtZGV2LXRvb2xraXQvbGludGVycy9lc2xpbnQnO1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFTQSxTQUFTLFFBQVEsbUJBQW1CO0FBQ3BDLFNBQVMsaUJBQWlCO0FBRTFCLFNBQVMsMkJBQTJCO0FBVXBDLGVBQWlDO0FBSGpDLGVBQXNCLEtBQUssU0FBc0M7QUFDL0QsUUFBTSxZQUFZLEVBQUUsdUJBQXVCLG9CQUFvQixVQUFVLGVBQWUsR0FBRyxHQUFHLFFBQVEsQ0FBQztBQUN6RzsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/lib/esm/linters/index.d.mts

@@ -0,0 +1,9 @@
+/// <reference path="../index.d.mts" />
+export * as 'eslint-config' from './eslint-config.mjs';
+export * as 'eslint-rules' from './eslint-rules/index.mjs';
+export * as 'eslint' from './eslint.mjs';
+export * as 'markdownlint-cli2-config' from './markdownlint-cli2-config.mjs';
+export * as 'markdownlint-rules' from './markdownlint-rules/index.mjs';
+export * as 'markdownlint' from './markdownlint.mjs';
+export * as 'obsidianmd-rule-custom-message' from './obsidianmd-rule-custom-message.mjs';
+export * as 'plugin-names' from './plugin-names.mjs';

package/dist/lib/esm/linters/index.mjs

@@ -0,0 +1,60 @@
+/*
+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 * as eslint_config from "./eslint-config.mjs";
+import * as eslint_rules from "./eslint-rules/index.mjs";
+import * as eslint from "./eslint.mjs";
+import * as markdownlint_cli2_config from "./markdownlint-cli2-config.mjs";
+import * as markdownlint_rules from "./markdownlint-rules/index.mjs";
+import * as markdownlint from "./markdownlint.mjs";
+import * as obsidianmd_rule_custom_message from "./obsidianmd-rule-custom-message.mjs";
+import * as plugin_names from "./plugin-names.mjs";
+export {
+  eslint,
+  eslint_config as "eslint-config",
+  eslint_rules as "eslint-rules",
+  markdownlint,
+  markdownlint_cli2_config as "markdownlint-cli2-config",
+  markdownlint_rules as "markdownlint-rules",
+  obsidianmd_rule_custom_message as "obsidianmd-rule-custom-message",
+  plugin_names as "plugin-names"
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL2xpbnRlcnMvaW5kZXgudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qIFRISVMgSVMgQSBHRU5FUkFURUQvQlVORExFRCBGSUxFIEJZIEJVSUxEIFNDUklQVCAqL1xuXG5leHBvcnQgKiBhcyAnZXNsaW50LWNvbmZpZycgZnJvbSAnLi9lc2xpbnQtY29uZmlnLnRzJztcbmV4cG9ydCAqIGFzICdlc2xpbnQtcnVsZXMnIGZyb20gJy4vZXNsaW50LXJ1bGVzL2luZGV4LnRzJztcbmV4cG9ydCAqIGFzICdlc2xpbnQnIGZyb20gJy4vZXNsaW50LnRzJztcbmV4cG9ydCAqIGFzICdtYXJrZG93bmxpbnQtY2xpMi1jb25maWcnIGZyb20gJy4vbWFya2Rvd25saW50LWNsaTItY29uZmlnLnRzJztcbmV4cG9ydCAqIGFzICdtYXJrZG93bmxpbnQtcnVsZXMnIGZyb20gJy4vbWFya2Rvd25saW50LXJ1bGVzL2luZGV4LnRzJztcbmV4cG9ydCAqIGFzICdtYXJrZG93bmxpbnQnIGZyb20gJy4vbWFya2Rvd25saW50LnRzJztcbmV4cG9ydCAqIGFzICdvYnNpZGlhbm1kLXJ1bGUtY3VzdG9tLW1lc3NhZ2UnIGZyb20gJy4vb2JzaWRpYW5tZC1ydWxlLWN1c3RvbS1tZXNzYWdlLnRzJztcbmV4cG9ydCAqIGFzICdwbHVnaW4tbmFtZXMnIGZyb20gJy4vcGx1Z2luLW5hbWVzLnRzJztcbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBRUEsWUFBWUEsbUJBQXFCO0FBQ2pDLFlBQVlDLGtCQUFvQjtBQUNoQyxZQUFZLFlBQWM7QUFDMUIsWUFBWUMsOEJBQWdDO0FBQzVDLFlBQVlDLHdCQUEwQjtBQUN0QyxZQUFZLGtCQUFvQjtBQUNoQyxZQUFZQyxvQ0FBc0M7QUFDbEQsWUFBWUMsa0JBQW9COyIsCiAgIm5hbWVzIjogWyJlc2xpbnQtY29uZmlnIiwgImVzbGludC1ydWxlcyIsICJtYXJrZG93bmxpbnQtY2xpMi1jb25maWciLCAibWFya2Rvd25saW50LXJ1bGVzIiwgIm9ic2lkaWFubWQtcnVsZS1jdXN0b20tbWVzc2FnZSIsICJwbHVnaW4tbmFtZXMiXQp9Cg==

package/dist/lib/esm/linters/markdownlint-cli2-config.d.mts

@@ -0,0 +1,12 @@
+/// <reference path="../index.d.mts" />
+/**
+ * @file
+ *
+ * The markdownlint-cli2 configuration of an Obsidian plugin: the generic one from `@mnaoumov/typescript-dev-toolkit`,
+ * plus the Obsidian rules of this package.
+ */
+import type { MarkdownlintCli2ConfigurationSchema as MarkdownlintCli2ConfigSchema } from '@mnaoumov/typescript-dev-toolkit/linters/markdownlint-types/@types/markdownlint-cli2-config-schema';
+/**
+ * The markdownlint-cli2 configuration of an Obsidian plugin.
+ */
+export declare const obsidianMarkdownlintCli2Config: MarkdownlintCli2ConfigSchema;

package/dist/lib/esm/linters/markdownlint-cli2-config.mjs

@@ -0,0 +1,66 @@
+/*
+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 { obsidianDevUtilsConfig } from "@mnaoumov/typescript-dev-toolkit/linters/markdownlint-cli2-config";
+import {
+  PLUGIN_NAME_AS_CODE_RULE_NAME,
+  pluginNameAsCodeRule
+} from "./markdownlint-rules/plugin-name-as-code.mjs";
+const obsidianMarkdownlintCli2Config = {
+  ...obsidianDevUtilsConfig,
+  config: {
+    ...obsidianDevUtilsConfig.config,
+    // Registered but OFF by default: markdownlint enables an unlisted custom rule, so landing it silent has to be
+    // said out loud. Repositories still carry plain plugin names from before the rule existed; each one fixes them
+    // (`npm run lint:md:fix` does it) and turns the rule on by overriding this one key in its own
+    // `scripts/markdownlint-cli2-config.ts`. The rule takes `{ additionalPluginNames: [...] }` for names the shared
+    // list lacks.
+    [PLUGIN_NAME_AS_CODE_RULE_NAME]: false
+  },
+  customRules: [
+    ...obsidianDevUtilsConfig.customRules ?? [],
+    pluginNameAsCodeRule
+  ]
+};
+export {
+  obsidianMarkdownlintCli2Config
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/linters/markdownlint-rules/index.d.mts

@@ -0,0 +1,2 @@
+/// <reference path="../../index.d.mts" />
+export * as 'plugin-name-as-code' from './plugin-name-as-code.mjs';