obsidian-dev-utils 96.6.0 → 98.0.0

package/dist/lib/esm/script-utils/linters/eslint-rules/manifest-description.mjs

@@ -0,0 +1,148 @@
+/*
+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 ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    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() {
+  ensureBrowserProcess();
+})();
+})();
+
+import {
+  findManifestMember,
+  getManifestObject,
+  getStringValue,
+  toReportNode
+} from "./manifest-helpers.mjs";
+const MESSAGE_ID_CONTAINS_OBSIDIAN = "descriptionContainsObsidian";
+const MESSAGE_ID_MISSING_PERIOD = "descriptionMissingPeriod";
+const MESSAGE_ID_NOT_CAPITALIZED = "descriptionNotCapitalized";
+const MESSAGE_ID_SELF_REFERENCE = "descriptionSelfReference";
+const MESSAGE_ID_TOO_LONG = "descriptionTooLong";
+const MESSAGE_ID_TOO_SHORT = "descriptionTooShort";
+const MAX_DESCRIPTION_LENGTH = 250;
+const MIN_DESCRIPTION_LENGTH = 10;
+const OBSIDIAN_WORD = /\bobsidian\b/i;
+const SELF_REFERENCE_PATTERNS = [
+  /\bthis plugin\b/i,
+  /\bthis is a plugin\b/i,
+  /\ba plugin (?:that|which)\b/i,
+  /^the plugin\b/i,
+  /^plugin\b/i
+];
+const manifestDescription = {
+  create(context) {
+    return {
+      Document(node) {
+        const manifestObject = getManifestObject(node);
+        if (!manifestObject) {
+          return;
+        }
+        const member = findManifestMember(manifestObject, "description");
+        if (!member) {
+          return;
+        }
+        const description = getStringValue(member.value);
+        if (description === null) {
+          return;
+        }
+        const reportNode = toReportNode(member.value);
+        if (OBSIDIAN_WORD.test(description)) {
+          context.report({
+            messageId: MESSAGE_ID_CONTAINS_OBSIDIAN,
+            node: reportNode
+          });
+        }
+        if (SELF_REFERENCE_PATTERNS.some((pattern) => pattern.test(description))) {
+          context.report({
+            messageId: MESSAGE_ID_SELF_REFERENCE,
+            node: reportNode
+          });
+        }
+        if (description.length < MIN_DESCRIPTION_LENGTH) {
+          context.report({
+            messageId: MESSAGE_ID_TOO_SHORT,
+            node: reportNode
+          });
+        }
+        if (description.length > MAX_DESCRIPTION_LENGTH) {
+          context.report({
+            data: { maxLength: MAX_DESCRIPTION_LENGTH.toString() },
+            messageId: MESSAGE_ID_TOO_LONG,
+            node: reportNode
+          });
+        }
+        if (!/^[A-Z]/.test(description)) {
+          context.report({
+            messageId: MESSAGE_ID_NOT_CAPITALIZED,
+            node: reportNode
+          });
+        }
+        if (!description.endsWith(".")) {
+          context.report({
+            messageId: MESSAGE_ID_MISSING_PERIOD,
+            node: reportNode
+          });
+        }
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Enforce the Community directory's constraints on a plugin's `manifest.json` `description`"
+    },
+    messages: {
+      [MESSAGE_ID_CONTAINS_OBSIDIAN]: "The `description` must not contain the word `Obsidian`. It is implied by the context of the plugin directory.",
+      [MESSAGE_ID_MISSING_PERIOD]: "The `description` must end with a period.",
+      [MESSAGE_ID_NOT_CAPITALIZED]: "The `description` must start with a capital letter.",
+      [MESSAGE_ID_SELF_REFERENCE]: "The `description` must not refer to itself, e.g. `this plugin` or `a plugin that`. Describe what it does instead.",
+      [MESSAGE_ID_TOO_LONG]: "The `description` must be at most {{ maxLength }} characters.",
+      [MESSAGE_ID_TOO_SHORT]: "The `description` is too short to say what the plugin does."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+export {
+  MESSAGE_ID_CONTAINS_OBSIDIAN,
+  MESSAGE_ID_MISSING_PERIOD,
+  MESSAGE_ID_NOT_CAPITALIZED,
+  MESSAGE_ID_SELF_REFERENCE,
+  MESSAGE_ID_TOO_LONG,
+  MESSAGE_ID_TOO_SHORT,
+  manifestDescription
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../../src/script-utils/linters/eslint-rules/manifest-description.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * ESLint rule: manifest-description\n *\n * Enforces the Community directory's constraints on a plugin's `manifest.json` `description`.\n *\n * Two of these checks deliberately diverge from `obsidianmd/validate-manifest`:\n *\n * - **Self-reference, not the word `plugin`.** Upstream's `FORBIDDEN_WORDS` bans the bare substring\n *   `plugin` in the description, which rejects two descriptions the directory itself passed untouched -\n *   `Enhances Note composer core plugin.` and `...not plugin updates...` - because each names something\n *   other than itself. The directory's actual objection is self-reference, so only self-referential\n *   phrases are matched here.\n * - **No character whitelist.** Upstream's format check rejects anything outside\n *   `[A-Za-z0-9\\s.,!?'\"-]`, which fails backticks, em dashes, parentheses, colons and slashes. Seven\n *   live listings carry those and the directory flagged none, so the check is noise rather than a gate.\n *\n * The no-`Obsidian` check has the opposite provenance: the directory enforces it and no Obsidian\n * document states it, which is what cost a released plugin a version bump for one word.\n *\n * Runs on the `@eslint/json` `json/json` language; see `manifest-helpers.ts` for why the AST is Momoa\n * rather than ESTree.\n */\n\nimport type { Rule } from 'eslint';\n\nimport {\n  findManifestMember,\n  getManifestObject,\n  getStringValue,\n  toReportNode\n} from './manifest-helpers.ts';\n\n/**\nMessage ID reported when the description contains the word `Obsidian`.\n */\nexport const MESSAGE_ID_CONTAINS_OBSIDIAN = 'descriptionContainsObsidian';\n\n/**\nMessage ID reported when the description does not end with a period.\n */\nexport const MESSAGE_ID_MISSING_PERIOD = 'descriptionMissingPeriod';\n\n/**\nMessage ID reported when the description does not start with a capital letter.\n */\nexport const MESSAGE_ID_NOT_CAPITALIZED = 'descriptionNotCapitalized';\n\n/**\nMessage ID reported when the description refers to itself.\n */\nexport const MESSAGE_ID_SELF_REFERENCE = 'descriptionSelfReference';\n\n/**\nMessage ID reported when the description is longer than the directory allows.\n */\nexport const MESSAGE_ID_TOO_LONG = 'descriptionTooLong';\n\n/**\nMessage ID reported when the description is too short to describe anything.\n */\nexport const MESSAGE_ID_TOO_SHORT = 'descriptionTooShort';\n\n/**\nThe longest description the Community directory accepts.\n */\nconst MAX_DESCRIPTION_LENGTH = 250;\n\n/**\nThe shortest description that can plausibly say what a plugin does.\n */\nconst MIN_DESCRIPTION_LENGTH = 10;\n\n/**\nThe word `Obsidian`, which the directory rejects in a description even though no Obsidian document says so.\n */\nconst OBSIDIAN_WORD = /\\bobsidian\\b/i;\n\n/**\nThe phrasings the directory calls out as self-reference. A bare `plugin` is deliberately not among them:\nnaming another plugin, or plugins in general, is not referring to oneself.\n */\nconst SELF_REFERENCE_PATTERNS = [\n  /\\bthis plugin\\b/i,\n  /\\bthis is a plugin\\b/i,\n  /\\ba plugin (?:that|which)\\b/i,\n  /^the plugin\\b/i,\n  /^plugin\\b/i\n];\n\n/**\n * ESLint rule enforcing the Community directory's constraints on a plugin's `manifest.json` `description`.\n */\nexport const manifestDescription: Rule.RuleModule = {\n  create(context) {\n    return {\n      Document(node: unknown): void {\n        const manifestObject = getManifestObject(node);\n\n        if (!manifestObject) {\n          return;\n        }\n\n        const member = findManifestMember(manifestObject, 'description');\n\n        if (!member) {\n          return;\n        }\n\n        const description = getStringValue(member.value);\n\n        if (description === null) {\n          return;\n        }\n\n        const reportNode = toReportNode(member.value);\n\n        if (OBSIDIAN_WORD.test(description)) {\n          context.report({\n            messageId: MESSAGE_ID_CONTAINS_OBSIDIAN,\n            node: reportNode\n          });\n        }\n\n        if (SELF_REFERENCE_PATTERNS.some((pattern) => pattern.test(description))) {\n          context.report({\n            messageId: MESSAGE_ID_SELF_REFERENCE,\n            node: reportNode\n          });\n        }\n\n        if (description.length < MIN_DESCRIPTION_LENGTH) {\n          context.report({\n            messageId: MESSAGE_ID_TOO_SHORT,\n            node: reportNode\n          });\n        }\n\n        if (description.length > MAX_DESCRIPTION_LENGTH) {\n          context.report({\n            data: { maxLength: MAX_DESCRIPTION_LENGTH.toString() },\n            messageId: MESSAGE_ID_TOO_LONG,\n            node: reportNode\n          });\n        }\n\n        if (!/^[A-Z]/.test(description)) {\n          context.report({\n            messageId: MESSAGE_ID_NOT_CAPITALIZED,\n            node: reportNode\n          });\n        }\n\n        if (!description.endsWith('.')) {\n          context.report({\n            messageId: MESSAGE_ID_MISSING_PERIOD,\n            node: reportNode\n          });\n        }\n      }\n    };\n  },\n  meta: {\n    docs: {\n      description: 'Enforce the Community directory\\'s constraints on a plugin\\'s `manifest.json` `description`'\n    },\n    messages: {\n      [MESSAGE_ID_CONTAINS_OBSIDIAN]: 'The `description` must not contain the word `Obsidian`. It is implied by the context of the plugin directory.',\n      [MESSAGE_ID_MISSING_PERIOD]: 'The `description` must end with a period.',\n      [MESSAGE_ID_NOT_CAPITALIZED]: 'The `description` must start with a capital letter.',\n      [MESSAGE_ID_SELF_REFERENCE]: 'The `description` must not refer to itself, e.g. `this plugin` or `a plugin that`. Describe what it does instead.',\n      [MESSAGE_ID_TOO_LONG]: 'The `description` must be at most {{ maxLength }} characters.',\n      [MESSAGE_ID_TOO_SHORT]: 'The `description` is too short to say what the plugin does.'\n    },\n    schema: [],\n    type: 'problem'\n  }\n};\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAKA,MAAM,+BAA+B;AAKrC,MAAM,4BAA4B;AAKlC,MAAM,6BAA6B;AAKnC,MAAM,4BAA4B;AAKlC,MAAM,sBAAsB;AAK5B,MAAM,uBAAuB;AAKpC,MAAM,yBAAyB;AAK/B,MAAM,yBAAyB;AAK/B,MAAM,gBAAgB;AAMtB,MAAM,0BAA0B;AAAA,EAC9B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAKO,MAAM,sBAAuC;AAAA,EAClD,OAAO,SAAS;AACd,WAAO;AAAA,MACL,SAAS,MAAqB;AAC5B,cAAM,iBAAiB,kBAAkB,IAAI;AAE7C,YAAI,CAAC,gBAAgB;AACnB;AAAA,QACF;AAEA,cAAM,SAAS,mBAAmB,gBAAgB,aAAa;AAE/D,YAAI,CAAC,QAAQ;AACX;AAAA,QACF;AAEA,cAAM,cAAc,eAAe,OAAO,KAAK;AAE/C,YAAI,gBAAgB,MAAM;AACxB;AAAA,QACF;AAEA,cAAM,aAAa,aAAa,OAAO,KAAK;AAE5C,YAAI,cAAc,KAAK,WAAW,GAAG;AACnC,kBAAQ,OAAO;AAAA,YACb,WAAW;AAAA,YACX,MAAM;AAAA,UACR,CAAC;AAAA,QACH;AAEA,YAAI,wBAAwB,KAAK,CAAC,YAAY,QAAQ,KAAK,WAAW,CAAC,GAAG;AACxE,kBAAQ,OAAO;AAAA,YACb,WAAW;AAAA,YACX,MAAM;AAAA,UACR,CAAC;AAAA,QACH;AAEA,YAAI,YAAY,SAAS,wBAAwB;AAC/C,kBAAQ,OAAO;AAAA,YACb,WAAW;AAAA,YACX,MAAM;AAAA,UACR,CAAC;AAAA,QACH;AAEA,YAAI,YAAY,SAAS,wBAAwB;AAC/C,kBAAQ,OAAO;AAAA,YACb,MAAM,EAAE,WAAW,uBAAuB,SAAS,EAAE;AAAA,YACrD,WAAW;AAAA,YACX,MAAM;AAAA,UACR,CAAC;AAAA,QACH;AAEA,YAAI,CAAC,SAAS,KAAK,WAAW,GAAG;AAC/B,kBAAQ,OAAO;AAAA,YACb,WAAW;AAAA,YACX,MAAM;AAAA,UACR,CAAC;AAAA,QACH;AAEA,YAAI,CAAC,YAAY,SAAS,GAAG,GAAG;AAC9B,kBAAQ,OAAO;AAAA,YACb,WAAW;AAAA,YACX,MAAM;AAAA,UACR,CAAC;AAAA,QACH;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAAA,EACA,MAAM;AAAA,IACJ,MAAM;AAAA,MACJ,aAAa;AAAA,IACf;AAAA,IACA,UAAU;AAAA,MACR,CAAC,4BAA4B,GAAG;AAAA,MAChC,CAAC,yBAAyB,GAAG;AAAA,MAC7B,CAAC,0BAA0B,GAAG;AAAA,MAC9B,CAAC,yBAAyB,GAAG;AAAA,MAC7B,CAAC,mBAAmB,GAAG;AAAA,MACvB,CAAC,oBAAoB,GAAG;AAAA,IAC1B;AAAA,IACA,QAAQ,CAAC;AAAA,IACT,MAAM;AAAA,EACR;AACF;",
  "names": []
}


