@codeperfect/eslint-plugin 1.0.0 → 2.1.0

package/dist/domain/docs/no-interface-member-docs/test-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-helpers.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/test-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAInC,qCAAqC;AACrC,KAAK,OAAO,GAAG,UAAU,CACvB,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC,gBAAgB,CAAC,CACjD,CAAC,MAAM,CAAC,CAAC;AAEV,qCAAqC;AACrC,UAAU,eAAe;IACvB,2BAA2B;IAC3B,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC;IAE1B,wBAAwB;IACxB,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC;IAEhB,2BAA2B;IAC3B,OAAO,EAAE,WAAW,EAAE,CAAC;IAEvB,8BAA8B;IAC9B,UAAU,EAAE,MAAM,CAAC;CACpB;AAWD,qCAAqC;AACrC,UAAU,WAAW;IACnB,wBAAwB;IACxB,GAAG,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC,WAAW,GAAG,SAAS,CAAC;IAE1C,8BAA8B;IAC9B,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B;AAED,qCAAqC;AACrC,UAAU,gBAAgB;IACxB,2BAA2B;IAC3B,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC;IAE1B,2BAA2B;IAC3B,OAAO,EAAE,WAAW,EAAE,CAAC;CACxB;AA+CD;;;;;;;;;GASG;AACH,QAAA,MAAM,aAAa,GACjB,YAAY,MAAM,EAClB,UAAU,OAAO,EAAE,KAClB,gBAKF,CAAC;AAEF;;;;;;;;;GASG;AACH,QAAA,MAAM,aAAa,GAAI,cAAc,MAAM,EAAE,YAAY,MAAM,KAAG,OAQjE,CAAC;AAEF;;;;;;;;;GASG;AACH,QAAA,MAAM,kBAAkB,GACtB,YAAY,MAAM,EAClB,YAAY,OAAO,EAAE,KACpB,IAAI,CAAC,IAKS,CAAC;AAElB;;;;;;;;GAQG;AACH,QAAA,MAAM,eAAe,GAAI,MAAM,MAAM,KAAG,OAMtC,CAAC;AAEH;;;;;;;;GAQG;AACH,QAAA,MAAM,mBAAmB,GACvB,SAAS,IAAI,CAAC,WAAW,EACzB,MAAM,IAAI,CAAC,IAAI,KACd,IAOF,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,eAAe,GAAI,cAAc,MAAM,KAAG,MAMlC,CAAC;AAEf;;;;;;;GAOG;AACH,QAAA,MAAM,qBAAqB,QAAO,eAmBjC,CAAC;AAEF,OAAO,EACL,eAAe,EACf,aAAa,EACb,aAAa,EACb,kBAAkB,EAClB,qBAAqB,EACrB,eAAe,EACf,mBAAmB,GACpB,CAAC;AACF,YAAY,EAAE,OAAO,EAAE,CAAC"}

package/dist/{docs → domain/docs}/no-interface-member-docs/test-helpers.js

