eslint-plugin-intlayer 9.3.1 → 9.3.2

package/dist/types/node_modules/.bun/@types_estree@1.0.9/node_modules/@types/estree/index.d.ts

@@ -0,0 +1,528 @@
+//#region ../../node_modules/.bun/@types+estree@1.0.9/node_modules/@types/estree/index.d.ts
+// This definition file follows a somewhat unusual format. ESTree allows
+// runtime type checks based on the `type` parameter. In order to explain this
+// to typescript we want to use discriminated union types:
+// https://github.com/Microsoft/TypeScript/pull/9163
+//
+// For ESTree this is a bit tricky because the high level interfaces like
+// Node or Function are pulling double duty. We want to pass common fields down
+// to the interfaces that extend them (like Identifier or
+// ArrowFunctionExpression), but you can't extend a type union or enforce
+// common fields on them. So we've split the high level interfaces into two
+// types, a base type which passes down inherited fields, and a type union of
+// all types which extend the base type. Only the type union is exported, and
+// the union is how other types refer to the collection of inheriting types.
+//
+// This makes the definitions file here somewhat more difficult to maintain,
+// but it has the notable advantage of making ESTree much easier to use as
+// an end user.
+interface BaseNodeWithoutComments {
+  // Every leaf interface that extends BaseNode must specify a type property.
+  // The type property should be a string literal. For example, Identifier
+  // has: `type: "Identifier"`
+  type: string;
+  loc?: SourceLocation | null | undefined;
+  range?: [number, number] | undefined;
+}
+interface BaseNode extends BaseNodeWithoutComments {
+  leadingComments?: Comment[] | undefined;
+  trailingComments?: Comment[] | undefined;
+}
+interface NodeMap {
+  AssignmentProperty: AssignmentProperty;
+  CatchClause: CatchClause;
+  Class: Class;
+  ClassBody: ClassBody;
+  Expression: Expression;
+  Function: Function;
+  Identifier: Identifier;
+  Literal: Literal;
+  MethodDefinition: MethodDefinition;
+  ModuleDeclaration: ModuleDeclaration;
+  ModuleSpecifier: ModuleSpecifier;
+  Pattern: Pattern;
+  PrivateIdentifier: PrivateIdentifier;
+  Program: Program;
+  Property: Property;
+  PropertyDefinition: PropertyDefinition;
+  SpreadElement: SpreadElement;
+  Statement: Statement;
+  Super: Super;
+  SwitchCase: SwitchCase;
+  TemplateElement: TemplateElement;
+  VariableDeclarator: VariableDeclarator;
+}
+type Node = NodeMap[keyof NodeMap];
+interface Comment extends BaseNodeWithoutComments {
+  type: "Line" | "Block";
+  value: string;
+}
+interface SourceLocation {
+  source?: string | null | undefined;
+  start: Position;
+  end: Position;
+}
+interface Position {
+  /** >= 1 */
+  line: number;
+  /** >= 0 */
+  column: number;
+}
+interface Program extends BaseNode {
+  type: "Program";
+  sourceType: "script" | "module";
+  body: Array<Directive | Statement | ModuleDeclaration>;
+  comments?: Comment[] | undefined;
+}
+interface Directive extends BaseNode {
+  type: "ExpressionStatement";
+  expression: Literal;
+  directive: string;
+}
+interface BaseFunction extends BaseNode {
+  params: Pattern[];
+  generator?: boolean | undefined;
+  async?: boolean | undefined;
+  // The body is either BlockStatement or Expression because arrow functions
+  // can have a body that's either. FunctionDeclarations and
+  // FunctionExpressions have only BlockStatement bodies.
+  body: BlockStatement | Expression;
+}
+type Function = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
+type Statement = ExpressionStatement | BlockStatement | StaticBlock | EmptyStatement | DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | Declaration;
+interface BaseStatement extends BaseNode {}
+interface EmptyStatement extends BaseStatement {
+  type: "EmptyStatement";
+}
+interface BlockStatement extends BaseStatement {
+  type: "BlockStatement";
+  body: Statement[];
+  innerComments?: Comment[] | undefined;
+}
+interface StaticBlock extends Omit<BlockStatement, "type"> {
+  type: "StaticBlock";
+}
+interface ExpressionStatement extends BaseStatement {
+  type: "ExpressionStatement";
+  expression: Expression;
+}
+interface IfStatement extends BaseStatement {
+  type: "IfStatement";
+  test: Expression;
+  consequent: Statement;
+  alternate?: Statement | null | undefined;
+}
+interface LabeledStatement extends BaseStatement {
+  type: "LabeledStatement";
+  label: Identifier;
+  body: Statement;
+}
+interface BreakStatement extends BaseStatement {
+  type: "BreakStatement";
+  label?: Identifier | null | undefined;
+}
+interface ContinueStatement extends BaseStatement {
+  type: "ContinueStatement";
+  label?: Identifier | null | undefined;
+}
+interface WithStatement extends BaseStatement {
+  type: "WithStatement";
+  object: Expression;
+  body: Statement;
+}
+interface SwitchStatement extends BaseStatement {
+  type: "SwitchStatement";
+  discriminant: Expression;
+  cases: SwitchCase[];
+}
+interface ReturnStatement extends BaseStatement {
+  type: "ReturnStatement";
+  argument?: Expression | null | undefined;
+}
+interface ThrowStatement extends BaseStatement {
+  type: "ThrowStatement";
+  argument: Expression;
+}
+interface TryStatement extends BaseStatement {
+  type: "TryStatement";
+  block: BlockStatement;
+  handler?: CatchClause | null | undefined;
+  finalizer?: BlockStatement | null | undefined;
+}
+interface WhileStatement extends BaseStatement {
+  type: "WhileStatement";
+  test: Expression;
+  body: Statement;
+}
+interface DoWhileStatement extends BaseStatement {
+  type: "DoWhileStatement";
+  body: Statement;
+  test: Expression;
+}
+interface ForStatement extends BaseStatement {
+  type: "ForStatement";
+  init?: VariableDeclaration | Expression | null | undefined;
+  test?: Expression | null | undefined;
+  update?: Expression | null | undefined;
+  body: Statement;
+}
+interface BaseForXStatement extends BaseStatement {
+  left: VariableDeclaration | Pattern;
+  right: Expression;
+  body: Statement;
+}
+interface ForInStatement extends BaseForXStatement {
+  type: "ForInStatement";
+}
+interface DebuggerStatement extends BaseStatement {
+  type: "DebuggerStatement";
+}
+type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
+interface BaseDeclaration extends BaseStatement {}
+interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration {
+  type: "FunctionDeclaration";
+  /** It is null when a function declaration is a part of the `export default function` statement */
+  id: Identifier | null;
+  body: BlockStatement;
+}
+interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
+  id: Identifier;
+}
+interface VariableDeclaration extends BaseDeclaration {
+  type: "VariableDeclaration";
+  declarations: VariableDeclarator[];
+  kind: "var" | "let" | "const" | "using" | "await using";
+}
+interface VariableDeclarator extends BaseNode {
+  type: "VariableDeclarator";
+  id: Pattern;
+  init?: Expression | null | undefined;
+}
+interface ExpressionMap {
+  ArrayExpression: ArrayExpression;
+  ArrowFunctionExpression: ArrowFunctionExpression;
+  AssignmentExpression: AssignmentExpression;
+  AwaitExpression: AwaitExpression;
+  BinaryExpression: BinaryExpression;
+  CallExpression: CallExpression;
+  ChainExpression: ChainExpression;
+  ClassExpression: ClassExpression;
+  ConditionalExpression: ConditionalExpression;
+  FunctionExpression: FunctionExpression;
+  Identifier: Identifier;
+  ImportExpression: ImportExpression;
+  Literal: Literal;
+  LogicalExpression: LogicalExpression;
+  MemberExpression: MemberExpression;
+  MetaProperty: MetaProperty;
+  NewExpression: NewExpression;
+  ObjectExpression: ObjectExpression;
+  SequenceExpression: SequenceExpression;
+  TaggedTemplateExpression: TaggedTemplateExpression;
+  TemplateLiteral: TemplateLiteral;
+  ThisExpression: ThisExpression;
+  UnaryExpression: UnaryExpression;
+  UpdateExpression: UpdateExpression;
+  YieldExpression: YieldExpression;
+}
+type Expression = ExpressionMap[keyof ExpressionMap];
+interface BaseExpression extends BaseNode {}
+type ChainElement = SimpleCallExpression | MemberExpression;
+interface ChainExpression extends BaseExpression {
+  type: "ChainExpression";
+  expression: ChainElement;
+}
+interface ThisExpression extends BaseExpression {
+  type: "ThisExpression";
+}
+interface ArrayExpression extends BaseExpression {
+  type: "ArrayExpression";
+  elements: Array<Expression | SpreadElement | null>;
+}
+interface ObjectExpression extends BaseExpression {
+  type: "ObjectExpression";
+  properties: Array<Property | SpreadElement>;
+}
+interface PrivateIdentifier extends BaseNode {
+  type: "PrivateIdentifier";
+  name: string;
+}
+interface Property extends BaseNode {
+  type: "Property";
+  key: Expression;
+  value: Expression | Pattern; // Could be an AssignmentProperty
+  kind: "init" | "get" | "set";
+  method: boolean;
+  shorthand: boolean;
+  computed: boolean;
+}
+interface PropertyDefinition extends BaseNode {
+  type: "PropertyDefinition";
+  key: Expression | PrivateIdentifier;
+  value?: Expression | null | undefined;
+  computed: boolean;
+  static: boolean;
+}
+interface FunctionExpression extends BaseFunction, BaseExpression {
+  id?: Identifier | null | undefined;
+  type: "FunctionExpression";
+  body: BlockStatement;
+}
+interface SequenceExpression extends BaseExpression {
+  type: "SequenceExpression";
+  expressions: Expression[];
+}
+interface UnaryExpression extends BaseExpression {
+  type: "UnaryExpression";
+  operator: UnaryOperator;
+  prefix: true;
+  argument: Expression;
+}
+interface BinaryExpression extends BaseExpression {
+  type: "BinaryExpression";
+  operator: BinaryOperator;
+  left: Expression | PrivateIdentifier;
+  right: Expression;
+}
+interface AssignmentExpression extends BaseExpression {
+  type: "AssignmentExpression";
+  operator: AssignmentOperator;
+  left: Pattern | MemberExpression;
+  right: Expression;
+}
+interface UpdateExpression extends BaseExpression {
+  type: "UpdateExpression";
+  operator: UpdateOperator;
+  argument: Expression;
+  prefix: boolean;
+}
+interface LogicalExpression extends BaseExpression {
+  type: "LogicalExpression";
+  operator: LogicalOperator;
+  left: Expression;
+  right: Expression;
+}
+interface ConditionalExpression extends BaseExpression {
+  type: "ConditionalExpression";
+  test: Expression;
+  alternate: Expression;
+  consequent: Expression;
+}
+interface BaseCallExpression extends BaseExpression {
+  callee: Expression | Super;
+  arguments: Array<Expression | SpreadElement>;
+}
+type CallExpression = SimpleCallExpression | NewExpression;
+interface SimpleCallExpression extends BaseCallExpression {
+  type: "CallExpression";
+  optional: boolean;
+}
+interface NewExpression extends BaseCallExpression {
+  type: "NewExpression";
+}
+interface MemberExpression extends BaseExpression, BasePattern {
+  type: "MemberExpression";
+  object: Expression | Super;
+  property: Expression | PrivateIdentifier;
+  computed: boolean;
+  optional: boolean;
+}
+type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
+interface BasePattern extends BaseNode {}
+interface SwitchCase extends BaseNode {
+  type: "SwitchCase";
+  test?: Expression | null | undefined;
+  consequent: Statement[];
+}
+interface CatchClause extends BaseNode {
+  type: "CatchClause";
+  param: Pattern | null;
+  body: BlockStatement;
+}
+interface Identifier extends BaseNode, BaseExpression, BasePattern {
+  type: "Identifier";
+  name: string;
+}
+type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
+interface SimpleLiteral extends BaseNode, BaseExpression {
+  type: "Literal";
+  value: string | boolean | number | null;
+  raw?: string | undefined;
+}
+interface RegExpLiteral extends BaseNode, BaseExpression {
+  type: "Literal";
+  value?: RegExp | null | undefined;
+  regex: {
+    pattern: string;
+    flags: string;
+  };
+  raw?: string | undefined;
+}
+interface BigIntLiteral extends BaseNode, BaseExpression {
+  type: "Literal";
+  value?: bigint | null | undefined;
+  bigint: string;
+  raw?: string | undefined;
+}
+type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
+type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" | "instanceof";
+type LogicalOperator = "||" | "&&" | "??";
+type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
+type UpdateOperator = "++" | "--";
+interface ForOfStatement extends BaseForXStatement {
+  type: "ForOfStatement";
+  await: boolean;
+}
+interface Super extends BaseNode {
+  type: "Super";
+}
+interface SpreadElement extends BaseNode {
+  type: "SpreadElement";
+  argument: Expression;
+}
+interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
+  type: "ArrowFunctionExpression";
+  expression: boolean;
+  body: BlockStatement | Expression;
+}
+interface YieldExpression extends BaseExpression {
+  type: "YieldExpression";
+  argument?: Expression | null | undefined;
+  delegate: boolean;
+}
+interface TemplateLiteral extends BaseExpression {
+  type: "TemplateLiteral";
+  quasis: TemplateElement[];
+  expressions: Expression[];
+}
+interface TaggedTemplateExpression extends BaseExpression {
+  type: "TaggedTemplateExpression";
+  tag: Expression;
+  quasi: TemplateLiteral;
+}
+interface TemplateElement extends BaseNode {
+  type: "TemplateElement";
+  tail: boolean;
+  value: {
+    /** It is null when the template literal is tagged and the text has an invalid escape (e.g. - tag`\unicode and \u{55}`) */
+    cooked?: string | null | undefined;
+    raw: string;
+  };
+}
+interface AssignmentProperty extends Property {
+  value: Pattern;
+  kind: "init";
+  method: boolean; // false
+}
+interface ObjectPattern extends BasePattern {
+  type: "ObjectPattern";
+  properties: Array<AssignmentProperty | RestElement>;
+}
+interface ArrayPattern extends BasePattern {
+  type: "ArrayPattern";
+  elements: Array<Pattern | null>;
+}
+interface RestElement extends BasePattern {
+  type: "RestElement";
+  argument: Pattern;
+}
+interface AssignmentPattern extends BasePattern {
+  type: "AssignmentPattern";
+  left: Pattern;
+  right: Expression;
+}
+type Class = ClassDeclaration | ClassExpression;
+interface BaseClass extends BaseNode {
+  superClass?: Expression | null | undefined;
+  body: ClassBody;
+}
+interface ClassBody extends BaseNode {
+  type: "ClassBody";
+  body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
+}
+interface MethodDefinition extends BaseNode {
+  type: "MethodDefinition";
+  key: Expression | PrivateIdentifier;
+  value: FunctionExpression;
+  kind: "constructor" | "method" | "get" | "set";
+  computed: boolean;
+  static: boolean;
+}
+interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration {
+  type: "ClassDeclaration";
+  /** It is null when a class declaration is a part of the `export default class` statement */
+  id: Identifier | null;
+}
+interface ClassDeclaration extends MaybeNamedClassDeclaration {
+  id: Identifier;
+}
+interface ClassExpression extends BaseClass, BaseExpression {
+  type: "ClassExpression";
+  id?: Identifier | null | undefined;
+}
+interface MetaProperty extends BaseExpression {
+  type: "MetaProperty";
+  meta: Identifier;
+  property: Identifier;
+}
+type ModuleDeclaration = ImportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration | ExportAllDeclaration;
+interface BaseModuleDeclaration extends BaseNode {}
+type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier;
+interface BaseModuleSpecifier extends BaseNode {
+  local: Identifier;
+}
+interface ImportDeclaration extends BaseModuleDeclaration {
+  type: "ImportDeclaration";
+  specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
+  attributes: ImportAttribute[];
+  source: Literal;
+}
+interface ImportSpecifier extends BaseModuleSpecifier {
+  type: "ImportSpecifier";
+  imported: Identifier | Literal;
+}
+interface ImportAttribute extends BaseNode {
+  type: "ImportAttribute";
+  key: Identifier | Literal;
+  value: Literal;
+}
+interface ImportExpression extends BaseExpression {
+  type: "ImportExpression";
+  source: Expression;
+  options?: Expression | null | undefined;
+}
+interface ImportDefaultSpecifier extends BaseModuleSpecifier {
+  type: "ImportDefaultSpecifier";
+}
+interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
+  type: "ImportNamespaceSpecifier";
+}
+interface ExportNamedDeclaration extends BaseModuleDeclaration {
+  type: "ExportNamedDeclaration";
+  declaration?: Declaration | null | undefined;
+  specifiers: ExportSpecifier[];
+  attributes: ImportAttribute[];
+  source?: Literal | null | undefined;
+}
+interface ExportSpecifier extends Omit<BaseModuleSpecifier, "local"> {
+  type: "ExportSpecifier";
+  local: Identifier | Literal;
+  exported: Identifier | Literal;
+}
+interface ExportDefaultDeclaration extends BaseModuleDeclaration {
+  type: "ExportDefaultDeclaration";
+  declaration: MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression;
+}
+interface ExportAllDeclaration extends BaseModuleDeclaration {
+  type: "ExportAllDeclaration";
+  exported: Identifier | Literal | null;
+  attributes: ImportAttribute[];
+  source: Literal;
+}
+interface AwaitExpression extends BaseExpression {
+  type: "AwaitExpression";
+  argument: Expression;
+}
+//#endregion
+export { ArrayExpression, ArrayPattern, ArrowFunctionExpression, AssignmentExpression, AssignmentOperator, AssignmentPattern, AssignmentProperty, AwaitExpression, BaseCallExpression, BaseClass, BaseDeclaration, BaseExpression, BaseForXStatement, BaseFunction, BaseModuleDeclaration, BaseModuleSpecifier, BaseNode, BaseNodeWithoutComments, BasePattern, BaseStatement, BigIntLiteral, BinaryExpression, BinaryOperator, BlockStatement, BreakStatement, CallExpression, CatchClause, ChainElement, ChainExpression, Class, ClassBody, ClassDeclaration, ClassExpression, Comment, ConditionalExpression, ContinueStatement, DebuggerStatement, Declaration, Directive, DoWhileStatement, EmptyStatement, ExportAllDeclaration, ExportDefaultDeclaration, ExportNamedDeclaration, ExportSpecifier, Expression, ExpressionMap, ExpressionStatement, ForInStatement, ForOfStatement, ForStatement, Function, FunctionDeclaration, FunctionExpression, Identifier, IfStatement, ImportAttribute, ImportDeclaration, ImportDefaultSpecifier, ImportExpression, ImportNamespaceSpecifier, ImportSpecifier, LabeledStatement, Literal, LogicalExpression, LogicalOperator, MaybeNamedClassDeclaration, MaybeNamedFunctionDeclaration, MemberExpression, MetaProperty, MethodDefinition, ModuleDeclaration, ModuleSpecifier, NewExpression, Node, NodeMap, ObjectExpression, ObjectPattern, Pattern, Position, PrivateIdentifier, Program, Property, PropertyDefinition, RegExpLiteral, RestElement, ReturnStatement, SequenceExpression, SimpleCallExpression, SimpleLiteral, SourceLocation, SpreadElement, Statement, StaticBlock, Super, SwitchCase, SwitchStatement, TaggedTemplateExpression, TemplateElement, TemplateLiteral, ThisExpression, ThrowStatement, TryStatement, UnaryExpression, UnaryOperator, UpdateExpression, UpdateOperator, VariableDeclaration, VariableDeclarator, WhileStatement, WithStatement, YieldExpression };
+//# sourceMappingURL=index.d.ts.map

