eslint-plugin-intlayer 9.3.1 → 9.3.3

package/dist/esm/utils/reactVersion.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactVersion.mjs","names":[],"sources":["../../../src/utils/reactVersion.ts"],"sourcesContent":["import fs from 'node:fs';\nimport path from 'node:path';\n\n/**\n * Detect the installed React version for ESLint configuration.\n *\n * `eslint-plugin-react` versions <= 7.37.5 rely on `context.getFilename()` to detect\n * the React version when `settings.react.version` is set to `\"detect\"`.\n * Because ESLint 10 removed `context.getFilename()`, every `react/*` rule throws on load\n * when `settings.react.version` is `\"detect\"`.\n *\n * Specifying an explicit detected React version in `settings.react.version`\n * bypasses the broken `detectReactVersion` codepath in `eslint-plugin-react`, allowing\n * Next.js and React projects using `eslint-config-next` / `eslint-plugin-react` to work\n * seamlessly under both ESLint 9 and ESLint 10 without needing manual configuration hacks.\n */\nexport const getReactVersion = (dir = process.cwd()): string => {\n  try {\n    let currentDir = dir;\n    while (currentDir) {\n      const reactPkgPath = path.join(\n        currentDir,\n        'node_modules',\n        'react',\n        'package.json'\n      );\n      if (fs.existsSync(reactPkgPath)) {\n        const pkg = JSON.parse(fs.readFileSync(reactPkgPath, 'utf8'));\n        if (pkg.version) {\n          return pkg.version;\n        }\n      }\n\n      const pkgJsonPath = path.join(currentDir, 'package.json');\n      if (fs.existsSync(pkgJsonPath)) {\n        const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));\n        const reactDep =\n          pkg.dependencies?.react ||\n          pkg.devDependencies?.react ||\n          pkg.peerDependencies?.react;\n        if (typeof reactDep === 'string') {\n          const match = reactDep.match(/\\d+(\\.\\d+)*/);\n          if (match) {\n            return match[0];\n          }\n        }\n      }\n\n      const parentDir = path.dirname(currentDir);\n      if (parentDir === currentDir) break;\n      currentDir = parentDir;\n    }\n  } catch {}\n\n  return '19.0';\n};\n"],"mappings":";;;;;;;;;;;;;;;;;AAgBA,MAAa,mBAAmB,MAAM,QAAQ,IAAI,MAAc;CAC9D,IAAI;EACF,IAAI,aAAa;EACjB,OAAO,YAAY;GACjB,MAAM,eAAe,KAAK,KACxB,YACA,gBACA,SACA,cACF;GACA,IAAI,GAAG,WAAW,YAAY,GAAG;IAC/B,MAAM,MAAM,KAAK,MAAM,GAAG,aAAa,cAAc,MAAM,CAAC;IAC5D,IAAI,IAAI,SACN,OAAO,IAAI;GAEf;GAEA,MAAM,cAAc,KAAK,KAAK,YAAY,cAAc;GACxD,IAAI,GAAG,WAAW,WAAW,GAAG;IAC9B,MAAM,MAAM,KAAK,MAAM,GAAG,aAAa,aAAa,MAAM,CAAC;IAC3D,MAAM,WACJ,IAAI,cAAc,SAClB,IAAI,iBAAiB,SACrB,IAAI,kBAAkB;IACxB,IAAI,OAAO,aAAa,UAAU;KAChC,MAAM,QAAQ,SAAS,MAAM,aAAa;KAC1C,IAAI,OACF,OAAO,MAAM;IAEjB;GACF;GAEA,MAAM,YAAY,KAAK,QAAQ,UAAU;GACzC,IAAI,cAAc,YAAY;GAC9B,aAAa;EACf;CACF,QAAQ,CAAC;CAET,OAAO;AACT"}

package/dist/types/index.d.ts

@@ -1,17 +1,23 @@
 import { IntlayerRule } from "./utils/createRule.js";
+import { GENERATED_OUTPUT_GLOBS, PLUGIN_NAMESPACE, PLUGIN_PACKAGE_NAME, RECOMMENDED_RULES, getRecommendedRules } from "./preset.js";
 import { NoRawTextOptions } from "./rules/noRawText.js";