@@ -1,4 +1,4 @@
-import { noInterfaceMemberDocumentationRule } from "./rule";
+import { noInterfaceMemberDocumentationRule } from "./rule.js";
 /**
  * Creates a SourceCode stub with the provided comments.
  * @param text Source text to attach.
@@ -154,4 +154,4 @@ const createInterfaceSample = () => {
     return { context, node, reports, sourceText };
 };
 export { buildSourceText, createComment, createContext, createFunctionNode, createInterfaceSample, createParameter, runFunctionListener, };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-helpers.js","sourceRoot":"","sources":["../../../src/docs/no-interface-member-docs/test-helpers.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kCAAkC,EAAE,MAAM,QAAQ,CAAC;AAiD5D;;;;;;;;;GASG;AACH,MAAM,gBAAgB,GAAG,CACvB,IAAY,EACZ,QAAmB,EACa,EAAE,CAClC,CAAC;IACC,cAAc,EAAE,GAAc,EAAE,CAAC,QAAQ;IACzC,IAAI;CACL,CAAmC,CAAC;AAEvC;;;;;;;;;GASG;AACH,MAAM,gBAAgB,GAAG,CACvB,UAA0C,EAC1C,OAAsB,EACJ,EAAE,CACpB,CAAC;IACC,EAAE,EAAE,0BAA0B;IAC9B,OAAO,EAAE,EAAE;IACX,MAAM,EAAE,CAAC,UAAiC,EAAQ,EAAE;QAClD,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,UAAqC,CAAC;QACjE,MAAM,KAAK,GAAgB,EAAE,GAAG,EAAE,SAAS,EAAE,CAAC;QAE9C,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACtB,CAAC;IACD,UAAU;CACX,CAAgC,CAAC;AAEpC;;;;;;;;;GASG;AACH,MAAM,aAAa,GAAG,CACpB,UAAkB,EAClB,QAAmB,EACD,EAAE;IACpB,MAAM,OAAO,GAAkB,EAAE,CAAC;IAClC,MAAM,UAAU,GAAG,gBAAgB,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;IAE1D,OAAO,EAAE,OAAO,EAAE,gBAAgB,CAAC,UAAU,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,CAAC;AACrE,CAAC,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,aAAa,GAAG,CAAC,YAAoB,EAAE,UAAkB,EAAW,EAAE;IAC1E,MAAM,GAAG,GAAG,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAEzC,OAAO;QACL,KAAK,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC;QACf,IAAI,EAAE,OAAO;QACb,KAAK,EAAE,YAAY;KACT,CAAC;AACf,CAAC,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,kBAAkB,GAAG,CACzB,UAAkB,EAClB,UAAqB,EACV,EAAE,CACb,CAAC;IACC,MAAM,EAAE,UAAU;IAClB,KAAK,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC;IAC1D,IAAI,EAAE,qBAAqB;CAC5B,CAAc,CAAC;AAElB;;;;;;;;GAQG;AACH,MAAM,eAAe,GAAG,CAAC,IAAY,EAAW,EAAE,CAAC,CAAC;IAClD,IAAI,EAAE,SAAS;IACf,IAAI,EAAE,YAAY;IAClB,cAAc,EAAE;QACd,cAAc,EAAE,EAAE,IAAI,EAAE;KACzB;CACF,CAAC,CAAC;AAEH;;;;;;;;GAQG;AACH,MAAM,mBAAmB,GAAG,CAC1B,OAAyB,EACzB,IAAe,EACT,EAAE;IACR,MAAM,SAAS,GAAG,kCAAkC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACrE,MAAM,QAAQ,GAAG,SAAS,CAAC,mBAEd,CAAC;IAEd,QAAQ,EAAE,CAAC,IAAI,CAAC,CAAC;AACnB,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,eAAe,GAAG,CAAC,YAAoB,EAAU,EAAE,CACvD;IACE,KAAK;IACL,YAAY,CAAC,OAAO,EAAE;IACtB,IAAI;IACJ,yDAAyD;CAC1D,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAEf;;;;;;;GAOG;AACH,MAAM,qBAAqB,GAAG,GAAoB,EAAE;IAClD,MAAM,YAAY,GAAG;QACnB,GAAG;QACH,sDAAsD;QACtD,yCAAyC;QACzC,wDAAwD;QACxD,uDAAuD;QACvD,uDAAuD;QACvD,gDAAgD;QAChD,GAAG;KACJ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACb,MAAM,UAAU,GAAG,eAAe,CAAC,YAAY,CAAC,CAAC;IACjD,MAAM,OAAO,GAAG,aAAa,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;IACxD,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,aAAa,CAAC,UAAU,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;IAClE,MAAM,IAAI,GAAG,kBAAkB,CAAC,UAAU,EAAE;QAC1C,eAAe,CAAC,iBAAiB,CAAC;KACnC,CAAC,CAAC;IAEH,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC;AAChD,CAAC,CAAC;AAEF,OAAO,EACL,eAAe,EACf,aAAa,EACb,aAAa,EACb,kBAAkB,EAClB,qBAAqB,EACrB,eAAe,EACf,mBAAmB,GACpB,CAAC","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport { noInterfaceMemberDocumentationRule } from \"./rule\";\n\n/** Type definition for rule data. */\ntype Comment = ReturnType<\n  Rule.RuleContext[\"sourceCode\"][\"getAllComments\"]\n>[number];\n\n/** Type definition for rule data. */\ninterface InterfaceSample {\n  /** Context field value. */\n  context: Rule.RuleContext;\n\n  /** Node field value. */\n  node: Rule.Node;\n\n  /** Reports field value. */\n  reports: ReportEntry[];\n\n  /** SourceText field value. */\n  sourceText: string;\n}\n\n/** Type definition for rule data. */\ninterface ReportDescriptorDetails {\n  /** Fix field value. */\n  fix?: null | Rule.ReportFixer | undefined;\n\n  /** MessageId field value. */\n  messageId?: string;\n}\n\n/** Type definition for rule data. */\ninterface ReportEntry {\n  /** Fix helper value. */\n  fix?: null | Rule.ReportFixer | undefined;\n\n  /** MessageId helper value. */\n  messageId: string | undefined;\n}\n\n/** Type definition for rule data. */\ninterface RuleContextState {\n  /** Context field value. */\n  context: Rule.RuleContext;\n\n  /** Reports field value. */\n  reports: ReportEntry[];\n}\n\n/**\n * Creates a SourceCode stub with the provided comments.\n * @param text Source text to attach.\n * @param comments Comment nodes to expose.\n * @returns SourceCode stub for tests.\n * @example\n * ```typescript\n * const sourceCode = createSourceCode(\"\", []);\n * ```\n */\nconst createSourceCode = (\n  text: string,\n  comments: Comment[],\n): Rule.RuleContext[\"sourceCode\"] =>\n  ({\n    getAllComments: (): Comment[] => comments,\n    text,\n  }) as Rule.RuleContext[\"sourceCode\"];\n\n/**\n * Builds a rule context for collecting reports.\n * @param sourceCode SourceCode stub.\n * @param reports Report sink.\n * @returns Rule context that records reports.\n * @example\n * ```typescript\n * const context = buildRuleContext(sourceCode, reports);\n * ```\n */\nconst buildRuleContext = (\n  sourceCode: Rule.RuleContext[\"sourceCode\"],\n  reports: ReportEntry[],\n): Rule.RuleContext =>\n  ({\n    id: \"no-interface-member-docs\",\n    options: [],\n    report: (descriptor: Rule.ReportDescriptor): void => {\n      const { fix, messageId } = descriptor as ReportDescriptorDetails;\n      const entry: ReportEntry = { fix, messageId };\n\n      reports.push(entry);\n    },\n    sourceCode,\n  }) as unknown as Rule.RuleContext;\n\n/**\n * Creates a rule context state for the given source text.\n * @param sourceText Source text to analyze.\n * @param comments Comment nodes for the source.\n * @returns Context state for tests.\n * @example\n * ```typescript\n * const state = createContext(\"\", []);\n * ```\n */\nconst createContext = (\n  sourceText: string,\n  comments: Comment[],\n): RuleContextState => {\n  const reports: ReportEntry[] = [];\n  const sourceCode = createSourceCode(sourceText, comments);\n\n  return { context: buildRuleContext(sourceCode, reports), reports };\n};\n\n/**\n * Creates a JSDoc block comment for the given source text.\n * @param commentValue Comment value without delimiters.\n * @param sourceText Source text containing the comment.\n * @returns Comment node for the source text.\n * @example\n * ```typescript\n * const comment = createComment(\"*\\n * ok\\n \", \"function demo() {}\");\n * ```\n */\nconst createComment = (commentValue: string, sourceText: string): Comment => {\n  const end = sourceText.indexOf(\"*/\") + 2;\n\n  return {\n    range: [0, end],\n    type: \"Block\",\n    value: commentValue,\n  } as Comment;\n};\n\n/**\n * Creates a function node for the given source text.\n * @param sourceText Source text containing the function.\n * @param parameters Parameter nodes for the function.\n * @returns Function declaration node.\n * @example\n * ```typescript\n * const node = createFunctionNode(\"function demo() {}\", []);\n * ```\n */\nconst createFunctionNode = (\n  sourceText: string,\n  parameters: unknown[],\n): Rule.Node =>\n  ({\n    params: parameters,\n    range: [sourceText.indexOf(\"function\"), sourceText.length],\n    type: \"FunctionDeclaration\",\n  }) as Rule.Node;\n\n/**\n * Creates a parameter node with a type annotation.\n * @param type Type annotation kind to assign.\n * @returns Parameter node for tests.\n * @example\n * ```typescript\n * const param = createParameter(\"TSTypeReference\");\n * ```\n */\nconst createParameter = (type: string): unknown => ({\n  name: \"context\",\n  type: \"Identifier\",\n  typeAnnotation: {\n    typeAnnotation: { type },\n  },\n});\n\n/**\n * Runs the rule listener for a function declaration node.\n * @param context Rule execution context.\n * @param node Function node to inspect.\n * @example\n * ```typescript\n * runFunctionListener(context, node);\n * ```\n */\nconst runFunctionListener = (\n  context: Rule.RuleContext,\n  node: Rule.Node,\n): void => {\n  const listeners = noInterfaceMemberDocumentationRule.create(context);\n  const listener = listeners.FunctionDeclaration as\n    | ((node: Rule.Node) => void)\n    | undefined;\n\n  listener?.(node);\n};\n\n/**\n * Builds source text with a leading JSDoc comment.\n * @param commentValue Comment value used in the source.\n * @returns Source text containing the comment and function.\n * @example\n * ```typescript\n * const text = buildSourceText(\"*\\n * ok\\n \");\n * ```\n */\nconst buildSourceText = (commentValue: string): string =>\n  [\n    \"/**\",\n    commentValue.trimEnd(),\n    \"*/\",\n    \"function getLineMeta(context: LineMetaContext): void {}\",\n  ].join(\"\\n\");\n\n/**\n * Creates a sample test fixture for interface member docs.\n * @returns Sample context, node, and reports.\n * @example\n * ```typescript\n * const sample = createInterfaceSample();\n * ```\n */\nconst createInterfaceSample = (): InterfaceSample => {\n  const commentValue = [\n    \"*\",\n    \" * Compute line metadata from the raw comment value.\",\n    \" * @param context The metadata context.\",\n    \" * @param context.commentValue The full comment value.\",\n    \" * @param context.full The full matched example text.\",\n    \" * @param context.startOffset The match start offset.\",\n    \" * @returns The line metadata for the example.\",\n    \" \",\n  ].join(\"\\n\");\n  const sourceText = buildSourceText(commentValue);\n  const comment = createComment(commentValue, sourceText);\n  const { context, reports } = createContext(sourceText, [comment]);\n  const node = createFunctionNode(sourceText, [\n    createParameter(\"TSTypeReference\"),\n  ]);\n\n  return { context, node, reports, sourceText };\n};\n\nexport {\n  buildSourceText,\n  createComment,\n  createContext,\n  createFunctionNode,\n  createInterfaceSample,\n  createParameter,\n  runFunctionListener,\n};\nexport type { Comment };\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-helpers.js","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/test-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport { noInterfaceMemberDocumentationRule } from \"./rule\";\n\n/** Type definition for rule data. */\ntype Comment = ReturnType<\n  Rule.RuleContext[\"sourceCode\"][\"getAllComments\"]\n>[number];\n\n/** Type definition for rule data. */\ninterface InterfaceSample {\n  /** Context field value. */\n  context: Rule.RuleContext;\n\n  /** Node field value. */\n  node: Rule.Node;\n\n  /** Reports field value. */\n  reports: ReportEntry[];\n\n  /** SourceText field value. */\n  sourceText: string;\n}\n\n/** Type definition for rule data. */\ninterface ReportDescriptorDetails {\n  /** Fix field value. */\n  fix?: null | Rule.ReportFixer | undefined;\n\n  /** MessageId field value. */\n  messageId?: string;\n}\n\n/** Type definition for rule data. */\ninterface ReportEntry {\n  /** Fix helper value. */\n  fix?: null | Rule.ReportFixer | undefined;\n\n  /** MessageId helper value. */\n  messageId: string | undefined;\n}\n\n/** Type definition for rule data. */\ninterface RuleContextState {\n  /** Context field value. */\n  context: Rule.RuleContext;\n\n  /** Reports field value. */\n  reports: ReportEntry[];\n}\n\n/**\n * Creates a SourceCode stub with the provided comments.\n * @param text Source text to attach.\n * @param comments Comment nodes to expose.\n * @returns SourceCode stub for tests.\n * @example\n * ```typescript\n * const sourceCode = createSourceCode(\"\", []);\n * ```\n */\nconst createSourceCode = (\n  text: string,\n  comments: Comment[],\n): Rule.RuleContext[\"sourceCode\"] =>\n  ({\n    getAllComments: (): Comment[] => comments,\n    text,\n  }) as Rule.RuleContext[\"sourceCode\"];\n\n/**\n * Builds a rule context for collecting reports.\n * @param sourceCode SourceCode stub.\n * @param reports Report sink.\n * @returns Rule context that records reports.\n * @example\n * ```typescript\n * const context = buildRuleContext(sourceCode, reports);\n * ```\n */\nconst buildRuleContext = (\n  sourceCode: Rule.RuleContext[\"sourceCode\"],\n  reports: ReportEntry[],\n): Rule.RuleContext =>\n  ({\n    id: \"no-interface-member-docs\",\n    options: [],\n    report: (descriptor: Rule.ReportDescriptor): void => {\n      const { fix, messageId } = descriptor as ReportDescriptorDetails;\n      const entry: ReportEntry = { fix, messageId };\n\n      reports.push(entry);\n    },\n    sourceCode,\n  }) as unknown as Rule.RuleContext;\n\n/**\n * Creates a rule context state for the given source text.\n * @param sourceText Source text to analyze.\n * @param comments Comment nodes for the source.\n * @returns Context state for tests.\n * @example\n * ```typescript\n * const state = createContext(\"\", []);\n * ```\n */\nconst createContext = (\n  sourceText: string,\n  comments: Comment[],\n): RuleContextState => {\n  const reports: ReportEntry[] = [];\n  const sourceCode = createSourceCode(sourceText, comments);\n\n  return { context: buildRuleContext(sourceCode, reports), reports };\n};\n\n/**\n * Creates a JSDoc block comment for the given source text.\n * @param commentValue Comment value without delimiters.\n * @param sourceText Source text containing the comment.\n * @returns Comment node for the source text.\n * @example\n * ```typescript\n * const comment = createComment(\"*\\n * ok\\n \", \"function demo() {}\");\n * ```\n */\nconst createComment = (commentValue: string, sourceText: string): Comment => {\n  const end = sourceText.indexOf(\"*/\") + 2;\n\n  return {\n    range: [0, end],\n    type: \"Block\",\n    value: commentValue,\n  };\n};\n\n/**\n * Creates a function node for the given source text.\n * @param sourceText Source text containing the function.\n * @param parameters Parameter nodes for the function.\n * @returns Function declaration node.\n * @example\n * ```typescript\n * const node = createFunctionNode(\"function demo() {}\", []);\n * ```\n */\nconst createFunctionNode = (\n  sourceText: string,\n  parameters: unknown[],\n): Rule.Node =>\n  ({\n    params: parameters,\n    range: [sourceText.indexOf(\"function\"), sourceText.length],\n    type: \"FunctionDeclaration\",\n  }) as Rule.Node;\n\n/**\n * Creates a parameter node with a type annotation.\n * @param type Type annotation kind to assign.\n * @returns Parameter node for tests.\n * @example\n * ```typescript\n * const param = createParameter(\"TSTypeReference\");\n * ```\n */\nconst createParameter = (type: string): unknown => ({\n  name: \"context\",\n  type: \"Identifier\",\n  typeAnnotation: {\n    typeAnnotation: { type },\n  },\n});\n\n/**\n * Runs the rule listener for a function declaration node.\n * @param context Rule execution context.\n * @param node Function node to inspect.\n * @example\n * ```typescript\n * runFunctionListener(context, node);\n * ```\n */\nconst runFunctionListener = (\n  context: Rule.RuleContext,\n  node: Rule.Node,\n): void => {\n  const listeners = noInterfaceMemberDocumentationRule.create(context);\n  const listener = listeners.FunctionDeclaration as\n    | ((node: Rule.Node) => void)\n    | undefined;\n\n  listener?.(node);\n};\n\n/**\n * Builds source text with a leading JSDoc comment.\n * @param commentValue Comment value used in the source.\n * @returns Source text containing the comment and function.\n * @example\n * ```typescript\n * const text = buildSourceText(\"*\\n * ok\\n \");\n * ```\n */\nconst buildSourceText = (commentValue: string): string =>\n  [\n    \"/**\",\n    commentValue.trimEnd(),\n    \"*/\",\n    \"function getLineMeta(context: LineMetaContext): void {}\",\n  ].join(\"\\n\");\n\n/**\n * Creates a sample test fixture for interface member docs.\n * @returns Sample context, node, and reports.\n * @example\n * ```typescript\n * const sample = createInterfaceSample();\n * ```\n */\nconst createInterfaceSample = (): InterfaceSample => {\n  const commentValue = [\n    \"*\",\n    \" * Compute line metadata from the raw comment value.\",\n    \" * @param context The metadata context.\",\n    \" * @param context.commentValue The full comment value.\",\n    \" * @param context.full The full matched example text.\",\n    \" * @param context.startOffset The match start offset.\",\n    \" * @returns The line metadata for the example.\",\n    \" \",\n  ].join(\"\\n\");\n  const sourceText = buildSourceText(commentValue);\n  const comment = createComment(commentValue, sourceText);\n  const { context, reports } = createContext(sourceText, [comment]);\n  const node = createFunctionNode(sourceText, [\n    createParameter(\"TSTypeReference\"),\n  ]);\n\n  return { context, node, reports, sourceText };\n};\n\nexport {\n  buildSourceText,\n  createComment,\n  createContext,\n  createFunctionNode,\n  createInterfaceSample,\n  createParameter,\n  runFunctionListener,\n};\nexport type { Comment };\n"]}

