refactor: major refactoring (#291)

Author: fisker

.eslintrc.cjs

@@ -11,7 +11,7 @@ module.exports = {
     ecmaVersion: 'latest',
     sourceType: 'module',
   },
-  plugins: ['@typescript-eslint', 'import', 'unicorn'],
+  plugins: ['simple-import-sort', '@typescript-eslint', 'import', 'unicorn'],
   env: { node: true },
   rules: {
     '@typescript-eslint/no-namespace': 'off',
@@ -23,6 +23,8 @@ module.exports = {
     ],
     'no-constant-condition': ['error', { checkLoops: false }],
     'import/extensions': ['error', 'always'],
+    'simple-import-sort/imports': 'error',
+    'simple-import-sort/exports': 'error',
     'unicorn/prefer-at': 'error',
   },
   overrides: [

.vscode/extensions.json

@@ -0,0 +1,8 @@
+{
+  "recommendations": [
+    "esbenp.prettier-vscode",
+    "editorconfig.editorconfig",
+    "dbaeumer.vscode-eslint",
+    "streetsidesoftware.code-spell-checker"
+  ]
+}

.vscode/settings.json

@@ -0,0 +1,17 @@
+{
+  "[javascript][typescript]": {
+    "editor.codeActionsOnSave": ["source.fixAll.eslint"]
+  },
+  "[javascript][typescript][markdown][json][jsonc][yaml]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode",
+    "editor.formatOnSave": true
+  },
+  "editor.codeActionsOnSave": {
+    "source.fixAll.eslint": "explicit"
+  },
+  "prettier.requireConfig": true,
+  // "eslint.experimental.useFlatConfig": true,
+  "files.exclude": {
+    "lib": true
+  }
+}

package.json

@@ -40,6 +40,7 @@
     "eslint-config-prettier": "9.1.0",
     "eslint-plugin-deprecation": "2.0.0",
     "eslint-plugin-import": "2.29.1",
+    "eslint-plugin-simple-import-sort": "12.0.0",
     "eslint-plugin-unicorn": "51.0.1",
     "jest": "29.7.0",
     "jest-snapshot-serializer-raw": "1.2.0",

src/angular-parser.ts

@@ -0,0 +1,83 @@
+import {
+  type ASTWithSource,
+  Lexer,
+  Parser,
+  type TemplateBindingParseResult,
+} from '@angular/compiler';
+
+import { type CommentLine } from './types.js';
+import { sourceSpanToLocationInformation } from './utils.js';
+
+const getCommentStart = (text: string): number | null =>
+  // @ts-expect-error -- need to call private _commentStart
+  Parser.prototype._commentStart(text);
+
+function extractComments(text: string, shouldExtractComment: boolean) {
+  const commentStart = shouldExtractComment ? getCommentStart(text) : null;
+
+  if (commentStart === null) {
+    return { text, comments: [] };
+  }
+
+  const comment: CommentLine = {
+    type: 'CommentLine',
+    value: text.slice(commentStart + '//'.length),
+    ...sourceSpanToLocationInformation({
+      start: commentStart,
+      end: text.length,
+    }),
+  };
+
+  return {
+    text: text.slice(0, commentStart),
+    comments: [comment],
+  };
+}
+
+function createAngularParseFunction<
+  T extends ASTWithSource | TemplateBindingParseResult,
+>(parse: (text: string, parser: Parser) => T, shouldExtractComment = true) {
+  return (originalText: string) => {
+    const lexer = new Lexer();
+    const parser = new Parser(lexer);
+
+    const { text, comments } = extractComments(
+      originalText,
+      shouldExtractComment,
+    );
+    const result = parse(text, parser);
+
+    if (result.errors.length !== 0) {
+      const [{ message }] = result.errors;
+      throw new SyntaxError(
+        message.replace(/^Parser Error: | at column \d+ in [^]*$/g, ''),
+      );
+    }
+
+    return { result, comments, text };
+  };
+}
+
+export const parseBinding = createAngularParseFunction((text, parser) =>
+  parser.parseBinding(text, '', 0),
+);
+
+export const parseSimpleBinding = createAngularParseFunction((text, parser) =>
+  parser.parseSimpleBinding(text, '', 0),
+);
+
+export const parseAction = createAngularParseFunction((text, parser) =>
+  parser.parseAction(text, '', 0),
+);
+
+export const parseInterpolationExpression = createAngularParseFunction(
+  (text, parser) => parser.parseInterpolationExpression(text, '', 0),
+);
+
+export const parseTemplateBindings = createAngularParseFunction(
+  (text, parser) => parser.parseTemplateBindings('', text, '', 0, 0),
+  /* shouldExtractComment */ false,
+);
+
+export type AstParseResult = ReturnType<typeof parseBinding>;
+export type MicroSyntaxParseResult = ReturnType<typeof parseTemplateBindings>;

src/context.ts

@@ -0,0 +1,17 @@
+import * as angularParser from './angular-parser.js';
+import { transformAstResult, transformMicrosyntaxResult } from './transform.js';
+
+export const parseBinding = (text: string) =>
+  transformAstResult(angularParser.parseBinding(text));
+
+export const parseSimpleBinding = (text: string) =>
+  transformAstResult(angularParser.parseSimpleBinding(text));
+
+export const parseInterpolationExpression = (text: string) =>
+  transformAstResult(angularParser.parseInterpolationExpression(text));
+
+export const parseAction = (text: string) =>
+  transformAstResult(angularParser.parseAction(text));
+
+export const parseTemplateBindings = (text: string) =>
+  transformMicrosyntaxResult(angularParser.parseTemplateBindings(text));

src/estree-parser.ts

@@ -1,39 +1,2 @@
-import type * as ng from '@angular/compiler';
-import transformComment from './transform-comment.js';
-import transformNode from './transform-node.js';
-import { transformTemplateBindings } from './transform-microsyntax.js';
-import type {
-  NGNode,
-  RawNGComment,
-  NGMicrosyntax,
-  ParseResult,
-} from './types.js';
-import * as angularParser from './parser.js';
-import { type Context } from './context.js';
-
-function createParser(
-  parse: (text: string) => {
-    ast: ng.AST;
-    comments: RawNGComment[];
-    context: Context;
-  },
-) {
-  return (text: string) => {
-    const { ast: angularNode, comments, context } = parse(text);
-    const ast = transformNode(angularNode, context) as ParseResult;
-    ast.comments = comments.map((comment) => transformComment(comment));
-    return ast;
-  };
-}
-
-export const parseBinding = createParser(angularParser.parseBinding);
-export const parseSimpleBinding = createParser(
-  angularParser.parseSimpleBinding,
-);
-export const parseInterpolationExpression = createParser(
-  angularParser.parseInterpolationExpression,
-);
-export const parseAction = createParser(angularParser.parseAction);
-export const parseTemplateBindings = (text: string): NGMicrosyntax =>
-  transformTemplateBindings(angularParser.parseTemplateBindings(text));
-export type { NGMicrosyntax, NGNode };
+export * from './estree-parser.js';
+export type { NGMicrosyntax, NGNode } from './types.ts';