+import { NoUnusedContentOptions } from "./rules/noUnusedContent.js";
+import { getReactVersion } from "./utils/reactVersion.js";
 import "./index.js";
 import { ESLint, Linter } from "eslint";
 //#region src/index.d.ts
 /**
  * Every rule this plugin ships, keyed by the name used in configuration.
  *
- * The rules split into two families:
+ * The rules split into three families:
  * - **Coverage** (`no-raw-text`) — user-facing copy that never reached a
  *   dictionary. Nothing else in the toolchain reports it.
  * - **Compiler contract** (`static-dictionary-key`, `no-dynamic-field-access`)
  *   — call shapes that type-check and run, but that the Babel/SWC passes cannot
  *   analyse, so they silently lose the optimize pass or read a purged field.
+ * - **Dead content** (`no-unused-content`) — dictionaries and fields nothing
+ *   reads. Off in every preset: it is the only rule that scans the whole
+ *   project from disk, so enabling it is a cost the user should opt into.
  *
  * Deliberately absent: unknown dictionary keys, unknown field paths and missing
  * required locales. The generated `__DictionaryRegistry` module augmentation
@@ -23,6 +29,7 @@ declare const rules: {
   'static-dictionary-key': IntlayerRule<[], "dynamicKey" | "dynamicTemplateKey" | "dynamicJsxKey">;
   'no-dynamic-field-access': IntlayerRule<[], "dynamicField" | "dynamicMessageId">;
   'enforce-adapter-import': IntlayerRule<[], "useAdapterImport">;
+  'no-unused-content': IntlayerRule<[NoUnusedContentOptions?], "unusedDictionary" | "unusedField" | "duplicateDictionary">;
 };
 /** Rule names this plugin exposes. */
 type IntlayerRuleName = keyof typeof rules;
@@ -38,7 +45,7 @@ type IntlayerConfigName = 'recommended' | 'strict' | 'contract-only';
  * ```js
  * import intlayer from 'eslint-plugin-intlayer';
  *
- * export default [intlayer.configs.recommended];
+ * export default [...intlayer]; // or [...intlayer.configs.recommended]
  * ```
  *
  * - `recommended` — the compiler-contract rules as errors, plus `no-raw-text`
@@ -50,18 +57,24 @@ type IntlayerConfigName = 'recommended' | 'strict' | 'contract-only';
  * `enforce-adapter-import` is opt-in: importing from the original package is
  * perfectly valid once the bundler alias is set up, so a project that has done
  * that should not be nagged. Only `strict` turns it on.
+ *
+ * `no-unused-content` is in no preset at all, `strict` included. It reads the
+ * Intlayer configuration and walks the project's source files from disk, which
+ * is a different order of cost from the AST-only rules and depends on build
+ * output for its duplicate report — spreading a preset should never quietly
+ * turn that on.
  */
-declare const configs: Record<IntlayerConfigName, Linter.Config>;
+declare const configs: Record<IntlayerConfigName, Linter.Config[]>;
 /** The plugin object, as consumed by `eslint.config.js`. */
-type IntlayerPlugin = ESLint.Plugin & {
+type IntlayerPlugin = ESLint.Plugin & Iterable<Linter.Config> & {
   meta: {
     name: string;
     version: string;
   };
   rules: typeof rules;
-  configs: Record<IntlayerConfigName, Linter.Config>;
+  configs: Record<IntlayerConfigName, Linter.Config[]>;
 };
 declare const intlayerPlugin: IntlayerPlugin;
 //#endregion
-export { IntlayerConfigName, IntlayerPlugin, IntlayerRuleName, type NoRawTextOptions, configs, intlayerPlugin as default, meta, rules };
+export { GENERATED_OUTPUT_GLOBS, IntlayerConfigName, IntlayerPlugin, IntlayerRuleName, type NoRawTextOptions, type NoUnusedContentOptions, PLUGIN_NAMESPACE, PLUGIN_PACKAGE_NAME, RECOMMENDED_RULES, configs, intlayerPlugin as default, getReactVersion, getRecommendedRules, meta, rules };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;cAwBa;+BAAA;;;;;;KAQD,gCAAgC;cAEtC;EAAQ;EAAc;;;KAQhB;;;;;;;;;;;;;;;;;;;;cAyCC,SAAS,OAAO,oBAAoB,OAAO;;KAiC5C,iBAAiB,OAAO;EAClC;IAAQ;IAAc;;EACtB,cAAc;EACd,SAAS,OAAO,oBAAoB,OAAO;;cAGvC,gBAAgB"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;cA+Ba;+BAAA;;;;;;;KASD,gCAAgC;cAEtC;EAAQ;EAAc;;;KAQhB;;;;;;;;;;;;;;;;;;;;;;;;;;cA4DC,SAAS,OAAO,oBAAoB,OAAO;;KA2B5C,iBAAiB,OAAO,SAClC,SAAS,OAAO;EACd;IAAQ;IAAc;;EACtB,cAAc;EACd,SAAS,OAAO,oBAAoB,OAAO;;cAGzC,gBAAgB"}

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/enforceAdapterImport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"enforceAdapterImport.d.ts","names":[],"sources":["../../../src/rules/enforceAdapterImport.ts"],"mappings":";;cAuDa,sBAAA"}
+{"version":3,"file":"enforceAdapterImport.d.ts","names":[],"sources":["../../../src/rules/enforceAdapterImport.ts"],"mappings":";;cA8Da,sBAAA"}