package/dist/{docs → domain/docs}/no-interface-member-docs/types.d.ts

@@ -14,8 +14,8 @@ interface CommentLine {
 }
 /** Type definition for rule data. */
 interface ParameterMemberTag {
-    /** BaseName field value. */
-    baseName: string;
+    /** Basename field value. */
+    basename: string;
     /** FullName field value. */
     fullName: string;
     /** Line field value. */

package/dist/domain/docs/no-interface-member-docs/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,qCAAqC;AACrC,KAAK,OAAO,GAAG,UAAU,CACvB,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC,gBAAgB,CAAC,CACjD,CAAC,MAAM,CAAC,CAAC;AAEV,qCAAqC;AACrC,UAAU,WAAW;IACnB,uBAAuB;IACvB,GAAG,EAAE,MAAM,CAAC;IAEZ,mCAAmC;IACnC,eAAe,EAAE,MAAM,CAAC;IAExB,yBAAyB;IACzB,KAAK,EAAE,MAAM,CAAC;IAEd,wBAAwB;IACxB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,qCAAqC;AACrC,UAAU,kBAAkB;IAC1B,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IAEjB,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IAEjB,wBAAwB;IACxB,IAAI,EAAE,WAAW,CAAC;CACnB;AAED,qCAAqC;AACrC,UAAU,kBAAkB;IAC1B,wBAAwB;IACxB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,YAAY,EAAE,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/domain/docs/no-interface-member-docs/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZG9tYWluL2RvY3Mvbm8taW50ZXJmYWNlLW1lbWJlci1kb2NzL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFJ1bGUgfSBmcm9tIFwiZXNsaW50XCI7XG5cbi8qKiBUeXBlIGRlZmluaXRpb24gZm9yIHJ1bGUgZGF0YS4gKi9cbnR5cGUgQ29tbWVudCA9IFJldHVyblR5cGU8XG4gIFJ1bGUuUnVsZUNvbnRleHRbXCJzb3VyY2VDb2RlXCJdW1wiZ2V0QWxsQ29tbWVudHNcIl1cbj5bbnVtYmVyXTtcblxuLyoqIFR5cGUgZGVmaW5pdGlvbiBmb3IgcnVsZSBkYXRhLiAqL1xuaW50ZXJmYWNlIENvbW1lbnRMaW5lIHtcbiAgLyoqIEVuZCBmaWVsZCB2YWx1ZS4gKi9cbiAgZW5kOiBudW1iZXI7XG5cbiAgLyoqIExpbmVCcmVha0xlbmd0aCBmaWVsZCB2YWx1ZS4gKi9cbiAgbGluZUJyZWFrTGVuZ3RoOiBudW1iZXI7XG5cbiAgLyoqIFN0YXJ0IGZpZWxkIHZhbHVlLiAqL1xuICBzdGFydDogbnVtYmVyO1xuXG4gIC8qKiBUZXh0IGZpZWxkIHZhbHVlLiAqL1xuICB0ZXh0OiBzdHJpbmc7XG59XG5cbi8qKiBUeXBlIGRlZmluaXRpb24gZm9yIHJ1bGUgZGF0YS4gKi9cbmludGVyZmFjZSBQYXJhbWV0ZXJNZW1iZXJUYWcge1xuICAvKiogQmFzZW5hbWUgZmllbGQgdmFsdWUuICovXG4gIGJhc2VuYW1lOiBzdHJpbmc7XG5cbiAgLyoqIEZ1bGxOYW1lIGZpZWxkIHZhbHVlLiAqL1xuICBmdWxsTmFtZTogc3RyaW5nO1xuXG4gIC8qKiBMaW5lIGZpZWxkIHZhbHVlLiAqL1xuICBsaW5lOiBDb21tZW50TGluZTtcbn1cblxuLyoqIFR5cGUgZGVmaW5pdGlvbiBmb3IgcnVsZSBkYXRhLiAqL1xuaW50ZXJmYWNlIFR5cGVBbm5vdGF0aW9uTm9kZSB7XG4gIC8qKiBUeXBlIGZpZWxkIHZhbHVlLiAqL1xuICB0eXBlOiBzdHJpbmc7XG59XG5cbmV4cG9ydCB0eXBlIHsgQ29tbWVudCwgQ29tbWVudExpbmUsIFBhcmFtZXRlck1lbWJlclRhZywgVHlwZUFubm90YXRpb25Ob2RlIH07XG4iXX0=

package/dist/domain/docs/require-example-language/create-fixer.d.ts

@@ -0,0 +1,5 @@
+import { createFixer } from "./fixes.js";
+/** Companion module for createFixer-focused tests. */
+declare const createFixerCompanion: typeof createFixer;
+export { createFixerCompanion };
+//# sourceMappingURL=create-fixer.d.ts.map

package/dist/domain/docs/require-example-language/create-fixer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-fixer.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/require-example-language/create-fixer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEtC,sDAAsD;AACtD,QAAA,MAAM,oBAAoB,oBAAc,CAAC;AAEzC,OAAO,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/domain/docs/require-example-language/create-fixer.js

@@ -0,0 +1,5 @@
+import { createFixer } from "./fixes.js";
+/** Companion module for createFixer-focused tests. */
+const createFixerCompanion = createFixer;
+export { createFixerCompanion };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLWZpeGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2RvbWFpbi9kb2NzL3JlcXVpcmUtZXhhbXBsZS1sYW5ndWFnZS9jcmVhdGUtZml4ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUV0QyxzREFBc0Q7QUFDdEQsTUFBTSxvQkFBb0IsR0FBRyxXQUFXLENBQUM7QUFFekMsT0FBTyxFQUFFLG9CQUFvQixFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBjcmVhdGVGaXhlciB9IGZyb20gXCIuL2ZpeGVzXCI7XHJcblxyXG4vKiogQ29tcGFuaW9uIG1vZHVsZSBmb3IgY3JlYXRlRml4ZXItZm9jdXNlZCB0ZXN0cy4gKi9cclxuY29uc3QgY3JlYXRlRml4ZXJDb21wYW5pb24gPSBjcmVhdGVGaXhlcjtcclxuXHJcbmV4cG9ydCB7IGNyZWF0ZUZpeGVyQ29tcGFuaW9uIH07XHJcbiJdfQ==

package/dist/domain/docs/require-example-language/empty-fence-fixes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"empty-fence-fixes.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/require-example-language/empty-fence-fixes.ts"],"names":[],"mappings":"AAqBA,qCAAqC;AACrC,UAAU,aAAa;IACrB,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IAEjB,2BAA2B;IAC3B,OAAO,EAAE,MAAM,CAAC;CACjB;AAuFD;;;;;;;;GAQG;AACH,iBAAS,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAe/D;AAED;;;;;;;;GAQG;AACH,iBAAS,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CA0B/D;AAgDD,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/domain/docs/require-example-language/empty-fence-fixes.js

