yuku-ast 0.6.7 → 0.6.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yuku-ast",
-  "version": "0.6.7",
+  "version": "0.6.8",
   "description": "Typed AST toolkit for JavaScript and TypeScript ESTree trees: walker, builders, guards, and syntactic utilities",
   "license": "MIT",
   "repository": {
@@ -11,15 +11,11 @@
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "bun": "./src/index.ts",
-      "default": "./dist/index.js"
-    }
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
   },
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
   "scripts": {
     "build": "tsdown"
@@ -40,5 +36,6 @@
     "typescript",
     "javascript",
     "yuku"
-  ]
+  ],
+  "module": "./dist/index.js"
 }

package/src/aliases.ts

@@ -1,190 +0,0 @@
-import type {
-  ClassType,
-  Declaration,
-  Expression,
-  FunctionType,
-  MethodDefinitionType,
-  ModuleDeclaration,
-  NodeOfType,
-  NodeType,
-  Statement,
-  TSType,
-} from "@yuku-toolchain/types";
-
-// every group member must be a real node type, and the union-backed
-// groups must match their @yuku-toolchain/types union exactly, both
-// directions checked below
-export const ALIAS_GROUPS = {
-  Expression: [
-    "Identifier",
-    "Literal",
-    "ThisExpression",
-    "Super",
-    "ArrayExpression",
-    "ObjectExpression",
-    "FunctionExpression",
-    "ArrowFunctionExpression",
-    "ClassExpression",
-    "TaggedTemplateExpression",
-    "TemplateLiteral",
-    "MemberExpression",
-    "CallExpression",
-    "NewExpression",
-    "ChainExpression",
-    "SequenceExpression",
-    "ParenthesizedExpression",
-    "BinaryExpression",
-    "LogicalExpression",
-    "ConditionalExpression",
-    "UnaryExpression",
-    "UpdateExpression",
-    "AssignmentExpression",
-    "YieldExpression",
-    "AwaitExpression",
-    "ImportExpression",
-    "MetaProperty",
-    "TSAsExpression",
-    "TSSatisfiesExpression",
-    "TSTypeAssertion",
-    "TSNonNullExpression",
-    "TSInstantiationExpression",
-    "JSXElement",
-    "JSXFragment",
-  ],
-  Statement: [
-    "ExpressionStatement",
-    "BlockStatement",
-    "EmptyStatement",
-    "DebuggerStatement",
-    "ReturnStatement",
-    "LabeledStatement",
-    "BreakStatement",
-    "ContinueStatement",
-    "IfStatement",
-    "SwitchStatement",
-    "ThrowStatement",
-    "TryStatement",
-    "WhileStatement",
-    "DoWhileStatement",
-    "ForStatement",
-    "ForInStatement",
-    "ForOfStatement",
-    "WithStatement",
-    "FunctionDeclaration",
-    "ClassDeclaration",
-    "VariableDeclaration",
-    "TSDeclareFunction",
-    "TSTypeAliasDeclaration",
-    "TSInterfaceDeclaration",
-    "TSEnumDeclaration",
-    "TSModuleDeclaration",
-    "TSImportEqualsDeclaration",
-  ],
-  Declaration: [
-    "FunctionDeclaration",
-    "ClassDeclaration",
-    "VariableDeclaration",
-    "TSDeclareFunction",
-    "TSTypeAliasDeclaration",
-    "TSInterfaceDeclaration",
-    "TSEnumDeclaration",
-    "TSModuleDeclaration",
-    "TSImportEqualsDeclaration",
-  ],
-  ModuleDeclaration: [
-    "ImportDeclaration",
-    "ExportNamedDeclaration",
-    "ExportDefaultDeclaration",
-    "ExportAllDeclaration",
-    "TSExportAssignment",
-    "TSNamespaceExportDeclaration",
-  ],
-  Function: [
-    "FunctionDeclaration",
-    "FunctionExpression",
-    "TSDeclareFunction",
-    "TSEmptyBodyFunctionExpression",
-    "ArrowFunctionExpression",
-  ],
-  Class: ["ClassDeclaration", "ClassExpression"],
-  Method: ["MethodDefinition", "TSAbstractMethodDefinition"],
-  Loop: ["DoWhileStatement", "ForInStatement", "ForOfStatement", "ForStatement", "WhileStatement"],
-  Pattern: ["ArrayPattern", "ObjectPattern", "AssignmentPattern", "RestElement"],
-  JSX: [
-    "JSXAttribute",
-    "JSXClosingElement",
-    "JSXClosingFragment",
-    "JSXElement",
-    "JSXEmptyExpression",
-    "JSXExpressionContainer",
-    "JSXFragment",
-    "JSXIdentifier",
-    "JSXMemberExpression",
-    "JSXNamespacedName",
-    "JSXOpeningElement",
-    "JSXOpeningFragment",
-    "JSXSpreadAttribute",
-    "JSXSpreadChild",
-    "JSXText",
-  ],
-  TSType: [
-    "TSAnyKeyword",
-    "TSUnknownKeyword",
-    "TSNeverKeyword",
-    "TSVoidKeyword",
-    "TSNullKeyword",
-    "TSUndefinedKeyword",
-    "TSStringKeyword",
-    "TSNumberKeyword",
-    "TSBigIntKeyword",
-    "TSBooleanKeyword",
-    "TSSymbolKeyword",
-    "TSObjectKeyword",
-    "TSIntrinsicKeyword",
-    "TSThisType",
-    "TSTypeReference",
-    "TSTypeQuery",
-    "TSImportType",
-    "TSLiteralType",
-    "TSTemplateLiteralType",
-    "TSArrayType",
-    "TSIndexedAccessType",
-    "TSTupleType",
-    "TSNamedTupleMember",
-    "TSJSDocNullableType",
-    "TSJSDocNonNullableType",
-    "TSJSDocUnknownType",
-    "TSUnionType",
-    "TSIntersectionType",
-    "TSConditionalType",
-    "TSInferType",
-    "TSTypeOperator",
-    "TSParenthesizedType",
-    "TSFunctionType",
-    "TSConstructorType",
-    "TSTypePredicate",
-    "TSTypeLiteral",
-    "TSMappedType",
-  ],
-} as const satisfies Record<string, readonly NodeType[]>;
-
-export type AliasName = keyof typeof ALIAS_GROUPS;
-
-type GroupType<A extends AliasName> = (typeof ALIAS_GROUPS)[A][number];
-
-/** The node union each alias covers, e.g. `AliasMap["Function"]`. */
-export type AliasMap = { [A in AliasName]: NodeOfType<GroupType<A>> };
-
-export const ALIAS_NAMES = Object.keys(ALIAS_GROUPS) as readonly AliasName[];
-
-// exact two-way agreement with the @yuku-toolchain/types unions
-type Same<A, B> = [A] extends [B] ? ([B] extends [A] ? true : false) : false;
-type Expect<T extends true> = T;
-type _expression = Expect<Same<GroupType<"Expression">, Expression["type"]>>;
-type _statement = Expect<Same<GroupType<"Statement">, Statement["type"]>>;
-type _declaration = Expect<Same<GroupType<"Declaration">, Declaration["type"]>>;
-type _module = Expect<Same<GroupType<"ModuleDeclaration">, ModuleDeclaration["type"]>>;
-type _function = Expect<Same<GroupType<"Function">, FunctionType | "ArrowFunctionExpression">>;
-type _class = Expect<Same<GroupType<"Class">, ClassType>>;
-type _method = Expect<Same<GroupType<"Method">, MethodDefinitionType>>;
-type _tstype = Expect<Same<GroupType<"TSType">, TSType["type"]>>;

