sinwan-compiler 0.3.1 → 1.0.0

package/dist/analyze.d.ts

@@ -6,7 +6,7 @@
  * modules. The result is written to a JSON metadata file consumed by the
  * per-file transform.
  */
-import * as t from "@babel/types";
+import * as t from "./ast/types";
 import { type ReactiveScope, type CallSite } from "./reactive-wrap";
 export type ImportInfo = {
     source: string;

package/dist/ast/generate.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Print ESTree ASTs with esrap.
+ */
+import type { Node } from "./node";
+export interface GenerateOptions {
+    sourceMaps?: boolean | "inline" | "both";
+    sourceFileName?: string;
+    compact?: boolean;
+    comments?: boolean;
+}
+export interface GenerateResult {
+    code: string;
+    map: object | null;
+}
+export declare function generate(ast: Node, options?: GenerateOptions, _code?: string): GenerateResult;
+export default generate;

package/dist/ast/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Oxc/ESTree AST facade for sinwan-compiler.
+ */
+export { parse, type ParseOptions } from "./parse";
+export { generate, type GenerateOptions, type GenerateResult, } from "./generate";
+export { traverse, Path, Scope, Binding, singlePath, type NodePath, type TraverseOptions, } from "./traverse";
+export * as t from "./types";
+export type { Node, Expression, Function, Identifier, Literal, Program, File, LVal, } from "./node";

package/dist/ast/node.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Shared AST node type — oxc/ESTree plain objects.
+ */
+export type Comment = {
+    type: string;
+    value: string;
+};
+export type SourceLocation = {
+    start: {
+        line: number;
+        column: number;
+    };
+    end: {
+        line: number;
+        column: number;
+    };
+};
+/**
+ * Mutable ESTree node. Named fields are the properties compiler passes read;
+ * the index signature lets Path replace arbitrary child keys.
+ */
+export type Node = {
+    type: string;
+    start?: number | null;
+    end?: number | null;
+    loc?: SourceLocation | null;
+    leadingComments?: Comment[] | null;
+    trailingComments?: Comment[] | null;
+    name?: string | Node;
+    value?: string | number | boolean | null | bigint | Node | {
+        raw?: string;
+        cooked?: string | null;
+    };
+    raw?: string;
+    optional?: boolean;
+    computed?: boolean;
+    shorthand?: boolean;
+    expression?: boolean | Node;
+    async?: boolean;
+    generator?: boolean;
+    kind?: string;
+    operator?: string;
+    prefix?: boolean;
+    method?: boolean;
+    id?: Node | null;
+    init?: Node | null;
+    body?: Node | Node[];
+    params?: Node[];
+    arguments?: Node[];
+    callee?: Node;
+    object?: Node;
+    property?: Node;
+    properties?: Node[];
+    elements?: (Node | null)[];
+    declarations?: Node[];
+    declaration?: Node | null;
+    specifiers?: Node[];
+    source?: Node | null;
+    imported?: Node;
+    exported?: Node;
+    local?: Node;
+    key?: Node;
+    left?: Node;
+    right?: Node;
+    argument?: Node | null;
+    test?: Node;
+    consequent?: Node;
+    alternate?: Node | null;
+    openingElement?: Node;
+    closingElement?: Node | null;
+    children?: Node[];
+    attributes?: Node[];
+    program?: Program;
+    comments?: Comment[] | null;
+    sourceType?: "module" | "script";
+    exportKind?: string;
+    importKind?: string;
+    typeAnnotation?: Node | null;
+    returnType?: Node | null;
+    typeParameters?: Node | null;
+    superClass?: Node | null;
+    quasis?: Node[];
+    expressions?: Node[];
+    regex?: {
+        pattern: string;
+        flags: string;
+    };
+    bigint?: string;
+    selfClosing?: boolean;
+    namespace?: Node;
+    objectType?: Node;
+    param?: Node | null;
+    label?: Node | null;
+    update?: Node | null;
+    definite?: boolean;
+    override?: boolean;
+    readonly?: boolean;
+    declare?: boolean;
+    static?: boolean;
+    accessibility?: string | null;
+    implements?: Node[];
+    mixins?: Node[];
+    decorators?: Node[];
+    typeArguments?: Node | null;
+    typeName?: Node;
+    types?: Node[];
+    elementTypes?: Node[];
+    members?: Node[];
+    openingFragment?: Node;
+    closingFragment?: Node;
+    [key: string]: unknown;
+};
+export type Program = Node & {
+    type: "Program";
+    body: Node[];
+    sourceType: "module" | "script";
+};
+export type File = Node & {
+    type: "File";
+    program: Program;
+    comments: Comment[] | null;
+};
+export type Expression = Node;
+export type Statement = Node;
+export type LVal = Node;
+export type Function = Node & {
+    params: Node[];
+    body: Node;
+    generator?: boolean;
+    async?: boolean;
+    id?: Node | null;
+};
+export type Identifier = Node & {
+    type: "Identifier";
+    name: string;
+};
+export type Literal = Node & {
+    type: "Literal";
+    value: string | number | boolean | null | bigint;
+    raw?: string;
+    regex?: {
+        pattern: string;
+        flags: string;
+    };
+    bigint?: string;
+};
+export declare function isAstNode(value: unknown): value is Node;

package/dist/ast/parse.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Parse TS/TSX with oxc-parser (ESTree) and attach comments onto nodes.
+ */
+import { type File, type Program } from "./node";
+export interface ParseOptions {
+    sourceType?: "module" | "script" | "unambiguous";
+    plugins?: unknown[];
+    sourceFilename?: string;
+    allowReturnOutsideFunction?: boolean;
+    errorRecovery?: boolean;
+}
+/**
+ * Normalize oxc's program object into our mutable Program node.
+ */
+export declare function asProgram(parsed: unknown): Program;
+/**
+ * Parse source into a File wrapper `{ type: "File", program }`.
+ */
+export declare function parse(code: string, options?: ParseOptions): File;

package/dist/ast/path.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Mutable ESTree path + scope for oxc ASTs.
+ */
+import type { Node } from "./node";
+import * as t from "./types";
+export type VisitorFn = (path: Path) => void;
+export type Visitors = Record<string, VisitorFn | {
+    enter?: VisitorFn;
+    exit?: VisitorFn;
+}>;
+export declare class Binding {
+    identifier: t.Identifier;
+    path: Path;
+    kind: string;
+    constant: boolean;
+    referenced: boolean;
+    referencePaths: Path[];
+    constantViolations: Path[];
+    constructor(identifier: t.Identifier, path: Path, kind: string);
+}
+export declare class Scope {
+    path: Path;
+    parent: Scope | null;
+    bindings: Map<string, Binding>;
+    constructor(path: Path, parent?: Scope | null);
+    getBinding(name: string): Binding | undefined;
+    register(name: string, binding: Binding): void;
+    crawl(): void;
+}
+export declare function singlePath(path: Path | Path[]): Path;
+export declare class Path {
+    node: Node;
+    parent: Node | null;
+    parentPath: Path | null;
+    key: string | number | null;
+    container: Node | Node[] | null;
+    listKey: string | null;
+    scope: Scope;
+    _skip: boolean;
+    _stop: boolean;
+    _removed: boolean;
+    _hubEmpty: boolean;
+    constructor(node: Node, parent: Node | null, parentPath: Path | null, key: string | number | null, container: Node | Node[] | null, listKey: string | null, scope?: Scope);
+    skip(): void;
+    stop(): void;
+    get shouldSkip(): boolean;
+    get shouldStop(): boolean;
+    /** Resolve dotted path like `declaration.declarations.0` or `arguments`. */
+    get(dotPath: string): Path | Path[];
+    getFunctionParent(): Path | null;
+    findParent(pred: (p: Path) => boolean): Path | null;
+    replaceWith(replacement: Node): void;
+    replaceWithMultiple(nodes: Node[]): void;
+    traverse(visitors: Visitors): void;
+    isReferencedIdentifier(): this is Path & {
+        node: t.Identifier;
+    };
+    isFunction(): boolean;
+    isIdentifier(opts?: {
+        name?: string;
+    }): boolean;
+    isLiteral(): boolean;
+    isCallExpression(): boolean;
+    isOptionalCallExpression(): boolean;
+    isMemberExpression(): boolean;
+    isOptionalMemberExpression(): boolean;
+    isObjectProperty(opts?: {
+        shorthand?: boolean;
+    }): boolean;
+    isObjectExpression(): boolean;
+    isParenthesizedExpression(): boolean;
+    isIfStatement(): boolean;
+    isObjectPattern(): boolean;
+    isArrayExpression(): boolean;
+    isArrayPattern(): boolean;
+    isVariableDeclarator(): boolean;
+    isVariableDeclaration(opts?: {
+        kind?: string;
+    }): boolean;
+    isImportSpecifier(): boolean;
+    isImportDefaultSpecifier(): boolean;
+    isImportDeclaration(): boolean;
+    isJSXElement(): boolean;
+    isJSXFragment(): boolean;
+    isJSXExpressionContainer(): boolean;
+    isJSXAttribute(): boolean;
+    isBlockStatement(): boolean;
+    isArrowFunctionExpression(): boolean;
+    isFunctionExpression(): boolean;
+    isFunctionDeclaration(): boolean;
+    isSpreadElement(): boolean;
+    isTemplateLiteral(): boolean;
+    isTemplateElement(): boolean;
+    isBinaryExpression(): boolean;
+    isLogicalExpression(): boolean;
+    isConditionalExpression(): boolean;
+    isUnaryExpression(opts?: {
+        operator?: string;
+    }): boolean;
+    isUpdateExpression(): boolean;
+    isAssignmentExpression(): boolean;
+    isForInStatement(): boolean;
+    isForOfStatement(): boolean;
+    isTSType(): boolean;
+    isTSAsExpression(): boolean;
+    isTSTypeAssertion(): boolean;
+    isTSNonNullExpression(): boolean;
+    isTSSatisfiesExpression(): boolean;
+    isProgram(): boolean;
+    assertExpression(): void;
+}
+export type NodePath<N extends Node = Node> = Path & {
+    node: N;
+};
+export type TraverseOptions = Visitors;
+export declare function traverse(ast: Node, visitors: Visitors): void;

package/dist/ast/traverse.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Re-export path traversal for compiler passes.
+ */
+export { traverse, Path, Scope, Binding, singlePath, type NodePath, type Visitors, type TraverseOptions, } from "./path";

package/dist/ast/types.d.ts

@@ -0,0 +1,267 @@
+/**
+ * ESTree node builders and type guards for oxc ASTs.
+ */
+import type { Expression, Function, Identifier, Literal, Node } from "./node";
+export declare function identifier(name: string): Identifier;
+export declare function stringLiteral(value: string): Literal;
+export declare function numericLiteral(value: number): Literal;
+export declare function booleanLiteral(value: boolean): Literal;
+export declare function nullLiteral(): Literal;
+export declare function callExpression(callee: Expression, args: Expression[]): CallExpression;
+export declare function memberExpression(object: Expression, property: Expression, computed?: boolean): Node;
+export declare function arrowFunctionExpression(params: Node[], body: Node, expression?: boolean): Function & {
+    type: "ArrowFunctionExpression";
+};
+export declare function functionExpression(id: Identifier | Node | null, params: Node[], body: Node, generator?: boolean, async?: boolean): Function;
+export declare function functionDeclaration(id: Identifier | Node | null, params: Node[], body: Node, generator?: boolean, async?: boolean): Function;
+export declare function variableDeclarator(id: Node, init?: Expression | null): Node;
+export declare function variableDeclaration(kind: "const" | "let" | "var", declarations: Node[]): VariableDeclaration;
+export declare function arrayExpression(elements: (Expression | null)[]): Node;
+export declare function objectExpression(properties: Node[]): Node;
+export declare function objectProperty(key: Node, value: Node, computed?: boolean, shorthand?: boolean): Node;
+export declare function objectPattern(properties: Node[]): ObjectPattern;
+export declare function restElement(argument: Node): Node;
+export declare function arrayPattern(elements: (Node | null)[]): Node;
+export declare function assignmentPattern(left: Node, right: Expression): Node;
+export declare function importSpecifier(local: Identifier, imported: Identifier): Node;
+export declare function importDeclaration(specifiers: Node[], source: Literal): ImportDeclaration;
+export declare function exportNamedDeclaration(declaration: Node | null, specifiers?: Node[]): Node;
+export declare function exportDefaultDeclaration(declaration: Node): Node;
+export declare function jsxExpressionContainer(expression: Expression): Node;
+export declare function blockStatement(body: Node[]): Node & {
+    type: "BlockStatement";
+    body: Node[];
+};
+export declare function returnStatement(argument?: Expression | null): Node;
+export declare function binaryExpression(operator: string, left: Expression, right: Expression): Node;
+export declare function conditionalExpression(test: Expression, consequent: Expression, alternate: Expression): Node;
+export declare function unaryExpression(operator: string, argument: Expression, prefix?: boolean): Node;
+export declare function tsNonNullExpression(expression: Expression): Node;
+export declare function tsAsExpression(expression: Expression, typeAnnotation: Node): Node;
+export declare function tsTypeAssertion(expression: Expression, typeAnnotation: Node): Node;
+export declare function isNode(n: unknown): n is Node;
+export declare function isIdentifier(n: unknown, opts?: {
+    name?: string;
+}): n is Identifier;
+export declare function isLiteral(n: unknown): n is Literal;
+export declare function isStringLiteral(n: unknown, opts?: {
+    value?: string;
+}): n is Literal & {
+    value: string;
+};
+export declare function isNumericLiteral(n: unknown): n is Literal;
+export declare function isBooleanLiteral(n: unknown): n is Literal;
+export declare function isNullLiteral(n: unknown): n is Literal;
+export declare function isTemplateLiteral(n: unknown): n is Node & {
+    type: "TemplateLiteral";
+    expressions: Node[];
+    quasis: Node[];
+};
+export declare function templateElementRaw(n: Node | undefined | null): string;
+export declare function isCallExpression(n: unknown): n is Node & {
+    type: "CallExpression";
+    callee: Node;
+    arguments: Node[];
+};
+export declare function isOptionalCallExpression(n: unknown): boolean;
+export declare function isMemberExpression(n: unknown): n is Node & {
+    type: "MemberExpression";
+    object: Node;
+    property: Node;
+    computed?: boolean;
+    optional?: boolean;
+};
+export declare function isOptionalMemberExpression(n: unknown): n is Node & {
+    type: string;
+    object: Node;
+    property: Node;
+    computed?: boolean;
+    optional?: boolean;
+};
+export declare function isChainExpression(n: unknown): boolean;
+/** Unwrap ChainExpression to the inner member/call expression. */
+export declare function unwrapChain(n: Node): Node;
+export declare function isParenthesizedExpression(n: unknown): boolean;
+/**
+ * Strip ParenthesizedExpression wrappers. Oxc preserves them by default;
+ * Babel typically does not.
+ */
+export declare function unwrapParens(n: Node): Node;
+/** Unwrap parens and ChainExpression so CallExpression fields are accessible. */
+export declare function unwrapCall(n: Node): Node;
+export declare function isObjectExpression(n: unknown): n is Node & {
+    type: "ObjectExpression";
+    properties: Node[];
+};
+export declare function isObjectProperty(n: unknown): n is Node & {
+    type: "Property" | "ObjectProperty";
+    key: Node;
+    value: Node;
+    computed?: boolean;
+    shorthand?: boolean;
+};
+export declare function isObjectPattern(n: unknown): n is Node & {
+    type: "ObjectPattern";
+    properties: Node[];
+};
+export declare function isArrayPattern(n: unknown): n is Node & {
+    type: "ArrayPattern";
+    elements: (Node | null)[];
+};
+export declare function isRestElement(n: unknown): n is Node & {
+    type: "RestElement";
+    argument: Node;
+};
+export declare function isSpreadElement(n: unknown): n is Node & {
+    type: "SpreadElement";
+    argument: Node;
+};
+export declare function isAssignmentPattern(n: unknown): n is Node & {
+    type: "AssignmentPattern";
+    left: Node;
+    right: Node;
+};
+export declare function isBlockStatement(n: unknown): n is Node & {
+    type: "BlockStatement";
+    body: Node[];
+};
+export declare function isVariableDeclaration(n: unknown, opts?: {
+    kind?: string;
+}): n is Node & {
+    type: "VariableDeclaration";
+    kind: string;
+    declarations: Node[];
+};
+export declare function isVariableDeclarator(n: unknown): n is Node & {
+    type: "VariableDeclarator";
+    id: Node;
+    init?: Node | null;
+};
+export declare function isFunctionDeclaration(n: unknown): n is Function;
+export declare function isFunctionExpression(n: unknown): n is Function;
+export declare function isArrowFunctionExpression(n: unknown): n is Function;
+export declare function isFunction(n: unknown): n is Function;
+export declare function isImportDeclaration(n: unknown): n is Node & {
+    type: "ImportDeclaration";
+    specifiers: Node[];
+    source: Literal;
+};
+export declare function isImportSpecifier(n: unknown): n is Node & {
+    type: "ImportSpecifier";
+    local: Identifier;
+    imported: Node;
+};
+export declare function isImportDefaultSpecifier(n: unknown): n is Node & {
+    type: "ImportDefaultSpecifier";
+    local: Identifier;
+};
+export declare function isImportNamespaceSpecifier(n: unknown): n is Node & {
+    type: "ImportNamespaceSpecifier";
+    local: Identifier;
+};
+export declare function isExportSpecifier(n: unknown): boolean;
+export declare function isClassDeclaration(n: unknown): boolean;
+export declare function isJSXElement(n: unknown): n is Node & {
+    type: "JSXElement";
+    openingElement: Node;
+    children: Node[];
+};
+export declare function isJSXFragment(n: unknown): boolean;
+export declare function isJSXIdentifier(n: unknown): n is Node & {
+    type: "JSXIdentifier";
+    name: string;
+};
+export declare function isJSXOpeningElement(n: unknown): n is Node & {
+    type: "JSXOpeningElement";
+    name: Node;
+    attributes: Node[];
+};
+export declare function isJSXMemberExpression(n: unknown): n is Node & {
+    type: "JSXMemberExpression";
+    object: Node;
+    property: Node;
+};
+export declare function isJSXAttribute(n: unknown): n is Node & {
+    type: "JSXAttribute";
+    name: Node;
+    value?: Node | null;
+};
+export declare function isJSXSpreadAttribute(n: unknown): boolean;
+export declare function isJSXExpressionContainer(n: unknown): n is Node & {
+    type: "JSXExpressionContainer";
+    expression: Node;
+};
+export declare function isJSXEmptyExpression(n: unknown): boolean;
+export declare function isTSNonNullExpression(n: unknown): n is Node & {
+    type: "TSNonNullExpression";
+    expression: Node;
+};
+export declare function isTSAsExpression(n: unknown): boolean;
+export declare function isTSTypeAssertion(n: unknown): boolean;
+export declare function isTSSatisfiesExpression(n: unknown): boolean;
+export declare function isTSTypeAnnotation(n: unknown): boolean;
+export declare function isExpression(n: unknown): n is Expression;
+export declare function importedBindingName(n: Node | undefined | null): string | null;
+export declare function moduleSourceValue(n: Node | undefined | null): string | null;
+export declare function assertExpression(n: unknown): asserts n is Expression;
+/** Type-only aliases used as `t.Function` etc. in annotations. */
+export type { Node, Expression, Function, Identifier, Literal, Program, File, LVal, } from "./node";
+export type MemberExpression = Node;
+export type OptionalMemberExpression = Node;
+export type CallExpression = Node & {
+    type: "CallExpression";
+    callee: Node;
+    arguments: Node[];
+};
+export type OptionalCallExpression = Node;
+export type ArrowFunctionExpression = Function & {
+    type: "ArrowFunctionExpression";
+};
+export type FunctionExpression = Function;
+export type FunctionDeclaration = Function;
+export type ObjectPattern = Node & {
+    type: "ObjectPattern";
+    properties: Node[];
+};
+export type ObjectExpression = Node & {
+    type: "ObjectExpression";
+    properties: Node[];
+};
+export type VariableDeclarator = Node;
+export type VariableDeclaration = Node & {
+    type: "VariableDeclaration";
+    kind: string;
+    declarations: Node[];
+};
+export type ExportNamedDeclaration = Node & {
+    type: "ExportNamedDeclaration";
+    declaration?: Node | null;
+    specifiers: Node[];
+};
+export type ImportDeclaration = Node & {
+    type: "ImportDeclaration";
+    specifiers: Node[];
+    source: Literal;
+};
+export type JSXElement = Node & {
+    type: "JSXElement";
+    openingElement: Node;
+    children: Node[];
+};
+export type JSXAttribute = Node;
+export type JSXOpeningElement = Node & {
+    type: "JSXOpeningElement";
+    name: Node;
+    attributes: Node[];
+};
+export type JSXIdentifier = Node & {
+    type: "JSXIdentifier";
+    name: string;
+};
+export type JSXMemberExpression = Node;
+export type JSXSpreadAttribute = Node;
+export type BlockStatement = Node & {
+    type: "BlockStatement";
+    body: Node[];
+};
+export type StringLiteral = Literal;

package/dist/auto-cc.d.ts

@@ -26,7 +26,7 @@
  * `sinwan` / `sinwan/component`, an `import { cc } from "sinwan/component"` is
  * prepended so the subsequent reactive-wrap pass detects the components.
  */
-import * as t from "@babel/types";
+import * as t from "./ast/types";
 /**
  * Mutates the AST, wrapping exported component-like functions with `cc(...)`.
  * Returns `true` if any wrapping was performed.