@@ -0,0 +1,169 @@
+/**
+ * Closes a fence and updates the state.
+ * @param state Current fence state.
+ * @param line Fence line being processed.
+ * @returns Updated fence state.
+ * @example
+ * ```typescript
+ * const next = closeFence(state, " * ```");
+ * ```
+ */
+function closeFence(state, line) {
+    const fenceLines = [...state.currentFence, line];
+    const shouldRemove = !state.hasFenceContent;
+    const hasNonEmptyFence = state.hasNonEmptyFence || state.hasFenceContent;
+    const output = shouldRemove ? state.output : [...state.output, ...fenceLines];
+    return {
+        ...state,
+        currentFence: [],
+        hasFenceContent: false,
+        hasNonEmptyFence,
+        inFence: false,
+        output,
+        removed: state.removed || shouldRemove,
+    };
+}
+/**
+ * Finalizes fence output, including any unclosed fences.
+ * @param state Current fence state.
+ * @returns Finalized fence state.
+ * @example
+ * ```typescript
+ * const next = finalizeFenceState(state);
+ * ```
+ */
+function finalizeFenceState(state) {
+    if (state.inFence) {
+        return {
+            ...state,
+            currentFence: [],
+            hasFenceContent: false,
+            hasNonEmptyFence: state.hasNonEmptyFence || state.hasFenceContent,
+            inFence: false,
+            output: [...state.output, ...state.currentFence],
+        };
+    }
+    return state;
+}
+/**
+ * Determines whether a line contains non-empty content.
+ * @param line Line text to check.
+ * @returns True when the line contains content.
+ * @example
+ * ```typescript
+ * const ok = isContentLine(" * const ok = true;");
+ * ```
+ */
+function isContentLine(line) {
+    const trimmed = line.replace(/^\s*\*?\s?/u, "").trim();
+    return trimmed.length > 0;
+}
+/**
+ * Opens a new fenced block.
+ * @param state Current fence state.
+ * @param line Fence line being processed.
+ * @returns Updated fence state.
+ * @example
+ * ```typescript
+ * const next = openFence(state, " * ```typescript");
+ * ```
+ */
+function openFence(state, line) {
+    return {
+        ...state,
+        currentFence: [line],
+        hasFenceContent: false,
+        hasNonEmptyFence: state.hasNonEmptyFence,
+        inFence: true,
+    };
+}
+/**
+ * Parses a fence line for its leading prefix and language.
+ * @param line Fence line to parse.
+ * @returns Parsed fence info when matched.
+ * @example
+ * ```typescript
+ * const info = parseFenceLine(" * ```typescript");
+ * ```
+ */
+function parseFenceLine(line) {
+    const fenceMatch = /^(?<leading>\s*\*?\s*)```(?<lang>[^\s`]+)?[ \t]*$/u.exec(line);
+    if (fenceMatch === null) {
+        return void 0;
+    }
+    const groups = fenceMatch.groups ?? {};
+    const leading = typeof groups["leading"] === "string" ? groups["leading"] : "";
+    const language = typeof groups["lang"] === "string" ? groups["lang"] : "";
+    return { language, leading };
+}
+/**
+ * Removes fenced blocks that contain no content.
+ * @param original Original comment text.
+ * @returns Updated comment text when a fence is removed.
+ * @example
+ * ```typescript
+ * const updated = removeEmptyFences("* ```typescript\n* ```\n* ok");
+ * ```
+ */
+function removeEmptyFences(original) {
+    const lineBreak = original.includes("\r\n") ? "\r\n" : "\n";
+    const lines = original.split(/\r?\n/u);
+    const initialState = {
+        currentFence: [],
+        hasFenceContent: false,
+        hasNonEmptyFence: false,
+        inFence: false,
+        output: [],
+        removed: false,
+    };
+    let state = initialState;
+    for (const line of lines) {
+        const fenceInfo = parseFenceLine(line);
+        state =
+            fenceInfo === void 0
+                ? updateContentState(state, line)
+                : updateFenceState(state, line);
+    }
+    const finalState = finalizeFenceState(state);
+    return finalState.removed && finalState.hasNonEmptyFence
+        ? finalState.output.join(lineBreak)
+        : void 0;
+}
+/**
+ * Updates the state with a non-fence line.
+ * @param state Current fence state.
+ * @param line Line being processed.
+ * @returns Updated fence state.
+ * @example
+ * ```typescript
+ * const next = updateContentState(state, " * const ok = true;");
+ * ```
+ */
+function updateContentState(state, line) {
+    if (state.inFence) {
+        return {
+            ...state,
+            currentFence: [...state.currentFence, line],
+            hasFenceContent: state.hasFenceContent || isContentLine(line),
+        };
+    }
+    return { ...state, output: [...state.output, line] };
+}
+/**
+ * Opens or closes a fence based on the current state.
+ * @param state Current fence state.
+ * @param line Fence line being processed.
+ * @returns Updated fence state.
+ * @example
+ * ```typescript
+ * const next = updateFenceState(state, " * ```");
+ * ```
+ */
+function updateFenceState(state, line) {
+    if (state.inFence) {
+        return closeFence(state, line);
+    }
+    return openFence(state, line);
+}
+export { parseFenceLine, removeEmptyFences };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"empty-fence-fixes.js","sourceRoot":"","sources":["../../../../src/domain/docs/require-example-language/empty-fence-fixes.ts"],"names":[],"mappings":"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","sourcesContent":["/** Type definition for rule data. */\ninterface EmptyFenceState {\n  /** CurrentFence field value. */\n  currentFence: string[];\n\n  /** HasFenceContent field value. */\n  hasFenceContent: boolean;\n\n  /** HasNonEmptyFence field value. */\n  hasNonEmptyFence: boolean;\n\n  /** InFence field value. */\n  inFence: boolean;\n\n  /** Output field value. */\n  output: string[];\n\n  /** Removed field value. */\n  removed: boolean;\n}\n\n/** Type definition for rule data. */\ninterface FenceLineInfo {\n  /** Language field value. */\n  language: string;\n\n  /** Leading field value. */\n  leading: string;\n}\n\n/**\n * Closes a fence and updates the state.\n * @param state Current fence state.\n * @param line Fence line being processed.\n * @returns Updated fence state.\n * @example\n * ```typescript\n * const next = closeFence(state, \" * ```\");\n * ```\n */\nfunction closeFence(state: EmptyFenceState, line: string): EmptyFenceState {\n  const fenceLines = [...state.currentFence, line];\n  const shouldRemove = !state.hasFenceContent;\n  const hasNonEmptyFence = state.hasNonEmptyFence || state.hasFenceContent;\n  const output = shouldRemove ? state.output : [...state.output, ...fenceLines];\n\n  return {\n    ...state,\n    currentFence: [],\n    hasFenceContent: false,\n    hasNonEmptyFence,\n    inFence: false,\n    output,\n    removed: state.removed || shouldRemove,\n  };\n}\n\n/**\n * Finalizes fence output, including any unclosed fences.\n * @param state Current fence state.\n * @returns Finalized fence state.\n * @example\n * ```typescript\n * const next = finalizeFenceState(state);\n * ```\n */\nfunction finalizeFenceState(state: EmptyFenceState): EmptyFenceState {\n  if (state.inFence) {\n    return {\n      ...state,\n      currentFence: [],\n      hasFenceContent: false,\n      hasNonEmptyFence: state.hasNonEmptyFence || state.hasFenceContent,\n      inFence: false,\n      output: [...state.output, ...state.currentFence],\n    };\n  }\n\n  return state;\n}\n\n/**\n * Determines whether a line contains non-empty content.\n * @param line Line text to check.\n * @returns True when the line contains content.\n * @example\n * ```typescript\n * const ok = isContentLine(\" * const ok = true;\");\n * ```\n */\nfunction isContentLine(line: string): boolean {\n  const trimmed = line.replace(/^\\s*\\*?\\s?/u, \"\").trim();\n  return trimmed.length > 0;\n}\n\n/**\n * Opens a new fenced block.\n * @param state Current fence state.\n * @param line Fence line being processed.\n * @returns Updated fence state.\n * @example\n * ```typescript\n * const next = openFence(state, \" * ```typescript\");\n * ```\n */\nfunction openFence(state: EmptyFenceState, line: string): EmptyFenceState {\n  return {\n    ...state,\n    currentFence: [line],\n    hasFenceContent: false,\n    hasNonEmptyFence: state.hasNonEmptyFence,\n    inFence: true,\n  };\n}\n\n/**\n * Parses a fence line for its leading prefix and language.\n * @param line Fence line to parse.\n * @returns Parsed fence info when matched.\n * @example\n * ```typescript\n * const info = parseFenceLine(\" * ```typescript\");\n * ```\n */\nfunction parseFenceLine(line: string): FenceLineInfo | undefined {\n  const fenceMatch = /^(?<leading>\\s*\\*?\\s*)```(?<lang>[^\\s`]+)?[ \\t]*$/u.exec(\n    line,\n  );\n\n  if (fenceMatch === null) {\n    return void 0;\n  }\n\n  const groups = fenceMatch.groups ?? {};\n  const leading =\n    typeof groups[\"leading\"] === \"string\" ? groups[\"leading\"] : \"\";\n  const language = typeof groups[\"lang\"] === \"string\" ? groups[\"lang\"] : \"\";\n\n  return { language, leading };\n}\n\n/**\n * Removes fenced blocks that contain no content.\n * @param original Original comment text.\n * @returns Updated comment text when a fence is removed.\n * @example\n * ```typescript\n * const updated = removeEmptyFences(\"* ```typescript\\n* ```\\n* ok\");\n * ```\n */\nfunction removeEmptyFences(original: string): string | undefined {\n  const lineBreak = original.includes(\"\\r\\n\") ? \"\\r\\n\" : \"\\n\";\n  const lines = original.split(/\\r?\\n/u);\n  const initialState: EmptyFenceState = {\n    currentFence: [],\n    hasFenceContent: false,\n    hasNonEmptyFence: false,\n    inFence: false,\n    output: [],\n    removed: false,\n  };\n  let state = initialState;\n\n  for (const line of lines) {\n    const fenceInfo = parseFenceLine(line);\n    state =\n      fenceInfo === void 0\n        ? updateContentState(state, line)\n        : updateFenceState(state, line);\n  }\n\n  const finalState = finalizeFenceState(state);\n\n  return finalState.removed && finalState.hasNonEmptyFence\n    ? finalState.output.join(lineBreak)\n    : void 0;\n}\n\n/**\n * Updates the state with a non-fence line.\n * @param state Current fence state.\n * @param line Line being processed.\n * @returns Updated fence state.\n * @example\n * ```typescript\n * const next = updateContentState(state, \" * const ok = true;\");\n * ```\n */\nfunction updateContentState(\n  state: EmptyFenceState,\n  line: string,\n): EmptyFenceState {\n  if (state.inFence) {\n    return {\n      ...state,\n      currentFence: [...state.currentFence, line],\n      hasFenceContent: state.hasFenceContent || isContentLine(line),\n    };\n  }\n\n  return { ...state, output: [...state.output, line] };\n}\n\n/**\n * Opens or closes a fence based on the current state.\n * @param state Current fence state.\n * @param line Fence line being processed.\n * @returns Updated fence state.\n * @example\n * ```typescript\n * const next = updateFenceState(state, \" * ```\");\n * ```\n */\nfunction updateFenceState(\n  state: EmptyFenceState,\n  line: string,\n): EmptyFenceState {\n  if (state.inFence) {\n    return closeFence(state, line);\n  }\n\n  return openFence(state, line);\n}\n\nexport { parseFenceLine, removeEmptyFences };\n"]}

