sinwan-compiler 0.4.0 → 1.1.0

package/dist/live-cc-destructure.d.ts

@@ -8,7 +8,7 @@
  * Nested patterns are left as snapshots. JSX spreads of the props (or rest)
  * identifier use `getSpreadProps` so native attributes keep getter functions.
  */
-import * as t from "@babel/types";
+import * as t from "./ast/types";
 /**
  * Rewrite flat `cc` destructure and raw JSX spreads. Returns whether any
  * helper imports are required.

package/dist/reactive-wrap.d.ts

@@ -6,7 +6,7 @@
  * when the value changes.
  *
  * Supported reactive sources:
- *   - `createMutable` / `createStore` from `sinwan/store`
+ *   - `createMutable` / `createStore` from `sinway`
  *   - `signal` / `computed` from `sinwan/reactivity`
  *   - `useState` from `sinwan/react`
  *   - `.value` reads of signals returned from other modules (`useTheme`,
@@ -20,7 +20,7 @@
  *   <p>{count.value}</p>        → <p>{() => count.value}</p>
  *   <p>{getCount()}</p>         → <p>{() => getCount()}</p>
  */
-import * as t from "@babel/types";
+import * as t from "./ast/types";
 export interface ImportNames {
     createMutable: Set<string>;
     createStore: Set<string>;

package/dist/transform.d.ts

@@ -5,6 +5,7 @@
  * Static JSX elements are extracted to module-level template strings
  * and replaced with optimized template creation calls.
  */
+import { t } from "./ast";
 export interface TransformOptions {
     derivedLocals?: boolean;
     /** Enable template hoisting (default: true) */
@@ -40,6 +41,7 @@ export declare const COMPILER_TEMPLATE_SLOT_PROTOCOL: {
     encodeSlot(index: number): string;
     decodeSlot(data: string): number | null;
 };
+export declare function jsxAttrName(attr: t.Node): string | undefined;
 export declare function transformJSX(code: string, filename: string, options?: TransformOptions): {
     code: string;
     map?: any;

package/docs/api.md

@@ -29,11 +29,11 @@ See [Transform](transform.md) for wrapping rules and options.
 
 ### `autoWrapComponents(ast, filename?)`
 
-Mutates a Babel AST: wrap exported component-like functions with `cc(...)`. Returns `true` if anything changed. `transformJSX` already runs this.
+Mutates an ESTree AST (oxc-parser): wrap exported component-like functions (including `function X` / `const X` exported through `export { X }`) with `cc(...)`. Returns `true` if anything changed. `transformJSX` already runs this.
 
 ### `rewriteLiveCcDestructure(ast)`
 
-Mutates a Babel AST: rewrite flat `cc(({ value }) => …)` params to a `props` identifier and `{...props}` spreads to `getSpreadProps(props)`. Nested destructure is left as a snapshot. `transformJSX` already runs this before reactive wrap.
+Mutates an ESTree AST (oxc-parser): rewrite flat `cc(({ value }) => …)` params to a `props` identifier and `{...props}` spreads to `getSpreadProps(props)`. Nested destructure is left as a snapshot. `transformJSX` already runs this before reactive wrap.
 
 ## Analysis
 

package/docs/architecture.md

@@ -6,6 +6,7 @@ This page is for people changing the compiler. App authors can stay on [Transfor
 
 ```
 src/
+  ast/               oxc parse, Path/Scope, esrap print
   index.ts           Public exports
   auto-cc.ts         Exported function → cc(...)
   live-cc-destructure.ts  Flat cc(({ value }) => …) → props.value
@@ -16,6 +17,21 @@ src/
   exports.ts         collectExportedComponents
 ```
 
+## AST pipeline
+
+`transformJSX` and analyze parse with **oxc-parser** (`parseSync`, ESTree / TS-ESTree). The compiler parses as TSX so JSX and TypeScript are accepted in `.js`, `.jsx`, `.ts`, and `.tsx`, matching the previous Babel plugin set. Comments are copied onto `leadingComments` / `trailingComments`. A JSX `{/* comment */}` stays on its empty expression. A comment that sits inside a function or object after the last child stays on that container. Rewrite passes walk a Babel-shaped **Path/Scope** facade built on oxc `visitorKeys` (parent pointers, `getBinding`, `replaceWith`). Print is **esrap** with `esrap/languages/tsx` and double quotes.
+
+Babel is not used. oxc-parser JS/JSX matches Acorn ESTree; TS/TSX matches TS-ESTree. Passes must treat:
+
+- `Literal` (not `StringLiteral` / `NumericLiteral`)
+- `Property` (not `ObjectProperty`)
+- `ChainExpression` around optional calls/members
+- `ParenthesizedExpression` (`preserveParens` defaults true) — unwrap in reactive walks, do not require Babel’s implicit paren stripping
+
+Print is esrap, not oxc-codegen or MagicString, so mutations stay on the tree. Acorn / acorn-walk cannot own this pipeline: Acorn does not parse TSX, and acorn-walk has no bindings or JSX/TS visitor keys. Bun.Transpiler and SWC are out of scope (no AST mutation API / not the primary engine).
+
+`derivedLocals` uses the Path/Scope facade; a Rust rewrite of passes is not required while those tests pass.
+
 ## Data flow
 
 ```text

package/docs/transform.md

@@ -32,7 +32,7 @@ Exported functions that look like components are wrapped for you. You can write
 
 A candidate must be:
 
-- **Exported** (named or default)
+- **Exported** (named or default): `export function`, `export const`, `export default`, or a top-level `function` / `const` exported through `export { X }` or `export { X as Name }` (the exported name must be uppercase)
 - **Uppercase** (or an anonymous `export default function ()`)
 - **0 or 1 parameter**
 - **Returning JSX** in that function (not only in a nested helper)
@@ -50,7 +50,9 @@ export const App = cc(function App() {
 });
 ```
 
-Not wrapped: lowercase helpers, generators, multi-argument functions, or functions that never return JSX. If `cc` is not imported yet, the compiler adds `import { cc } from "sinwan/component"`.
+Not wrapped: lowercase helpers, generators, multi-argument functions, functions that never return JSX, type-only exports, re-exports (`export { X } from "./x"`), components that are not exported, and a `function X` exported through `export { X }` that module code reads before its declaration (for example `const Group = Object.assign(X, { Item })` above it), because turning it into `const X = cc(...)` would make that read throw. Reads inside functions, export specifiers and types do not count. A `cc` parent passes reactive props to child components as getters, so a non-exported component that receives props from one must be wrapped with `cc(...)` explicitly. If `cc` is not imported yet, the compiler adds `import { cc } from "sinwan/component"`.
+
+Type parameters and return types are kept on the wrapped function. A circular import that reads `X` at module load before this file finishes evaluating is not detected; `export function X` has the same limitation.
 
 `cc` may be imported from `sinwan` or `sinwan/component`.
 
@@ -78,7 +80,7 @@ Tracked imports:
 
 | Module              | Names                          |
 | ------------------- | ------------------------------ |
-| `sinwan/store`      | `createMutable`, `createStore` |
+| `sinway`      | `createMutable`, `createStore` |
 | `sinwan/reactivity` | `signal`, `computed`           |
 | `sinwan/react`      | `useState`                     |
 | `sinwan/hook`       | `useFetch`                     |
@@ -138,7 +140,10 @@ return (
 
 - Only referenced, identifier-named `const` declarations directly in a `cc` setup body (including auto-`cc` components) are candidates. Dependencies are processed in declaration order, including multiple declarators in one statement.
 - Pure read expressions are supported: member/index/optional access, arithmetic, comparisons, boolean/conditional expressions, template strings, object/array literals, and TypeScript expression annotations. Direct imported `useState` getter calls and unshadowed single-argument `Boolean`, `Number`, and `String` coercions are also supported. Property reads and coercions must be free of user-defined side effects.
-- Calls to arbitrary helpers, hooks, factories or methods, assignments, updates, allocations, destructuring, `let`/`var`, mutable captures, and forward/TDZ references remain eager — **unless** the callee is an imported function annotated with `/** @sinwan-pure */` (see [`@sinwan-pure` JSDoc contract](#sinwan-pure-jsdoc-contract) below). Explicit getter and `computed` initializers are unchanged. Module, event-handler, render-callback, loop and nested-block declarations are not promoted.
+- Calls to arbitrary helpers, hooks, factories or methods, assignments, updates, allocations, destructuring, `let`/`var`, mutable captures, and forward/TDZ references remain eager — **unless** the callee is a function annotated with `/** @sinwan-pure */` (imported, or declared in the same file), a local zero-arity arrow getter whose expression body is itself safe (`const yearNow = () => …`, then `props.fromYear ?? yearNow() - 10`), or a built-in read on a known array or `Date` (below). See [`@sinwan-pure` JSDoc contract](#sinwan-pure-jsdoc-contract) below. A getter with a block body, side effects (`() => count++`) or a call back into itself stays eager. Explicit getter and `computed` initializers are unchanged.
+- Built-in reads: `Array.from(...)`, non-mutating array reads (`map`, `filter`, `flatMap`, `flat`, `slice`, `concat`, `join`, `at`, `find`, `findIndex`, `some`, `every`, `reduce`, `includes`, `indexOf`, `entries`, `keys`, `values`) and `Date` getters (`getFullYear`, `getMonth`, `getDate`, `getDay`, `getTime`, `getHours`, `getMinutes`, `getSeconds`, `getMilliseconds`, `valueOf`) promote only on a receiver the compiler knows is an array or `Date`: an array literal, `Array.from(...)`, an array read that returns a new array, a `const` annotated `T[]` / `Array<T>` / `ReadonlyArray<T>` / `Date` or initialized from one of these, or a call to a same-file function with that return type annotation. A callback must be inline (its body is inspected) or a `@sinwan-pure` function; `items.map(track)` with an unannotated `track` stays eager. Reads on other values (`props.items.map(...)`, `props.query.filter(...)`) stay eager because the method may not be the built-in one; annotate a `const` (`const items: Item[] = props.items`) to opt in.
+- A pure method read on a promoted local such as `monthList.map(...)` or `today.getFullYear()` is rewritten to `monthList().map(...)` / `today().getFullYear()`. Mutating reads such as `list.push` and `date.setFullYear` stay snapshots. A promoted local that holds a function is still called: `const close = props.onClose; close()` becomes `close()()`. Module, event-handler, render-callback, loop and nested-block declarations are not promoted.
+- A reactive value passed to a parameter typed `LiveRead<T>` (`T | (() => T)`) is wrapped as `() => value`. An argument that is already a function is left alone. `createLiveState(..., props.selected)` therefore re-reads `props.selected` on each `state.value` access.
 - Bare signal/store containers still pass through unchanged. Bare component prop-bag aliases retain their ordinary JavaScript value semantics. References are resolved by lexical binding, so shadowed locals and object keys are not rewritten.
 - Every ordinary value use is called, including chained initializers, closures, event bodies, shorthand object values and setup `if` tests. A boolean does **not** become an accidentally truthy function. Setup control flow still runs once; use `Show`/`Switch` for reactive branches.
 - Variables used as JSX tag names, in type queries, or as mutation/method-call receivers are left eager. Components containing direct `eval` are excluded.
@@ -170,12 +175,12 @@ export function cn(...inputs: ClassValue[]): string {
 }
 ```
 
-Both `export function` and `export const` declarations are recognized. The annotation must be a block comment (`/** */`) immediately before the `export` keyword.
+Both `export function` and `export const` declarations are recognized. The annotation must be a block comment (`/** */`) immediately before the `export` keyword. A non-exported function in the same file is also recognized when the comment sits directly above `function` or `const`.
 
 **What the compiler guarantees:**
 
 - When `derivedLocals: true` is enabled, calls to `@sinwan-pure`-annotated imported functions are treated as safe expressions. The containing `const` initializer is promoted to a zero-argument getter, and references inside the function arguments are rewritten (e.g. `seamInactive` → `seamInactive()`).
-- The compiler resolves the import path, reads the source file, parses it, and checks for `/** @sinwan-pure */` on exported declarations. Results are cached per resolved file path, so each file is read at most once per compilation process.
+- The compiler resolves the import path, reads the source file, parses it, and checks for `/** @sinwan-pure */` on exported declarations. Results are cached per resolved file path and reused while that file, and any file it re-exports from, keeps its modification time, so a dev server picks up a new or removed annotation without a restart. The same applies to the `LiveRead<T>` parameter scan.
 - All import types are scanned: relative imports (`./`, `../`), bare specifiers (`clsx`, `sinwan/reactivity`), scoped packages (`@scope/utils`), and subpath imports (`@scope/utils/merge`). The compiler walks up the directory tree to find `node_modules/<pkg>`, reads `package.json`, and resolves the entry point via `exports`, `module`, `main`, `source`, or `index` files.
 - If the `resolveImport` callback is provided by the plugin, it is used for path resolution (handles tsconfig paths, bunfig aliases, workspace packages, and Bun/Vite module resolution). Otherwise, the compiler falls back to direct filesystem resolution with common extensions (`.ts`, `.tsx`, `.js`, `.jsx`, `.mjs`, `.cjs`, `.mts`, `.cts`) and `index` files.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sinwan-compiler",
-  "version": "0.4.0",
+  "version": "1.1.0",
   "description": "Shared compiler core for Sinwan plugins",
   "type": "module",
   "main": "./dist/index.js",
@@ -37,16 +37,12 @@
     "prepublishOnly": "bun run clean && bun run typecheck && bun run test && bun run build"
   },
   "devDependencies": {
-    "@types/babel__generator": "^7.27.0",
-    "@types/babel__traverse": "^7.28.0",
+    "@oxc-project/types": "^0.150.0",
     "@types/bun": "latest"
   },
   "dependencies": {
-    "@babel/core": "^7.29.7",
-    "@babel/generator": "^7.29.8",
-    "@babel/parser": "^7.29.8",
-    "@babel/traverse": "^7.29.8",
-    "@babel/types": "^7.29.8"
+    "esrap": "^2.3.7",
+    "oxc-parser": "^0.150.0"
   },
   "peerDependencies": {
     "typescript": ">=5.0.0 <8.0.0"