package/dist/lib/esm/script-utils/linters/eslint-rules/manifest-helpers.d.mts

@@ -0,0 +1,141 @@
+/// <reference path="../../../library.d.mts" />
+/**
+ * @file
+ *
+ * Shared helpers for the `manifest.json` ESLint rules.
+ *
+ * The manifest is linted through `@eslint/json`'s `json/json` language, whose AST is Momoa
+ * (`Document` -> `Object` -> `Member`) rather than ESTree, so these rules visit `Document` instead of
+ * `Program`. That difference is exactly why `obsidianmd/validate-manifest` can never fire: it registers a
+ * `Program` visitor and expects an ESTree `ObjectExpression`, which no shipped JSON parser produces.
+ *
+ * The Momoa node shapes are declared structurally here rather than imported from `@humanwhocodes/momoa`,
+ * which is only a transitive dependency of `@eslint/json`. A type-only import would leak into the
+ * published declarations and force every consumer to resolve a package it never installed.
+ */
+import type { ESLint, Rule } from 'eslint';
+/**
+ * The Momoa node type of a JSON boolean value.
+ */
+export declare const JSON_NODE_TYPE_BOOLEAN = "Boolean";
+/**
+ * The Momoa node type of a JSON object value.
+ */
+export declare const JSON_NODE_TYPE_OBJECT = "Object";
+/**
+ * The Momoa node type of a JSON string value.
+ */
+export declare const JSON_NODE_TYPE_STRING = "String";
+/**
+ * `@eslint/json`, typed as the plugin type a flat config and `RuleTester` are written against.
+ *
+ * The package's rule definitions are generic over its own JSON language, which `@types/eslint`'s
+ * `ESLint.Plugin` - written against ESTree rules - cannot express, so the two are nominally incompatible
+ * while being exactly compatible at runtime. Registering it is what makes `language: 'json/json'`
+ * resolvable, so there is no way to avoid the bridge.
+ */
+export declare const jsonPlugin: ESLint.Plugin;
+/**
+ * The `version` a plugin repo carries before its first release, when `minAppVersion` is legitimately absent.
+ */
+export declare const UNRELEASED_VERSION = "0.0.0";
+/**
+ * The root node of a parsed JSON document.
+ */
+export interface JsonDocumentNode extends JsonNode {
+    /**
+     * The document's single top-level value.
+     */
+    readonly body: JsonNode;
+}
+/**
+ * A JSON literal - a string, number, boolean or null.
+ */
+export interface JsonLiteralNode extends JsonNode {
+    /**
+     * The literal's parsed value.
+     */
+    readonly value: boolean | null | number | string;
+}
+/**
+ * A single `"key": value` pair of a JSON object.
+ */
+export interface JsonMemberNode extends JsonNode {
+    /**
+     * The member's key.
+     */
+    readonly name: JsonLiteralNode;
+    /**
+     * The member's value.
+     */
+    readonly value: JsonNode;
+}
+/**
+ * Any node of the Momoa JSON AST.
+ */
+export interface JsonNode {
+    /**
+     * The node type, e.g. `Document`, `Object`, `Member`, `String`.
+     */
+    readonly type: string;
+}
+/**
+ * A JSON object value.
+ */
+export interface JsonObjectNode extends JsonNode {
+    /**
+     * The object's members, in source order, including any duplicate keys.
+     */
+    readonly members: readonly JsonMemberNode[];
+}
+/**
+ * Finds a top-level member of the manifest by key.
+ *
+ * @param manifestObject - The manifest's root object node.
+ * @param key - The key to look for.
+ * @returns The first member with that key, or `null` when the manifest has none.
+ */
+export declare function findManifestMember(manifestObject: JsonObjectNode, key: string): JsonMemberNode | null;
+/**
+ * Reads the manifest's root object out of the visited `Document` node.
+ *
+ * @param node - The `Document` node handed to the rule's visitor.
+ * @returns The root object node, or `null` when the document's top-level value is not an object.
+ */
+export declare function getManifestObject(node: unknown): JsonObjectNode | null;
+/**
+ * Reads the value of a top-level string member of the manifest.
+ *
+ * @param manifestObject - The manifest's root object node.
+ * @param key - The key to look for.
+ * @returns The member's value, or `null` when it is absent or not a string.
+ */
+export declare function getManifestStringValue(manifestObject: JsonObjectNode, key: string): null | string;
+/**
+ * Reads a member's key.
+ *
+ * Under the `json/json` language a member's name is always a string node - identifier keys exist only in
+ * JSON5 - so this never has to account for a missing key.
+ *
+ * @param member - The member to read.
+ * @returns The member's key.
+ */
+export declare function getMemberKey(member: JsonMemberNode): string;
+/**
+ * Reads the value of a Momoa string node.
+ *
+ * @param node - The node to read.
+ * @returns The string value, or `null` when the node is not a string.
+ */
+export declare function getStringValue(node: JsonNode): null | string;
+/**
+ * Bridges a Momoa node to the node type `context.report()` is typed against.
+ *
+ * The two are structurally incompatible - ESLint's rule types describe ESTree - but the `json/json`
+ * language's source code adapter resolves a Momoa node's position at report time, so they are compatible
+ * at runtime. This mirrors the bridge `rule-tester-helper.ts` makes over the same kind of type-level gap.
+ *
+ * @param node - The Momoa node to report on.
+ * @returns The same node, typed for `context.report()`.
+ */
+export declare function toReportNode(node: unknown): Rule.Node;