package/dist/domain/docs/require-example-language/example-utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"example-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/require-example-language/example-utilities.ts"],"names":[],"mappings":"AAAA,qCAAqC;AACrC,UAAU,QAAQ;IAChB,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IAEjB,6BAA6B;IAC7B,SAAS,EAAE,MAAM,CAAC;IAElB,6BAA6B;IAC7B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,qCAAqC;AACrC,UAAU,eAAe;IACvB,gCAAgC;IAChC,YAAY,EAAE,MAAM,CAAC;IAErB,wBAAwB;IACxB,IAAI,EAAE,MAAM,CAAC;IAEb,+BAA+B;IAC/B,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;GAQG;AACH,iBAAS,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAU1D;AAED;;;;;;;;GAQG;AACH,iBAAS,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAIhD;AAED;;;;;;;;GAQG;AACH,iBAAS,WAAW,CAAC,OAAO,EAAE,eAAe,GAAG,QAAQ,CAQvD;AAED;;;;;;;;GAQG;AACH,iBAAS,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAQzC;AAED;;;;;;;;GAQG;AACH,iBAAS,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAG7C;AAED,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,WAAW,EACX,SAAS,EACT,cAAc,GACf,CAAC"}

package/dist/domain/docs/require-example-language/example-utilities.js