package/src/builders.ts

@@ -1,27 +0,0 @@
-import type { Node, NodeOfType, NodeType } from "@yuku-toolchain/types";
-import { NODE_TYPES } from "./generated.ts";
-
-// distributes over unions, so b.Literal accepts each literal shape
-type BuilderInput<T> = T extends Node
-  ? Omit<T, "type" | "start" | "end"> & { start?: number; end?: number }
-  : never;
-
-type Builders = {
-  [K in NodeType]: (fields: BuilderInput<NodeOfType<K>>) => NodeOfType<K>;
-};
-
-/**
- * One constructor per node type, its fields derived from the node type
- * itself. `start` and `end` default to 0, which `ctx.replace` treats
- * as span-less and fills from the replaced node.
- *
- * @example
- * b.Identifier({ name: "x" })
- * b.ExpressionStatement({ expression: b.Identifier({ name: "x" }) })
- */
-export const b = Object.fromEntries(
-  NODE_TYPES.map((type) => [
-    type,
-    (fields: Record<string, unknown>) => ({ type, start: 0, end: 0, ...fields }),
-  ]),
-) as unknown as Builders;

package/src/context.ts

@@ -1,110 +0,0 @@
-import type { Node } from "@yuku-toolchain/types";
-
-interface Frame {
-  i: number;
-}
-
-/**
- * The walk context: one reused object exposing the current position and
- * the tree mutation operations. Valid only during the visit that
- * receives it, do not store it. Underscore members are engine state.
- */
-export class WalkContext<T extends Node = Node, S = unknown> {
-  _ancestors: Node[] = [];
-  _node: Node | null = null;
-  _key: string | null = null;
-  _list: Node[] | null = null;
-  _frame: Frame | null = null;
-  _skip = false;
-  _stopped = false;
-  _removed = false;
-  _replacement: Node | null = null;
-  /** State threaded through the walk, the third `walk` argument. */
-  state!: S;
-
-  /** The node being visited. */
-  get node(): T {
-    return this._node as T;
-  }
-
-  /** The node holding {@link node}, or null at the walk root. */
-  get parent(): Node | null {
-    const a = this._ancestors;
-    return a.length === 0 ? null : a[a.length - 1]!;
-  }
-
-  /** The field on {@link parent} holding {@link node}, or null at the root. */
-  get key(): string | null {
-    return this._key;
-  }
-
-  /** Index within an array field, or null in a plain field. */
-  get index(): number | null {
-    return this._list === null ? null : this._frame!.i;
-  }
-
-  /** Ancestors from the walk root down to {@link parent}. */
-  ancestors(): Node[] {
-    return [...this._ancestors];
-  }
-
-  /** Do not descend into the current node's children. */
-  skip(): void {
-    this._skip = true;
-  }
-
-  /** Stop the walk entirely. */
-  stop(): void {
-    this._stopped = true;
-  }
-
-  /**
-   * Replace the current node. The walk continues into the replacement's
-   * children and `leave` fires for the replacement's type. A synthetic
-   * node with `start === 0 && end === 0` inherits the original span,
-   * for source maps. Throws at the walk root.
-   */
-  replace(node: Node): void {
-    if (node === null || typeof node !== "object" || typeof node.type !== "string") {
-      throw new TypeError("replace: expected an AST node");
-    }
-    if (this.parent === null) {
-      throw new TypeError("replace: cannot replace the walk root");
-    }
-    if (node.start === 0 && node.end === 0) {
-      node.start = this.node.start;
-      node.end = this.node.end;
-    }
-    this._replacement = node;
-  }
-
-  /**
-   * Remove the current node from its parent: spliced from array fields,
-   * nulled in plain fields. Children are not walked and `leave` does
-   * not fire. Throws at the walk root.
-   */
-  remove(): void {
-    if (this.parent === null) {
-      throw new TypeError("remove: cannot remove the walk root");
-    }
-    this._removed = true;
-  }
-
-  /** Insert a sibling before the current node, not visited. Array fields only. */
-  insertBefore(node: Node): void {
-    this.#insert(node, 0);
-    this._frame!.i++;
-  }
-
-  /** Insert a sibling after the current node, visited by the walk. Array fields only. */
-  insertAfter(node: Node): void {
-    this.#insert(node, 1);
-  }
-
-  #insert(node: Node, offset: number): void {
-    if (this._list === null) {
-      throw new TypeError("insertBefore/insertAfter require a node in an array field");
-    }
-    this._list.splice(this._frame!.i + offset, 0, node);
-  }
-}