@tsrx/eslint-parser 0.3.25

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Dominic Gannaway
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,133 @@
+# @tsrx/eslint-parser
+
+[![npm version](https://img.shields.io/npm/v/%40tsrx%2Feslint-parser?logo=npm)](https://www.npmjs.com/package/@tsrx/eslint-parser)
+[![npm downloads](https://img.shields.io/npm/dm/%40tsrx%2Feslint-parser?logo=npm&label=downloads)](https://www.npmjs.com/package/@tsrx/eslint-parser)
+
+ESLint parser for Ripple component files. This parser enables ESLint to understand
+and lint `.tsrx` files by default, while also supporting `.tsrx` files through
+Ripple's built-in compiler.
+
+## Installation
+
+```bash
+pnpm add --save-dev '@tsrx/eslint-parser' ripple
+# or
+npm install --save-dev '@tsrx/eslint-parser' ripple
+# or
+yarn add --dev '@tsrx/eslint-parser' ripple
+```
+
+**Note:** This parser requires `ripple` as a peer dependency.
+
+## Usage
+
+### Flat Config (ESLint 9+)
+
+```js
+// eslint.config.js
+import rippleParser from '@tsrx/eslint-parser';
+import ripplePlugin from '@tsrx/eslint-plugin';
+
+export default [
+  {
+    files: ['**/*.{tsrx,ripple}'],
+    languageOptions: {
+      parser: rippleParser,
+    },
+    plugins: {
+      ripple: ripplePlugin,
+    },
+    rules: {
+      ...ripplePlugin.configs.recommended.rules,
+    },
+  },
+];
+```
+
+### Legacy Config (.eslintrc)
+
+```json
+{
+  "overrides": [
+    {
+      "files": ["*.tsrx", "*.tsrx"],
+      "parser": "@tsrx/eslint-parser",
+      "plugins": ["ripple"],
+      "extends": ["plugin:ripple/recommended"]
+    }
+  ]
+}
+```
+
+## How It Works
+
+This parser uses Ripple's compiler (`ripple/compiler`) to parse Ripple component
+files into an ESTree-compatible AST that ESLint can analyze. The Ripple compiler
+already outputs ESTree-compliant ASTs, making integration straightforward.
+
+The parser:
+
+1. Loads the Ripple compiler
+2. Parses the component source code (`.tsrx` or `.tsrx`)
+3. Returns the ESTree AST to ESLint
+4. Allows ESLint rules to analyze Ripple-specific patterns
+
+## Supported Syntax
+
+The parser supports all Ripple syntax including:
+
+- `component` declarations
+- `track()` reactive values (imported from `ripple`)
+- `@` unboxing operator
+- Reactive collections (`RippleArray`, `RippleObject`, etc.)
+- JSX-like templating inside components
+- All standard JavaScript/TypeScript syntax
+
+## Example
+
+Given a `.tsrx` file:
+
+```ripple
+import { track } from 'ripple';
+
+export component Counter() {
+  let count = track(0);
+
+  <div>
+    <button onClick={() => @count++}>Increment</button>
+    <span>{@count}</span>
+  </div>
+}
+```
+
+The parser will successfully parse this and allow ESLint rules (like those from
+`@tsrx/eslint-plugin`) to check for:
+
+- Track calls at module scope
+- Missing @ operators
+- Component export requirements
+- And more
+
+## Limitations
+
+- The parser requires Node.js runtime as it uses `require()` to load the Ripple
+  compiler
+- Browser-based linting is not currently supported
+
+## Related Packages
+
+- [@tsrx/eslint-plugin](https://www.npmjs.com/package/@tsrx/eslint-plugin) -
+  ESLint rules for Ripple
+- [ripple](https://ripplejs.com) - The Ripple framework
+- [@ripple-ts/vite-plugin](https://www.npmjs.com/package/@ripple-ts/vite-plugin) -
+  Vite plugin for Ripple
+- [@ripple-ts/prettier-plugin](https://www.npmjs.com/package/@ripple-ts/prettier-plugin) -
+  Prettier plugin for Ripple
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

package/dist/index.d.ts

@@ -0,0 +1,529 @@
+import { Linter } from "eslint";
+
+//#region ../../node_modules/.pnpm/@types+estree@1.0.8/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 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 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 | PrivateIdentifier;
+  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;
+}
+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 {}
+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
+//#region src/index.d.ts
+interface ParseResult {
+  ast: Program;
+  services?: Record<string, any>;
+  scopeManager?: any;
+  visitorKeys?: Record<string, string[]>;
+}
+/**
+ * ESLint parser for Ripple (.tsrx) files
+ *
+ * This parser uses Ripple's built-in compiler to parse .tsrx files
+ * and returns an ESTree-compatible AST for ESLint to analyze.
+ */
+declare function parseForESLint(code: string, options?: Linter.ParserOptions): ParseResult;
+/**
+ * Legacy parse function for older ESLint versions
+ */
+declare function parse(code: string, options?: Linter.ParserOptions): Program;
+declare global {
+  var __RIPPLE_COMPILER__: {
+    parse: (source: string) => Program;
+    compile: (source: string, filename: string, options?: any) => any;
+  };
+}
+declare const _default: {
+  parseForESLint: typeof parseForESLint;
+  parse: typeof parse;
+};
+//#endregion
+export { _default as default, parse, parseForESLint };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["BaseNodeWithoutComments","SourceLocation","type","loc","range","BaseNode","Comment","leadingComments","trailingComments","NodeMap","AssignmentProperty","CatchClause","Class","ClassBody","Expression","Function","Identifier","Literal","MethodDefinition","ModuleDeclaration","ModuleSpecifier","Pattern","PrivateIdentifier","Program","Property","PropertyDefinition","SpreadElement","Statement","Super","SwitchCase","TemplateElement","VariableDeclarator","Node","value","Position","source","start","end","line","column","Directive","Array","sourceType","body","comments","expression","directive","BaseFunction","BlockStatement","params","generator","async","FunctionDeclaration","FunctionExpression","ArrowFunctionExpression","ExpressionStatement","StaticBlock","EmptyStatement","DebuggerStatement","WithStatement","ReturnStatement","LabeledStatement","BreakStatement","ContinueStatement","IfStatement","SwitchStatement","ThrowStatement","TryStatement","WhileStatement","DoWhileStatement","ForStatement","ForInStatement","ForOfStatement","Declaration","BaseStatement","innerComments","Omit","test","consequent","alternate","label","object","discriminant","cases","argument","block","handler","finalizer","VariableDeclaration","init","update","BaseForXStatement","left","right","ClassDeclaration","BaseDeclaration","MaybeNamedFunctionDeclaration","id","declarations","kind","ExpressionMap","ArrayExpression","AssignmentExpression","AwaitExpression","BinaryExpression","CallExpression","ChainExpression","ClassExpression","ConditionalExpression","ImportExpression","LogicalExpression","MemberExpression","MetaProperty","NewExpression","ObjectExpression","SequenceExpression","TaggedTemplateExpression","TemplateLiteral","ThisExpression","UnaryExpression","UpdateExpression","YieldExpression","BaseExpression","ChainElement","SimpleCallExpression","elements","properties","name","key","method","shorthand","computed","static","expressions","UnaryOperator","operator","prefix","BinaryOperator","AssignmentOperator","UpdateOperator","LogicalOperator","BaseCallExpression","callee","arguments","optional","BasePattern","property","ObjectPattern","ArrayPattern","RestElement","AssignmentPattern","param","SimpleLiteral","RegExpLiteral","BigIntLiteral","raw","RegExp","regex","pattern","flags","bigint","await","delegate","quasis","tag","quasi","tail","cooked","BaseClass","superClass","MaybeNamedClassDeclaration","meta","ImportDeclaration","ExportNamedDeclaration","ExportDefaultDeclaration","ExportAllDeclaration","BaseModuleDeclaration","ImportSpecifier","ImportDefaultSpecifier","ImportNamespaceSpecifier","ExportSpecifier","BaseModuleSpecifier","local","ImportAttribute","specifiers","attributes","imported","options","declaration","exported"],"sources":["../../../node_modules/.pnpm/@types+estree@1.0.8/node_modules/@types/estree/index.d.ts","../src/index.ts"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,150 @@
+import { createRequire } from "module";
+
+//#region src/index.ts
+/**
+* The Ripple compiler's AST contains some redundant references (e.g. `Element.attributes`
+* and `Element.openingElement.attributes`) that are useful for formatters/source-maps.
+* ESLint's traverser will visit both paths and can trigger duplicate rule reports.
+*
+* For ESLint, we prune JSX wrapper nodes to keep a single traversal path.
+*/
+function normalizeRippleAstForEslint(ast) {
+	const seen = /* @__PURE__ */ new Set();
+	const visit = (node) => {
+		if (!node || typeof node !== "object") return;
+		if (seen.has(node)) return;
+		seen.add(node);
+		if (node.type === "Element") {
+			delete node.openingElement;
+			delete node.closingElement;
+		}
+		for (const key of Object.keys(node)) {
+			if (key === "parent" || key === "loc" || key === "range") continue;
+			const value = node[key];
+			if (Array.isArray(value)) for (const child of value) visit(child);
+			else if (value && typeof value === "object") visit(value);
+		}
+	};
+	visit(ast);
+}
+/**
+* Recursively walks the AST and ensures all nodes have range and loc properties
+* ESLint's scope analyzer requires these properties on ALL nodes
+*/
+function ensureNodeProperties(node, code) {
+	if (!node || typeof node !== "object") return;
+	if (node.start !== void 0 && node.end !== void 0 && !node.range) node.range = [node.start, node.end];
+	if (!node.loc && node.start !== void 0 && node.end !== void 0) {
+		const lines = code.split("\n");
+		let currentPos = 0;
+		let startLine = 1;
+		let startColumn = 0;
+		let endLine = 1;
+		let endColumn = 0;
+		for (let i = 0; i < lines.length; i++) {
+			const lineLength = lines[i].length + 1;
+			if (currentPos + lineLength > node.start) {
+				startLine = i + 1;
+				startColumn = node.start - currentPos;
+				break;
+			}
+			currentPos += lineLength;
+		}
+		currentPos = 0;
+		for (let i = 0; i < lines.length; i++) {
+			const lineLength = lines[i].length + 1;
+			if (currentPos + lineLength > node.end) {
+				endLine = i + 1;
+				endColumn = node.end - currentPos;
+				break;
+			}
+			currentPos += lineLength;
+		}
+		node.loc = {
+			start: {
+				line: startLine,
+				column: startColumn
+			},
+			end: {
+				line: endLine,
+				column: endColumn
+			}
+		};
+	}
+	for (const key in node) {
+		if (key === "parent" || key === "loc" || key === "range") continue;
+		const value = node[key];
+		if (Array.isArray(value)) value.forEach((child) => ensureNodeProperties(child, code));
+		else if (value && typeof value === "object" && value.type) ensureNodeProperties(value, code);
+	}
+}
+/**
+* ESLint parser for Ripple (.tsrx) files
+*
+* This parser uses Ripple's built-in compiler to parse .tsrx files
+* and returns an ESTree-compatible AST for ESLint to analyze.
+*/
+function parseForESLint(code, options) {
+	try {
+		const ast = requireRippleCompiler().parse(code);
+		if (!ast) throw new Error("Parser returned null or undefined AST");
+		normalizeRippleAstForEslint(ast);
+		ensureNodeProperties(ast, code);
+		return {
+			ast: {
+				type: ast.type || "Program",
+				start: ast.start !== void 0 ? ast.start : 0,
+				end: ast.end !== void 0 ? ast.end : code.length,
+				loc: ast.loc || {
+					start: {
+						line: 1,
+						column: 0
+					},
+					end: {
+						line: code.split("\n").length,
+						column: 0
+					}
+				},
+				range: ast.range || [0, code.length],
+				body: ast.body || [],
+				sourceType: ast.sourceType || "module",
+				comments: ast.comments || [],
+				tokens: ast.tokens || []
+			},
+			services: {},
+			visitorKeys: void 0
+		};
+	} catch (error) {
+		throw new SyntaxError(`Failed to parse Ripple file: ${error.message || error}`);
+	}
+}
+/**
+* Legacy parse function for older ESLint versions
+*/
+function parse(code, options) {
+	return parseForESLint(code, options).ast;
+}
+/**
+* Helper to require the Ripple compiler
+* This handles both CommonJS and ESM environments
+*/
+function requireRippleCompiler() {
+	const globalRipple = globalThis.__RIPPLE_COMPILER__;
+	if (globalRipple && globalRipple.parse) return globalRipple;
+	try {
+		const ripple = createRequire(import.meta.url)("@tsrx/ripple");
+		if (!ripple || !ripple.parse) throw new Error("Ripple compiler loaded but parse function not found.");
+		globalThis.__RIPPLE_COMPILER__ = ripple;
+		return ripple;
+	} catch (error) {
+		throw new Error(`Failed to load Ripple compiler: ${error.message}. Make sure the "@tsrx/ripple" package is installed as a peer dependency.`);
+	}
+}
+var src_default = {
+	parseForESLint,
+	parse
+};
+
+//#endregion
+export { src_default as default, parse, parseForESLint };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["import type { Program } from 'estree';\nimport type { Linter } from 'eslint';\nimport { createRequire } from 'module';\n\ninterface ParseResult {\n\tast: Program;\n\tservices?: Record<string, any>;\n\tscopeManager?: any;\n\tvisitorKeys?: Record<string, string[]>;\n}\n\n/**\n * The Ripple compiler's AST contains some redundant references (e.g. `Element.attributes`\n * and `Element.openingElement.attributes`) that are useful for formatters/source-maps.\n * ESLint's traverser will visit both paths and can trigger duplicate rule reports.\n *\n * For ESLint, we prune JSX wrapper nodes to keep a single traversal path.\n */\nfunction normalizeRippleAstForEslint(ast: any): void {\n\tconst seen = new Set<any>();\n\tconst visit = (node: any) => {\n\t\tif (!node || typeof node !== 'object') return;\n\t\tif (seen.has(node)) return;\n\t\tseen.add(node);\n\n\t\tif (node.type === 'Element') {\n\t\t\t// Avoid duplicate traversal of attributes/children through openingElement/closingElement.\n\t\t\t// The Element node itself carries the data ESLint rules care about.\n\t\t\tdelete node.openingElement;\n\t\t\tdelete node.closingElement;\n\t\t}\n\n\t\tfor (const key of Object.keys(node)) {\n\t\t\tif (key === 'parent' || key === 'loc' || key === 'range') continue;\n\t\t\tconst value = node[key];\n\t\t\tif (Array.isArray(value)) {\n\t\t\t\tfor (const child of value) visit(child);\n\t\t\t} else if (value && typeof value === 'object') {\n\t\t\t\tvisit(value);\n\t\t\t}\n\t\t}\n\t};\n\n\tvisit(ast);\n}\n\n/**\n * Recursively walks the AST and ensures all nodes have range and loc properties\n * ESLint's scope analyzer requires these properties on ALL nodes\n */\nfunction ensureNodeProperties(node: any, code: string): void {\n\tif (!node || typeof node !== 'object') {\n\t\treturn;\n\t}\n\n\t// Ensure range property exists\n\tif (node.start !== undefined && node.end !== undefined && !node.range) {\n\t\tnode.range = [node.start, node.end];\n\t}\n\n\t// Ensure loc property exists\n\tif (!node.loc && node.start !== undefined && node.end !== undefined) {\n\t\tconst lines = code.split('\\n');\n\t\tlet currentPos = 0;\n\t\tlet startLine = 1;\n\t\tlet startColumn = 0;\n\t\tlet endLine = 1;\n\t\tlet endColumn = 0;\n\n\t\tfor (let i = 0; i < lines.length; i++) {\n\t\t\tconst lineLength = lines[i].length + 1;\n\t\t\tif (currentPos + lineLength > node.start) {\n\t\t\t\tstartLine = i + 1;\n\t\t\t\tstartColumn = node.start - currentPos;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tcurrentPos += lineLength;\n\t\t}\n\n\t\tcurrentPos = 0;\n\t\tfor (let i = 0; i < lines.length; i++) {\n\t\t\tconst lineLength = lines[i].length + 1;\n\t\t\tif (currentPos + lineLength > node.end) {\n\t\t\t\tendLine = i + 1;\n\t\t\t\tendColumn = node.end - currentPos;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tcurrentPos += lineLength;\n\t\t}\n\n\t\tnode.loc = {\n\t\t\tstart: { line: startLine, column: startColumn },\n\t\t\tend: { line: endLine, column: endColumn },\n\t\t};\n\t}\n\n\tfor (const key in node) {\n\t\tif (key === 'parent' || key === 'loc' || key === 'range') {\n\t\t\tcontinue; // Skip these to avoid infinite loops\n\t\t}\n\n\t\tconst value = node[key];\n\t\tif (Array.isArray(value)) {\n\t\t\tvalue.forEach((child) => ensureNodeProperties(child, code));\n\t\t} else if (value && typeof value === 'object' && value.type) {\n\t\t\tensureNodeProperties(value, code);\n\t\t}\n\t}\n}\n\n/**\n * ESLint parser for Ripple (.tsrx) files\n *\n * This parser uses Ripple's built-in compiler to parse .tsrx files\n * and returns an ESTree-compatible AST for ESLint to analyze.\n */\nexport function parseForESLint(code: string, options?: Linter.ParserOptions): ParseResult {\n\ttry {\n\t\t// Dynamically import the Ripple compiler\n\t\t// We use dynamic import to avoid bundling the entire compiler\n\t\tconst rippleCompiler = requireRippleCompiler();\n\n\t\t// Parse the Ripple source code using the Ripple compiler\n\t\tconst ast = rippleCompiler.parse(code);\n\t\tif (!ast) throw new Error('Parser returned null or undefined AST');\n\n\t\t// Normalize for ESLint traversal (avoid duplicate node visits)\n\t\tnormalizeRippleAstForEslint(ast);\n\n\t\t// Recursively ensure all nodes have range and loc properties\n\t\tensureNodeProperties(ast, code);\n\n\t\t// Create a properly structured AST object ensuring all required properties exist\n\t\tconst result: any = {\n\t\t\ttype: ast.type || 'Program',\n\t\t\tstart: ast.start !== undefined ? ast.start : 0,\n\t\t\tend: ast.end !== undefined ? ast.end : code.length,\n\t\t\tloc: ast.loc || {\n\t\t\t\tstart: { line: 1, column: 0 },\n\t\t\t\tend: { line: code.split('\\n').length, column: 0 },\n\t\t\t},\n\t\t\trange: ast.range || [0, code.length],\n\t\t\tbody: ast.body || [],\n\t\t\tsourceType: ast.sourceType || 'module',\n\t\t\tcomments: ast.comments || [],\n\t\t\ttokens: ast.tokens || [],\n\t\t};\n\n\t\treturn {\n\t\t\tast: result,\n\t\t\tservices: {},\n\t\t\tvisitorKeys: undefined, // Use ESLint's default visitor keys\n\t\t};\n\t} catch (error: any) {\n\t\t// Transform Ripple parse errors to ESLint-compatible format\n\t\tthrow new SyntaxError(`Failed to parse Ripple file: ${error.message || error}`);\n\t}\n}\n\n/**\n * Legacy parse function for older ESLint versions\n */\nexport function parse(code: string, options?: Linter.ParserOptions): Program {\n\tconst result = parseForESLint(code, options);\n\treturn result.ast;\n}\n\n/**\n * Helper to require the Ripple compiler\n * This handles both CommonJS and ESM environments\n */\nfunction requireRippleCompiler(): any {\n\tconst globalRipple = (globalThis as any).__RIPPLE_COMPILER__;\n\tif (globalRipple && globalRipple.parse) {\n\t\treturn globalRipple;\n\t}\n\n\ttry {\n\t\t// Use createRequire to dynamically require the module\n\t\t// This works in both ESM and CommonJS contexts\n\t\tconst require = createRequire(import.meta.url);\n\t\tconst ripple = require('@tsrx/ripple');\n\n\t\tif (!ripple || !ripple.parse) {\n\t\t\tthrow new Error('Ripple compiler loaded but parse function not found.');\n\t\t}\n\n\t\t(globalThis as any).__RIPPLE_COMPILER__ = ripple;\n\n\t\treturn ripple;\n\t} catch (error: any) {\n\t\tthrow new Error(\n\t\t\t`Failed to load Ripple compiler: ${error.message}. ` +\n\t\t\t\t'Make sure the \"@tsrx/ripple\" package is installed as a peer dependency.',\n\t\t);\n\t}\n}\n\ndeclare global {\n\tvar __RIPPLE_COMPILER__: {\n\t\tparse: (source: string) => Program;\n\t\tcompile: (source: string, filename: string, options?: any) => any;\n\t};\n}\n\nexport default {\n\tparseForESLint,\n\tparse,\n};\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@tsrx/eslint-parser",
+  "version": "0.3.25",
+  "description": "ESLint parser for Ripple (.tsrx files)",
+  "type": "module",
+  "main": "src/index.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Ripple-TS/ripple.git",
+    "directory": "packages/eslint-parser"
+  },
+  "bugs": {
+    "url": "https://github.com/Ripple-TS/ripple/issues"
+  },
+  "homepage": "https://ripple-ts.com",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "eslint",
+    "parser",
+    "ripple"
+  ],
+  "author": "Dominic Gannaway",
+  "license": "MIT",
+  "peerDependencies": {
+    "eslint": ">=9.0.0",
+    "ripple": "*"
+  },
+  "dependencies": {
+    "@tsrx/ripple": "0.0.6"
+  },
+  "devDependencies": {
+    "@types/eslint": "^9.6.1",
+    "@types/estree": "^1.0.8",
+    "@types/node": "^24.3.0",
+    "tsdown": "^0.20.3",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "scripts": {
+    "dist": "perl -pi -e 's/\"main\": \"src\\/index.ts\"/\"main\": \"dist\\/index.js\"/' package.json",
+    "src": "perl -pi -e 's/\"main\": \"dist\\/index.js\"/\"main\": \"src\\/index.ts\"/' package.json",
+    "build": "pnpm dist && tsdown && pnpm src || pnpm src"
+  }
+}

package/src/index.ts

@@ -0,0 +1,209 @@
+import type { Program } from 'estree';
+import type { Linter } from 'eslint';
+import { createRequire } from 'module';
+
+interface ParseResult {
+	ast: Program;
+	services?: Record<string, any>;
+	scopeManager?: any;
+	visitorKeys?: Record<string, string[]>;
+}
+
+/**
+ * The Ripple compiler's AST contains some redundant references (e.g. `Element.attributes`
+ * and `Element.openingElement.attributes`) that are useful for formatters/source-maps.
+ * ESLint's traverser will visit both paths and can trigger duplicate rule reports.
+ *
+ * For ESLint, we prune JSX wrapper nodes to keep a single traversal path.
+ */
+function normalizeRippleAstForEslint(ast: any): void {
+	const seen = new Set<any>();
+	const visit = (node: any) => {
+		if (!node || typeof node !== 'object') return;
+		if (seen.has(node)) return;
+		seen.add(node);
+
+		if (node.type === 'Element') {
+			// Avoid duplicate traversal of attributes/children through openingElement/closingElement.
+			// The Element node itself carries the data ESLint rules care about.
+			delete node.openingElement;
+			delete node.closingElement;
+		}
+
+		for (const key of Object.keys(node)) {
+			if (key === 'parent' || key === 'loc' || key === 'range') continue;
+			const value = node[key];
+			if (Array.isArray(value)) {
+				for (const child of value) visit(child);
+			} else if (value && typeof value === 'object') {
+				visit(value);
+			}
+		}
+	};
+
+	visit(ast);
+}
+
+/**
+ * Recursively walks the AST and ensures all nodes have range and loc properties
+ * ESLint's scope analyzer requires these properties on ALL nodes
+ */
+function ensureNodeProperties(node: any, code: string): void {
+	if (!node || typeof node !== 'object') {
+		return;
+	}
+
+	// Ensure range property exists
+	if (node.start !== undefined && node.end !== undefined && !node.range) {
+		node.range = [node.start, node.end];
+	}
+
+	// Ensure loc property exists
+	if (!node.loc && node.start !== undefined && node.end !== undefined) {
+		const lines = code.split('\n');
+		let currentPos = 0;
+		let startLine = 1;
+		let startColumn = 0;
+		let endLine = 1;
+		let endColumn = 0;
+
+		for (let i = 0; i < lines.length; i++) {
+			const lineLength = lines[i].length + 1;
+			if (currentPos + lineLength > node.start) {
+				startLine = i + 1;
+				startColumn = node.start - currentPos;
+				break;
+			}
+			currentPos += lineLength;
+		}
+
+		currentPos = 0;
+		for (let i = 0; i < lines.length; i++) {
+			const lineLength = lines[i].length + 1;
+			if (currentPos + lineLength > node.end) {
+				endLine = i + 1;
+				endColumn = node.end - currentPos;
+				break;
+			}
+			currentPos += lineLength;
+		}
+
+		node.loc = {
+			start: { line: startLine, column: startColumn },
+			end: { line: endLine, column: endColumn },
+		};
+	}
+
+	for (const key in node) {
+		if (key === 'parent' || key === 'loc' || key === 'range') {
+			continue; // Skip these to avoid infinite loops
+		}
+
+		const value = node[key];
+		if (Array.isArray(value)) {
+			value.forEach((child) => ensureNodeProperties(child, code));
+		} else if (value && typeof value === 'object' && value.type) {
+			ensureNodeProperties(value, code);
+		}
+	}
+}
+
+/**
+ * ESLint parser for Ripple (.tsrx) files
+ *
+ * This parser uses Ripple's built-in compiler to parse .tsrx files
+ * and returns an ESTree-compatible AST for ESLint to analyze.
+ */
+export function parseForESLint(code: string, options?: Linter.ParserOptions): ParseResult {
+	try {
+		// Dynamically import the Ripple compiler
+		// We use dynamic import to avoid bundling the entire compiler
+		const rippleCompiler = requireRippleCompiler();
+
+		// Parse the Ripple source code using the Ripple compiler
+		const ast = rippleCompiler.parse(code);
+		if (!ast) throw new Error('Parser returned null or undefined AST');
+
+		// Normalize for ESLint traversal (avoid duplicate node visits)
+		normalizeRippleAstForEslint(ast);
+
+		// Recursively ensure all nodes have range and loc properties
+		ensureNodeProperties(ast, code);
+
+		// Create a properly structured AST object ensuring all required properties exist
+		const result: any = {
+			type: ast.type || 'Program',
+			start: ast.start !== undefined ? ast.start : 0,
+			end: ast.end !== undefined ? ast.end : code.length,
+			loc: ast.loc || {
+				start: { line: 1, column: 0 },
+				end: { line: code.split('\n').length, column: 0 },
+			},
+			range: ast.range || [0, code.length],
+			body: ast.body || [],
+			sourceType: ast.sourceType || 'module',
+			comments: ast.comments || [],
+			tokens: ast.tokens || [],
+		};
+
+		return {
+			ast: result,
+			services: {},
+			visitorKeys: undefined, // Use ESLint's default visitor keys
+		};
+	} catch (error: any) {
+		// Transform Ripple parse errors to ESLint-compatible format
+		throw new SyntaxError(`Failed to parse Ripple file: ${error.message || error}`);
+	}
+}
+
+/**
+ * Legacy parse function for older ESLint versions
+ */
+export function parse(code: string, options?: Linter.ParserOptions): Program {
+	const result = parseForESLint(code, options);
+	return result.ast;
+}
+
+/**
+ * Helper to require the Ripple compiler
+ * This handles both CommonJS and ESM environments
+ */
+function requireRippleCompiler(): any {
+	const globalRipple = (globalThis as any).__RIPPLE_COMPILER__;
+	if (globalRipple && globalRipple.parse) {
+		return globalRipple;
+	}
+
+	try {
+		// Use createRequire to dynamically require the module
+		// This works in both ESM and CommonJS contexts
+		const require = createRequire(import.meta.url);
+		const ripple = require('@tsrx/ripple');
+
+		if (!ripple || !ripple.parse) {
+			throw new Error('Ripple compiler loaded but parse function not found.');
+		}
+
+		(globalThis as any).__RIPPLE_COMPILER__ = ripple;
+
+		return ripple;
+	} catch (error: any) {
+		throw new Error(
+			`Failed to load Ripple compiler: ${error.message}. ` +
+				'Make sure the "@tsrx/ripple" package is installed as a peer dependency.',
+		);
+	}
+}
+
+declare global {
+	var __RIPPLE_COMPILER__: {
+		parse: (source: string) => Program;
+		compile: (source: string, filename: string, options?: any) => any;
+	};
+}
+
+export default {
+	parseForESLint,
+	parse,
+};