@@ -0,0 +1,76 @@
+/**
+ * Extracts the language from a fence line when present.
+ * @param line Fence line to inspect.
+ * @returns Language tag when present.
+ * @example
+ * ```typescript
+ * const lang = getFenceLanguage(" * ```typescript");
+ * ```
+ */
+function getFenceLanguage(line) {
+    const fenceMatch = /^(?<leading>\s*\*?\s*)```(?<lang>[^\s`]+)?[ \t]*$/u.exec(line);
+    if (fenceMatch === null) {
+        return void 0;
+    }
+    return fenceMatch.groups?.["lang"] ?? "";
+}
+/**
+ * Extracts inline example content from the header line.
+ * @param header Example header line.
+ * @returns Inline example content.
+ * @example
+ * ```typescript
+ * const text = getInlineContent("* @example hello");
+ * ```
+ */
+function getInlineContent(header) {
+    const inlineMatch = /^.*@example\b\s?(?<c>.*)$/u.exec(header);
+    return inlineMatch?.groups?.["c"] ?? "";
+}
+/**
+ * Computes line metadata from the raw comment value.
+ * @param context Comment metadata context.
+ * @returns Line metadata for the example.
+ * @example
+ * ```typescript
+ * const meta = getLineMeta({ commentValue: "* ok", full: "* ok", startOffset: 0 });
+ * ```
+ */
+function getLineMeta(context) {
+    const { commentValue, full, startOffset } = context;
+    const lineIndex = commentValue.slice(0, startOffset).split(/\r?\n/u).length - 1;
+    const endOffset = startOffset + full.length;
+    const endIndex = lineIndex + full.split(/\r?\n/u).length - 1;
+    return { endIndex, endOffset, lineIndex };
+}
+/**
+ * Resolves the leading prefix used by example lines.
+ * @param header Example header line.
+ * @returns The leading prefix string.
+ * @example
+ * ```typescript
+ * const prefix = getPrefix(" * @example");
+ * ```
+ */
+function getPrefix(header) {
+    const prefixMatch = header.indexOf("@example");
+    if (prefixMatch === -1) {
+        return "";
+    }
+    return header.slice(0, prefixMatch);
+}
+/**
+ * Determines whether a content line contains non-empty example text.
+ * @param line Line text to check.
+ * @returns True when the line contains content.
+ * @example
+ * ```typescript
+ * const ok = hasLineContent(" * const value = 1;");
+ * ```
+ */
+function hasLineContent(line) {
+    const trimmed = line.replace(/^\s*\*?\s?/u, "").trim();
+    return trimmed.length > 0;
+}
+export { getFenceLanguage, getInlineContent, getLineMeta, getPrefix, hasLineContent, };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/{docs → domain/docs}/require-example-language/examples.d.ts