package/dist/types/node_modules/.bun/@types_estree@1.0.9/node_modules/@types/estree/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../../../../../../../node_modules/.bun/@types+estree@1.0.9/node_modules/@types/estree/index.d.ts"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/types/preset.d.ts

@@ -0,0 +1,45 @@
+import { IntlayerRuleName } from "./index.js";
+import { Linter } from "eslint";
+//#region src/preset.d.ts
+/** npm package name of this plugin. */
+declare const PLUGIN_PACKAGE_NAME = "eslint-plugin-intlayer";
+/** Prefix the rules are registered under, e.g. `intlayer/no-raw-text`. */
+declare const PLUGIN_NAMESPACE = "intlayer";
+/**
+ * Intlayer's generated output, which every preset ignores.
+ *
+ * `.intlayer/` holds compiled dictionaries and generated types — machine-written
+ * files that are never source. Linting them is at best wasted work and at worst
+ * a hard failure, since third-party rules can crash on generated shapes they
+ * were never meant to see. The rest of the toolchain already excludes this
+ * directory (`content.watchExclude`, the build globs), so the lint preset
+ * matches.
+ */
+declare const GENERATED_OUTPUT_GLOBS: string[];
+/**
+ * Rules enabled by the `recommended` preset, keyed by unprefixed rule name.
+ *
+ * Exported because oxlint resolves a plugin's *rules* but not its shipped
+ * *configs*: `intlayer init` reads this to spell the preset out explicitly in
+ * `.oxlintrc.json`. Keeping the definition next to the rules it names means
+ * enabling one by default is a single-line change.
+ *
+ * `no-raw-text` stays a warning on purpose — pointed at an existing codebase it
+ * surfaces every untranslated string at once, which should not break a build on
+ * day one. `enforce-adapter-import` is deliberately absent: importing from the
+ * original package is valid once the bundler alias is configured, so it is
+ * opt-in through the `strict` preset. `no-unused-content` is absent from every
+ * preset — it scans the project from disk, which no preset should impose.
+ */
+declare const RECOMMENDED_RULES: Partial<Record<IntlayerRuleName, Linter.RuleEntry>>;
+/**
+ * The `recommended` preset with every rule name prefixed by the plugin
+ * namespace — the shape both ESLint flat config and `.oxlintrc.json` expect.
+ *
+ * `intlayer init` uses this to write the preset into `.oxlintrc.json`, since
+ * oxlint resolves a plugin's rules but not its configs.
+ */
+declare const getRecommendedRules: () => Record<string, Linter.RuleEntry>;
+//#endregion
+export { GENERATED_OUTPUT_GLOBS, PLUGIN_NAMESPACE, PLUGIN_PACKAGE_NAME, RECOMMENDED_RULES, getRecommendedRules };
+//# sourceMappingURL=preset.d.ts.map