package/dist/lib/esm/script-utils/linters/eslint-rules/manifest-helpers.mjs

@@ -0,0 +1,92 @@
+/*
+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 ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    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() {
+  ensureBrowserProcess();
+})();
+})();
+
+import json from "@eslint/json";
+const JSON_NODE_TYPE_BOOLEAN = "Boolean";
+const JSON_NODE_TYPE_OBJECT = "Object";
+const JSON_NODE_TYPE_STRING = "String";
+const jsonPlugin = bridgeJsonPlugin();
+const UNRELEASED_VERSION = "0.0.0";
+function findManifestMember(manifestObject, key) {
+  return manifestObject.members.find((member) => getMemberKey(member) === key) ?? null;
+}
+function getManifestObject(node) {
+  const document = node;
+  return document.body.type === JSON_NODE_TYPE_OBJECT ? document.body : null;
+}
+function getManifestStringValue(manifestObject, key) {
+  const member = findManifestMember(manifestObject, key);
+  return member ? getStringValue(member.value) : null;
+}
+function getMemberKey(member) {
+  return member.name.value;
+}
+function getStringValue(node) {
+  if (node.type !== JSON_NODE_TYPE_STRING) {
+    return null;
+  }
+  const literal = node;
+  return literal.value;
+}
+function toReportNode(node) {
+  const bridged = node;
+  return bridged;
+}
+function bridgeJsonPlugin() {
+  const bridged = json;
+  return bridged;
+}
+export {
+  JSON_NODE_TYPE_BOOLEAN,
+  JSON_NODE_TYPE_OBJECT,
+  JSON_NODE_TYPE_STRING,
+  UNRELEASED_VERSION,
+  findManifestMember,
+  getManifestObject,
+  getManifestStringValue,
+  getMemberKey,
+  getStringValue,
+  jsonPlugin,
+  toReportNode
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../../src/script-utils/linters/eslint-rules/manifest-helpers.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Shared helpers for the `manifest.json` ESLint rules.\n *\n * The manifest is linted through `@eslint/json`'s `json/json` language, whose AST is Momoa\n * (`Document` -> `Object` -> `Member`) rather than ESTree, so these rules visit `Document` instead of\n * `Program`. That difference is exactly why `obsidianmd/validate-manifest` can never fire: it registers a\n * `Program` visitor and expects an ESTree `ObjectExpression`, which no shipped JSON parser produces.\n *\n * The Momoa node shapes are declared structurally here rather than imported from `@humanwhocodes/momoa`,\n * which is only a transitive dependency of `@eslint/json`. A type-only import would leak into the\n * published declarations and force every consumer to resolve a package it never installed.\n */\n\nimport type {\n  ESLint,\n  Rule\n} from 'eslint';\n\n// eslint-disable-next-line import-x/no-rename-default -- The default export name `plugin` is too confusing.\nimport json from '@eslint/json';\n\n/**\n * The Momoa node type of a JSON boolean value.\n */\nexport const JSON_NODE_TYPE_BOOLEAN = 'Boolean';\n\n/**\n * The Momoa node type of a JSON object value.\n */\nexport const JSON_NODE_TYPE_OBJECT = 'Object';\n\n/**\n * The Momoa node type of a JSON string value.\n */\nexport const JSON_NODE_TYPE_STRING = 'String';\n\n/**\n * `@eslint/json`, typed as the plugin type a flat config and `RuleTester` are written against.\n *\n * The package's rule definitions are generic over its own JSON language, which `@types/eslint`'s\n * `ESLint.Plugin` - written against ESTree rules - cannot express, so the two are nominally incompatible\n * while being exactly compatible at runtime. Registering it is what makes `language: 'json/json'`\n * resolvable, so there is no way to avoid the bridge.\n */\nexport const jsonPlugin: ESLint.Plugin = bridgeJsonPlugin();\n\n/**\n * The `version` a plugin repo carries before its first release, when `minAppVersion` is legitimately absent.\n */\nexport const UNRELEASED_VERSION = '0.0.0';\n\n/**\n * The root node of a parsed JSON document.\n */\nexport interface JsonDocumentNode extends JsonNode {\n  /**\n   * The document's single top-level value.\n   */\n  readonly body: JsonNode;\n}\n\n/**\n * A JSON literal - a string, number, boolean or null.\n */\nexport interface JsonLiteralNode extends JsonNode {\n  /**\n   * The literal's parsed value.\n   */\n  readonly value: boolean | null | number | string;\n}\n\n/**\n * A single `\"key\": value` pair of a JSON object.\n */\nexport interface JsonMemberNode extends JsonNode {\n  /**\n   * The member's key.\n   */\n  readonly name: JsonLiteralNode;\n\n  /**\n   * The member's value.\n   */\n  readonly value: JsonNode;\n}\n\n/**\n * Any node of the Momoa JSON AST.\n */\nexport interface JsonNode {\n  /**\n   * The node type, e.g. `Document`, `Object`, `Member`, `String`.\n   */\n  readonly type: string;\n}\n\n/**\n * A JSON object value.\n */\nexport interface JsonObjectNode extends JsonNode {\n  /**\n   * The object's members, in source order, including any duplicate keys.\n   */\n  readonly members: readonly JsonMemberNode[];\n}\n\n/**\n * Finds a top-level member of the manifest by key.\n *\n * @param manifestObject - The manifest's root object node.\n * @param key - The key to look for.\n * @returns The first member with that key, or `null` when the manifest has none.\n */\nexport function findManifestMember(manifestObject: JsonObjectNode, key: string): JsonMemberNode | null {\n  return manifestObject.members.find((member) => getMemberKey(member) === key) ?? null;\n}\n\n/**\n * Reads the manifest's root object out of the visited `Document` node.\n *\n * @param node - The `Document` node handed to the rule's visitor.\n * @returns The root object node, or `null` when the document's top-level value is not an object.\n */\nexport function getManifestObject(node: unknown): JsonObjectNode | null {\n  const document = node as JsonDocumentNode;\n  return document.body.type === JSON_NODE_TYPE_OBJECT ? document.body as JsonObjectNode : null;\n}\n\n/**\n * Reads the value of a top-level string member of the manifest.\n *\n * @param manifestObject - The manifest's root object node.\n * @param key - The key to look for.\n * @returns The member's value, or `null` when it is absent or not a string.\n */\nexport function getManifestStringValue(manifestObject: JsonObjectNode, key: string): null | string {\n  const member = findManifestMember(manifestObject, key);\n  return member ? getStringValue(member.value) : null;\n}\n\n/**\n * Reads a member's key.\n *\n * Under the `json/json` language a member's name is always a string node - identifier keys exist only in\n * JSON5 - so this never has to account for a missing key.\n *\n * @param member - The member to read.\n * @returns The member's key.\n */\nexport function getMemberKey(member: JsonMemberNode): string {\n  return member.name.value as string;\n}\n\n/**\n * Reads the value of a Momoa string node.\n *\n * @param node - The node to read.\n * @returns The string value, or `null` when the node is not a string.\n */\nexport function getStringValue(node: JsonNode): null | string {\n  if (node.type !== JSON_NODE_TYPE_STRING) {\n    return null;\n  }\n\n  const literal = node as JsonLiteralNode;\n  return literal.value as string;\n}\n\n/**\n * Bridges a Momoa node to the node type `context.report()` is typed against.\n *\n * The two are structurally incompatible - ESLint's rule types describe ESTree - but the `json/json`\n * language's source code adapter resolves a Momoa node's position at report time, so they are compatible\n * at runtime. This mirrors the bridge `rule-tester-helper.ts` makes over the same kind of type-level gap.\n *\n * @param node - The Momoa node to report on.\n * @returns The same node, typed for `context.report()`.\n */\nexport function toReportNode(node: unknown): Rule.Node {\n  const bridged: unknown = node;\n  return bridged as Rule.Node;\n}\n\n/**\n * Casts `@eslint/json` to the plugin type `@types/eslint` declares.\n *\n * @returns The `@eslint/json` plugin, typed for a flat config.\n */\nfunction bridgeJsonPlugin(): ESLint.Plugin {\n  const bridged: unknown = json;\n  return bridged as ESLint.Plugin;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqBA,OAAO,UAAU;AAKV,MAAM,yBAAyB;AAK/B,MAAM,wBAAwB;AAK9B,MAAM,wBAAwB;AAU9B,MAAM,aAA4B,iBAAiB;AAKnD,MAAM,qBAAqB;AAgE3B,SAAS,mBAAmB,gBAAgC,KAAoC;AACrG,SAAO,eAAe,QAAQ,KAAK,CAAC,WAAW,aAAa,MAAM,MAAM,GAAG,KAAK;AAClF;AAQO,SAAS,kBAAkB,MAAsC;AACtE,QAAM,WAAW;AACjB,SAAO,SAAS,KAAK,SAAS,wBAAwB,SAAS,OAAyB;AAC1F;AASO,SAAS,uBAAuB,gBAAgC,KAA4B;AACjG,QAAM,SAAS,mBAAmB,gBAAgB,GAAG;AACrD,SAAO,SAAS,eAAe,OAAO,KAAK,IAAI;AACjD;AAWO,SAAS,aAAa,QAAgC;AAC3D,SAAO,OAAO,KAAK;AACrB;AAQO,SAAS,eAAe,MAA+B;AAC5D,MAAI,KAAK,SAAS,uBAAuB;AACvC,WAAO;AAAA,EACT;AAEA,QAAM,UAAU;AAChB,SAAO,QAAQ;AACjB;AAYO,SAAS,aAAa,MAA0B;AACrD,QAAM,UAAmB;AACzB,SAAO;AACT;AAOA,SAAS,mBAAkC;AACzC,QAAM,UAAmB;AACzB,SAAO;AACT;",
  "names": []
}