@@ -1,4 +1,4 @@
-import type { Example, Problem } from "./types";
+import type { Example, Problem } from "./types.js";
 /**
  * Builds an Example from a regex match and raw comment value.
  * @param match Regex match from the example pattern.

package/dist/domain/docs/require-example-language/examples.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"examples.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/require-example-language/examples.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AA6KhD;;;;;;;;;GASG;AACH,iBAAS,qBAAqB,CAC5B,KAAK,EAAE,gBAAgB,EACvB,YAAY,EAAE,MAAM,GACnB,OAAO,CAqBT;AAED;;;;;;;;GAQG;AACH,iBAAS,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAoBjE;AAED;;;;;;;;;;GAUG;AACH,iBAAS,WAAW,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,EAAE,CAQpD;AAED,OAAO,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,WAAW,EAAE,CAAC"}

package/dist/domain/docs/require-example-language/examples.js

@@ -0,0 +1,181 @@
+import { getFenceLanguage, getInlineContent, getLineMeta, getPrefix, hasLineContent, } from "./example-utilities.js";
+/** Captures `@example` headers and bodies for analysis. */
+const examplePattern = /^(?<header>\s*\*?\s*@example\b[^\n]*)(?<body>[\s\S]*?)(?=^\s*\*?\s*@\w+|(?![\s\S]))/gmu;
+/**
+ * Updates fence state based on the detected language.
+ * @param state Current fence tracking state.
+ * @param language Fence language string.
+ * @returns Updated fence tracking state.
+ * @example
+ * ```typescript
+ * const next = updateFenceState(state, "typescript");
+ * ```
+ */
+const updateFenceState = (state, language) => {
+    if (!state.inFence) {
+        if (language.length === 0) {
+            return { ...state, missingLanguage: true, sawFence: true };
+        }
+        return {
+            ...state,
+            currentFenceHasContent: false,
+            inFence: true,
+            missingLanguage: false,
+            sawFence: true,
+        };
+    }
+    return {
+        ...state,
+        currentFenceHasContent: false,
+        hasEmptyFence: state.hasEmptyFence || !state.currentFenceHasContent,
+        inFence: false,
+        missingLanguage: false,
+        sawFence: true,
+    };
+};
+/**
+ * Updates fence tracking for a single example line.
+ * @param state Current fence tracking state.
+ * @param line Example line to inspect.
+ * @returns Updated fence tracking state.
+ * @example
+ * ```typescript
+ * const next = updateFenceStateForLine(state, " * ok");
+ * ```
+ */
+const updateFenceStateForLine = (state, line) => {
+    const language = getFenceLanguage(line);
+    if (language !== void 0) {
+        return updateFenceState(state, language);
+    }
+    if (state.inFence && hasLineContent(line)) {
+        return { ...state, currentFenceHasContent: true };
+    }
+    return state;
+};
+/**
+ * Analyzes fenced code blocks for missing language identifiers.
+ * @param content Example content to analyze.
+ * @returns Fence analysis results.
+ * @example
+ * ```typescript
+ * const analysis = analyzeFenceContent("```typescript\nconst value = 1;\n```");
+ * ```
+ */
+function analyzeFenceContent(content) {
+    const lines = content.split(/\r?\n/u);
+    let state = {
+        currentFenceHasContent: false,
+        hasEmptyFence: false,
+        inFence: false,
+        missingLanguage: false,
+        sawFence: false,
+    };
+    for (const line of lines) {
+        state = updateFenceStateForLine(state, line);
+        if (state.missingLanguage) {
+            break;
+        }
+    }
+    if (state.inFence && !state.currentFenceHasContent) {
+        state = { ...state, hasEmptyFence: true };
+    }
+    return {
+        hasEmptyFence: state.hasEmptyFence,
+        missingLanguage: state.missingLanguage,
+        sawFence: state.sawFence,
+    };
+}
+/**
+ * Builds example content from an inline header and body lines.
+ * @param context Example header and body lines.
+ * @returns Combined example content.
+ * @example
+ * ```typescript
+ * const content = buildExampleContent({ body: "* ok", header: "* @example" });
+ * ```
+ */
+function buildExampleContent(context) {
+    const { body, header } = context;
+    const inlineContent = getInlineContent(header);
+    if (inlineContent.length > 0) {
+        return `${inlineContent}\n${body}`;
+    }
+    return body;
+}
+/**
+ * Builds an Example from a regex match and raw comment value.
+ * @param match Regex match from the example pattern.
+ * @param commentValue Raw comment value.
+ * @returns Example metadata extracted from the match.
+ * @example
+ * ```typescript
+ * const example = buildExampleFromMatch(match, commentValue);
+ * ```
+ */
+function buildExampleFromMatch(match, commentValue) {
+    const [full] = match;
+    const header = match.groups?.["header"] ?? "";
+    const body = match.groups?.["body"] ?? "";
+    const startOffset = match.index ?? 0;
+    const content = buildExampleContent({ body, header });
+    const prefix = getPrefix(header);
+    const { endIndex, endOffset, lineIndex } = getLineMeta({
+        commentValue,
+        full,
+        startOffset,
+    });
+    return {
+        content: content.trim(),
+        endIndex,
+        endOffset,
+        lineIndex,
+        prefix,
+        startOffset,
+    };
+}
+/**
+ * Checks example content for required fences and language.
+ * @param content Example content to inspect.
+ * @returns Problem identifier when the content is invalid.
+ * @example
+ * ```typescript
+ * const problem = checkExampleContent("```typescript\nconst ok = true;\n```");
+ * ```
+ */
+function checkExampleContent(content) {
+    if (content.trim().length === 0) {
+        return "emptyExample";
+    }
+    const { hasEmptyFence, missingLanguage, sawFence } = analyzeFenceContent(content);
+    if (missingLanguage) {
+        return "missingLanguage";
+    }
+    if (sawFence && hasEmptyFence) {
+        return "emptyExample";
+    }
+    if (!sawFence) {
+        return "missingFence";
+    }
+    return void 0;
+}
+/**
+ * Extracts all `@example` entries from a JSDoc comment value.
+ * Uses a multiline regex to capture the header and following lines
+ * until the next JSDoc tag or the end of the comment.
+ * @param commentValue Raw comment value.
+ * @returns Extracted examples.
+ * @example
+ * ```typescript
+ * const examples = getExamples("* @example\n* ```typescript\n* ok\n* ```");
+ * ```
+ */
+function getExamples(commentValue) {
+    const examples = [];
+    for (const match of commentValue.matchAll(examplePattern)) {
+        examples.push(buildExampleFromMatch(match, commentValue));
+    }
+    return examples;
+}
+export { buildExampleFromMatch, checkExampleContent, getExamples };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"examples.js","sourceRoot":"","sources":["../../../../src/domain/docs/require-example-language/examples.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Example, Problem } from \"./types\";\n\nimport {\n  getFenceLanguage,\n  getInlineContent,\n  getLineMeta,\n  getPrefix,\n  hasLineContent,\n} from \"./example-utilities\";\n\n/** Captures `@example` headers and bodies for analysis. */\nconst examplePattern =\n  /^(?<header>\\s*\\*?\\s*@example\\b[^\\n]*)(?<body>[\\s\\S]*?)(?=^\\s*\\*?\\s*@\\w+|(?![\\s\\S]))/gmu;\n\n/** Type definition for rule data. */\ninterface FenceState {\n  /** CurrentFenceHasContent field value. */\n  currentFenceHasContent: boolean;\n\n  /** HasEmptyFence field value. */\n  hasEmptyFence: boolean;\n\n  /** InFence field value. */\n  inFence: boolean;\n\n  /** MissingLanguage field value. */\n  missingLanguage: boolean;\n\n  /** SawFence field value. */\n  sawFence: boolean;\n}\n\n/**\n * Updates fence state based on the detected language.\n * @param state Current fence tracking state.\n * @param language Fence language string.\n * @returns Updated fence tracking state.\n * @example\n * ```typescript\n * const next = updateFenceState(state, \"typescript\");\n * ```\n */\nconst updateFenceState = (state: FenceState, language: string): FenceState => {\n  if (!state.inFence) {\n    if (language.length === 0) {\n      return { ...state, missingLanguage: true, sawFence: true };\n    }\n\n    return {\n      ...state,\n      currentFenceHasContent: false,\n      inFence: true,\n      missingLanguage: false,\n      sawFence: true,\n    };\n  }\n\n  return {\n    ...state,\n    currentFenceHasContent: false,\n    hasEmptyFence: state.hasEmptyFence || !state.currentFenceHasContent,\n    inFence: false,\n    missingLanguage: false,\n    sawFence: true,\n  };\n};\n\n/**\n * Updates fence tracking for a single example line.\n * @param state Current fence tracking state.\n * @param line Example line to inspect.\n * @returns Updated fence tracking state.\n * @example\n * ```typescript\n * const next = updateFenceStateForLine(state, \" * ok\");\n * ```\n */\nconst updateFenceStateForLine = (\n  state: FenceState,\n  line: string,\n): FenceState => {\n  const language = getFenceLanguage(line);\n\n  if (language !== void 0) {\n    return updateFenceState(state, language);\n  }\n\n  if (state.inFence && hasLineContent(line)) {\n    return { ...state, currentFenceHasContent: true };\n  }\n\n  return state;\n};\n\n/** Type definition for rule data. */\ninterface ExampleContentContext {\n  /** Body field value. */\n  body: string;\n\n  /** Header field value. */\n  header: string;\n}\n\n/** Type definition for rule data. */\ninterface FenceAnalysis {\n  /** HasEmptyFence field value. */\n  hasEmptyFence: boolean;\n\n  /** MissingLanguage field value. */\n  missingLanguage: boolean;\n\n  /** SawFence field value. */\n  sawFence: boolean;\n}\n\n/**\n * Analyzes fenced code blocks for missing language identifiers.\n * @param content Example content to analyze.\n * @returns Fence analysis results.\n * @example\n * ```typescript\n * const analysis = analyzeFenceContent(\"```typescript\\nconst value = 1;\\n```\");\n * ```\n */\nfunction analyzeFenceContent(content: string): FenceAnalysis {\n  const lines = content.split(/\\r?\\n/u);\n  let state: FenceState = {\n    currentFenceHasContent: false,\n    hasEmptyFence: false,\n    inFence: false,\n    missingLanguage: false,\n    sawFence: false,\n  };\n\n  for (const line of lines) {\n    state = updateFenceStateForLine(state, line);\n\n    if (state.missingLanguage) {\n      break;\n    }\n  }\n\n  if (state.inFence && !state.currentFenceHasContent) {\n    state = { ...state, hasEmptyFence: true };\n  }\n\n  return {\n    hasEmptyFence: state.hasEmptyFence,\n    missingLanguage: state.missingLanguage,\n    sawFence: state.sawFence,\n  };\n}\n\n/**\n * Builds example content from an inline header and body lines.\n * @param context Example header and body lines.\n * @returns Combined example content.\n * @example\n * ```typescript\n * const content = buildExampleContent({ body: \"* ok\", header: \"* @example\" });\n * ```\n */\nfunction buildExampleContent(context: ExampleContentContext): string {\n  const { body, header } = context;\n  const inlineContent = getInlineContent(header);\n\n  if (inlineContent.length > 0) {\n    return `${inlineContent}\\n${body}`;\n  }\n\n  return body;\n}\n\n/**\n * Builds an Example from a regex match and raw comment value.\n * @param match Regex match from the example pattern.\n * @param commentValue Raw comment value.\n * @returns Example metadata extracted from the match.\n * @example\n * ```typescript\n * const example = buildExampleFromMatch(match, commentValue);\n * ```\n */\nfunction buildExampleFromMatch(\n  match: RegExpMatchArray,\n  commentValue: string,\n): Example {\n  const [full] = match;\n  const header = match.groups?.[\"header\"] ?? \"\";\n  const body = match.groups?.[\"body\"] ?? \"\";\n  const startOffset = match.index ?? 0;\n  const content = buildExampleContent({ body, header });\n  const prefix = getPrefix(header);\n  const { endIndex, endOffset, lineIndex } = getLineMeta({\n    commentValue,\n    full,\n    startOffset,\n  });\n\n  return {\n    content: content.trim(),\n    endIndex,\n    endOffset,\n    lineIndex,\n    prefix,\n    startOffset,\n  };\n}\n\n/**\n * Checks example content for required fences and language.\n * @param content Example content to inspect.\n * @returns Problem identifier when the content is invalid.\n * @example\n * ```typescript\n * const problem = checkExampleContent(\"```typescript\\nconst ok = true;\\n```\");\n * ```\n */\nfunction checkExampleContent(content: string): Problem | undefined {\n  if (content.trim().length === 0) {\n    return \"emptyExample\";\n  }\n  const { hasEmptyFence, missingLanguage, sawFence } =\n    analyzeFenceContent(content);\n\n  if (missingLanguage) {\n    return \"missingLanguage\";\n  }\n\n  if (sawFence && hasEmptyFence) {\n    return \"emptyExample\";\n  }\n\n  if (!sawFence) {\n    return \"missingFence\";\n  }\n\n  return void 0;\n}\n\n/**\n * Extracts all `@example` entries from a JSDoc comment value.\n * Uses a multiline regex to capture the header and following lines\n * until the next JSDoc tag or the end of the comment.\n * @param commentValue Raw comment value.\n * @returns Extracted examples.\n * @example\n * ```typescript\n * const examples = getExamples(\"* @example\\n* ```typescript\\n* ok\\n* ```\");\n * ```\n */\nfunction getExamples(commentValue: string): Example[] {\n  const examples: Example[] = [];\n\n  for (const match of commentValue.matchAll(examplePattern)) {\n    examples.push(buildExampleFromMatch(match, commentValue));\n  }\n\n  return examples;\n}\n\nexport { buildExampleFromMatch, checkExampleContent, getExamples };\n"]}