package/dist/types/preset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preset.d.ts","names":[],"sources":["../../src/preset.ts"],"mappings":";;;;cAIa;;cAGA;;;;;;;;;;;cAYA;;;;;;;;;;;;;;;;cAiBA,mBAAmB,QAC9B,OAAO,kBAAkB,OAAO;;;;;;;;cAcrB,2BAA0B,eAAe,OAAO"}

package/dist/types/rules/noUnusedContent.d.ts

@@ -0,0 +1,33 @@
+import { IntlayerRule } from "../utils/createRule.js";
+//#region src/rules/noUnusedContent.d.ts
+type NoUnusedContentOptions = {
+  /** Report a dictionary whose key is never referenced anywhere. Default: `true`. */
+  reportUnusedDictionaries?: boolean;
+  /** Report a content field that is never read anywhere. Default: `true`. */
+  reportUnusedFields?: boolean;
+  /**
+   * Report a dictionary key that is also declared elsewhere. Needs the unmerged
+   * dictionaries on disk, so it stays silent until the project has been built.
+   * Default: `true`.
+   */
+  reportDuplicateKeys?: boolean;
+  /** Regular-expression sources for field paths that are never reported. */
+  ignoreFields?: string[];
+  /**
+   * Project root the scan starts from. Defaults to ESLint's working directory,
+   * which is the right answer unless one lint run spans several Intlayer
+   * projects in a monorepo.
+   */
+  baseDir?: string;
+  /**
+   * How long one project scan is reused, in milliseconds. Lower it when linting
+   * from a long-lived editor server and you want edits reflected sooner; `0`
+   * rescans on every file. Default: `30000`.
+   */
+  cacheTtl?: number;
+};
+type MessageIds = 'unusedDictionary' | 'unusedField' | 'duplicateDictionary';
+declare const noUnusedContent: IntlayerRule<[NoUnusedContentOptions?], MessageIds>;
+//#endregion
+export { NoUnusedContentOptions, noUnusedContent };
+//# sourceMappingURL=noUnusedContent.d.ts.map