package/dist/lib/esm/script-utils/linters/eslint-rules/manifest-id.d.mts

@@ -0,0 +1,32 @@
+/// <reference path="../../../library.d.mts" />
+/**
+ * @file
+ *
+ * ESLint rule: manifest-id
+ *
+ * Enforces the Community directory's constraints on a plugin's `manifest.json` `id`: lowercase letters,
+ * digits and hyphens only; never containing `obsidian`; never ending with `plugin`.
+ *
+ * A published id can never be changed, so a violation in an already-listed plugin is permanent and the
+ * only remedy is turning this rule off for that repo with the reason written beside it.
+ *
+ * Runs on the `@eslint/json` `json/json` language; see `manifest-helpers.ts` for why the AST is Momoa
+ * rather than ESTree.
+ */
+import type { Rule } from 'eslint';
+/**
+Message ID reported when the id contains `obsidian`.
+ */
+export declare const MESSAGE_ID_CONTAINS_OBSIDIAN = "idContainsObsidian";
+/**
+Message ID reported when the id ends with `plugin`.
+ */
+export declare const MESSAGE_ID_ENDS_WITH_PLUGIN = "idEndsWithPlugin";
+/**
+Message ID reported when the id holds characters other than lowercase letters, digits and hyphens.
+ */
+export declare const MESSAGE_ID_INVALID_CHARACTERS = "idInvalidCharacters";
+/**
+ * ESLint rule enforcing the Community directory's constraints on a plugin's `manifest.json` `id`.
+ */
+export declare const manifestId: Rule.RuleModule;