package/dist/{docs → domain/docs}/require-example-language/fixes.d.ts

@@ -1,5 +1,5 @@
 import type { Rule } from "eslint";
-import type { Example, Problem } from "./types";
+import type { Example, Problem } from "./types.js";
 /** Type definition for rule data. */
 interface FixerContext {
     /** AbsoluteEnd field value. */
@@ -44,6 +44,6 @@ declare function buildMissingLanguageFix(original: string): string | undefined;
  * const fixer = createFixer(context);
  * ```
  */
-declare function createFixer(context: FixerContext): (fixer: Rule.RuleFixer) => null | Rule.Fix;
+declare function createFixer(context: FixerContext): (fixer: Rule.RuleFixer) => Rule.Fix | undefined;
 export { buildMissingFenceFix, buildMissingLanguageFix, createFixer };
 //# sourceMappingURL=fixes.d.ts.map

package/dist/domain/docs/require-example-language/fixes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixes.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/require-example-language/fixes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AA8BhD,qCAAqC;AACrC,UAAU,YAAY;IACpB,+BAA+B;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,iCAAiC;IACjC,aAAa,EAAE,MAAM,CAAC;IACtB,2BAA2B;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,oCAAoC;IACpC,gBAAgB,EAAE,OAAO,CAAC;IAC1B,2BAA2B;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,8BAA8B;IAC9B,UAAU,EAAE,MAAM,CAAC;CACpB;AA2CD;;;;;;;;GAQG;AACH,iBAAS,oBAAoB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAgBtD;AAED;;;;;;;;GAQG;AACH,iBAAS,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAiBrE;AAED;;;;;;;;GAQG;AACH,iBAAS,WAAW,CAClB,OAAO,EAAE,YAAY,GACpB,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,KAAK,IAAI,CAAC,GAAG,GAAG,SAAS,CAYjD;AA0HD,OAAO,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,WAAW,EAAE,CAAC"}