package/dist/types/rules/noUnusedContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noUnusedContent.d.ts","names":[],"sources":["../../../src/rules/noUnusedContent.ts"],"mappings":";;KAmBY;;EAEV;;EAEA;;;;;;EAMA;;EAEA;;;;;;EAMA;;;;;;EAMA;;KAGG;cAsDQ,iBAAe,cAAA,0BAAA"}

package/dist/types/utils/ast.d.ts

@@ -1,4 +1,4 @@
-import { Node } from "/Users/aymericpineau/Documents/intlayer_/node_modules/.bun/@types+estree@1.0.9/node_modules/@types/estree/index.js";
+import { Node } from "../node_modules/.bun/@types_estree@1.0.9/node_modules/@types/estree/index.js";
 //#region src/utils/ast.d.ts
 /**
  * Minimal structural models for the nodes this plugin inspects that are not

package/dist/types/utils/contentDeclaration.d.ts

@@ -0,0 +1,42 @@
+import { AstNode } from "./ast.js";
+//#region src/utils/contentDeclaration.d.ts
+/**
+ * Reading an Intlayer content declaration out of the file being linted.
+ *
+ * A declaration is any object literal carrying both a `key` and a `content`
+ * property — the same shape the VS Code extension looks for, which covers
+ * `export default { … }`, `const dictionary = { … } satisfies Dictionary` and
+ * every variant in between without caring how the object reaches the export.
+ */
+/** One field declared inside a dictionary's `content`. */
+type DeclaredField = {
+  /** Dotted path from the content root, e.g. `hero.title`. */
+  path: string;
+  /** The property key node, so a report points at the field name. */
+  keyNode: AstNode;
+};
+/** A dictionary declaration found in the linted file. */
+type ContentDeclaration = {
+  /** The static dictionary key. */
+  dictionaryKey: string;
+  /** The node holding the key, for reporting a fully unused dictionary. */
+  keyNode: AstNode;
+  /** Every field declared under `content`, depth-first. */
+  fields: DeclaredField[];
+  /**
+   * True when the content object holds a spread or a computed key, so the field
+   * list is not exhaustive. No field may be reported unused in that case — the
+   * missing entries could be exactly the ones being read.
+   */
+  isPartiallyEnumerated: boolean;
+};
+/**
+ * Read the dictionary declaration an object literal represents, or `null` when
+ * it is not one.
+ *
+ * @param objectExpression - Any `ObjectExpression` node from the linted file.
+ */
+declare const readContentDeclaration: (objectExpression: AstNode) => ContentDeclaration | null;
+//#endregion
+export { ContentDeclaration, DeclaredField, readContentDeclaration };
+//# sourceMappingURL=contentDeclaration.d.ts.map

package/dist/types/utils/contentDeclaration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contentDeclaration.d.ts","names":[],"sources":["../../../src/utils/contentDeclaration.ts"],"mappings":";;;;;;;;;;;KAaY;;EAEV;;EAEA,SAAS;;;KAIC;;EAEV;;EAEA,SAAS;;EAET,QAAQ;;;;;;EAMR;;;;;;;;cA+GW,yBACX,kBAAkB,YACjB"}