package/dist/lib/esm/script-utils/linters/eslint-rules/manifest-id.mjs

@@ -0,0 +1,111 @@
+/*
+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 ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    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() {
+  ensureBrowserProcess();
+})();
+})();
+
+import {
+  findManifestMember,
+  getManifestObject,
+  getStringValue,
+  toReportNode
+} from "./manifest-helpers.mjs";
+const MESSAGE_ID_CONTAINS_OBSIDIAN = "idContainsObsidian";
+const MESSAGE_ID_ENDS_WITH_PLUGIN = "idEndsWithPlugin";
+const MESSAGE_ID_INVALID_CHARACTERS = "idInvalidCharacters";
+const ALLOWED_ID_CHARACTERS = /^[a-z0-9-]+$/;
+const manifestId = {
+  create(context) {
+    return {
+      Document(node) {
+        const manifestObject = getManifestObject(node);
+        if (!manifestObject) {
+          return;
+        }
+        const member = findManifestMember(manifestObject, "id");
+        if (!member) {
+          return;
+        }
+        const id = getStringValue(member.value);
+        if (id === null) {
+          return;
+        }
+        const reportNode = toReportNode(member.value);
+        if (!ALLOWED_ID_CHARACTERS.test(id)) {
+          context.report({
+            messageId: MESSAGE_ID_INVALID_CHARACTERS,
+            node: reportNode
+          });
+        }
+        if (id.toLowerCase().includes("obsidian")) {
+          context.report({
+            messageId: MESSAGE_ID_CONTAINS_OBSIDIAN,
+            node: reportNode
+          });
+        }
+        if (id.toLowerCase().endsWith("plugin")) {
+          context.report({
+            messageId: MESSAGE_ID_ENDS_WITH_PLUGIN,
+            node: reportNode
+          });
+        }
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Enforce the Community directory's constraints on a plugin's `manifest.json` `id`"
+    },
+    messages: {
+      [MESSAGE_ID_CONTAINS_OBSIDIAN]: "The `id` must not contain `obsidian`. It is implied by the context of the plugin directory.",
+      [MESSAGE_ID_ENDS_WITH_PLUGIN]: "The `id` must not end with `plugin`.",
+      [MESSAGE_ID_INVALID_CHARACTERS]: "The `id` must contain only lowercase letters, digits and hyphens."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+export {
+  MESSAGE_ID_CONTAINS_OBSIDIAN,
+  MESSAGE_ID_ENDS_WITH_PLUGIN,
+  MESSAGE_ID_INVALID_CHARACTERS,
+  manifestId
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/script-utils/linters/eslint-rules/manifest-name.d.mts

@@ -0,0 +1,30 @@
+/// <reference path="../../../library.d.mts" />
+/**
+ * @file
+ *
+ * ESLint rule: manifest-name
+ *
+ * Enforces the Community directory's constraints on a plugin's `manifest.json` `name`: no `Obsidian` or
+ * its variants, no `Plugin`, and Basic Latin only with hyphens, plus signs and parentheses the sole
+ * permitted punctuation.
+ *
+ * Runs on the `@eslint/json` `json/json` language; see `manifest-helpers.ts` for why the AST is Momoa
+ * rather than ESTree.
+ */
+import type { Rule } from 'eslint';
+/**
+Message ID reported when the name contains `Obsidian` or one of its variants.
+ */
+export declare const MESSAGE_ID_CONTAINS_OBSIDIAN = "nameContainsObsidian";
+/**
+Message ID reported when the name contains `Plugin`.
+ */
+export declare const MESSAGE_ID_CONTAINS_PLUGIN = "nameContainsPlugin";
+/**
+Message ID reported when the name holds a character outside Basic Latin, or punctuation the directory rejects.
+ */
+export declare const MESSAGE_ID_INVALID_CHARACTERS = "nameInvalidCharacters";
+/**
+ * ESLint rule enforcing the Community directory's constraints on a plugin's `manifest.json` `name`.
+ */
+export declare const manifestName: Rule.RuleModule;