@wyw-in-js/transform 1.1.0 → 2.0.0-alpha.1

package/types/transform/{barrelManifest.js → oxcBarrelManifest.js}

@@ -1,12 +1,6 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.analyzeBarrelFile = analyzeBarrelFile;
 /* eslint-disable no-continue, @typescript-eslint/no-use-before-define */
-const traverse_1 = __importDefault(require("@babel/traverse"));
-const types_1 = require("@babel/types");
+import { parseSync } from 'oxc-parser';
+const nameFromModuleExport = (node) => node.type === 'Literal' ? String(node.value) : node.name;
 const isTypeOnlyImport = (statement) => {
     if (statement.importKind === 'type') {
         return true;
@@ -16,8 +10,7 @@ const isTypeOnlyImport = (statement) => {
     }
     return statement.specifiers.every((specifier) => specifier.type === 'ImportSpecifier' && specifier.importKind === 'type');
 };
-const isTypeOnlyExport = (statement) => statement.exportKind === 'type';
-const getModuleExportName = (node) => node.type === 'Identifier' ? node.name : node.value;
+const isTypeOnlyExport = (statement) => 'exportKind' in statement && statement.exportKind === 'type';
 const isTypeOnlyStatement = (statement) => {
     switch (statement.type) {
         case 'EmptyStatement':
@@ -29,60 +22,71 @@ const isTypeOnlyStatement = (statement) => {
             return false;
     }
 };
-function collectExportNamedDeclaration(statement, reexports, explicitExports) {
-    if (!statement.source) {
-        return isTypeOnlyExport(statement);
-    }
-    if (isTypeOnlyExport(statement)) {
-        return true;
-    }
-    const source = statement.source.value;
-    for (const specifier of statement.specifiers) {
-        if (specifier.type === 'ExportSpecifier') {
-            if (specifier.exportKind === 'type') {
-                continue;
-            }
-            explicitExports.add(getModuleExportName(specifier.exported));
-            reexports.push(getNamedReexport(specifier, source));
-            continue;
+const getChildren = (node) => {
+    const result = [];
+    const record = node;
+    Object.keys(record).forEach((key) => {
+        if (key === 'type' || key === 'start' || key === 'end' || key === 'range') {
+            return;
         }
-        if (specifier.type === 'ExportDefaultSpecifier') {
-            explicitExports.add(getModuleExportName(specifier.exported));
-            reexports.push(getDefaultReexport(specifier, source));
-            continue;
-        }
-        if (specifier.type === 'ExportNamespaceSpecifier') {
-            explicitExports.add(getModuleExportName(specifier.exported));
-            reexports.push(getNamespaceReexport(specifier, source));
-            continue;
+        const value = record[key];
+        if (value && typeof value === 'object') {
+            if (Array.isArray(value)) {
+                value.forEach((item) => {
+                    if (item && typeof item === 'object' && 'type' in item) {
+                        result.push({ key, node: item });
+                    }
+                });
+                return;
+            }
+            if ('type' in value) {
+                result.push({ key, node: value });
+            }
         }
-        return false;
+    });
+    return result;
+};
+const collectBindingNames = (pattern) => {
+    if (!pattern) {
+        return [];
     }
-    return statement.specifiers.length > 0;
-}
-function getNamedReexport(specifier, source) {
-    return {
-        exported: getModuleExportName(specifier.exported),
-        imported: getModuleExportName(specifier.local),
-        kind: 'named',
-        source,
-    };
-}
-function getDefaultReexport(specifier, source) {
-    return {
-        exported: getModuleExportName(specifier.exported),
-        imported: 'default',
-        kind: 'named',
-        source,
-    };
-}
-function getNamespaceReexport(specifier, source) {
-    return {
-        exported: getModuleExportName(specifier.exported),
-        kind: 'namespace',
-        source,
-    };
-}
+    if (pattern.type === 'Identifier') {
+        return [pattern.name];
+    }
+    if (pattern.type === 'RestElement') {
+        return collectBindingNames(pattern.argument);
+    }
+    if (pattern.type === 'AssignmentPattern') {
+        return collectBindingNames(pattern.left);
+    }
+    if (pattern.type === 'ObjectPattern') {
+        return pattern.properties.flatMap((property) => property.type === 'RestElement'
+            ? collectBindingNames(property.argument)
+            : collectBindingNames(property.value));
+    }
+    if (pattern.type === 'ArrayPattern') {
+        return pattern.elements.flatMap((element) => collectBindingNames(element));
+    }
+    return [];
+};
+const getLocalDeclarationNames = (declaration) => {
+    if (!declaration) {
+        return [];
+    }
+    if (declaration.type === 'VariableDeclaration') {
+        return declaration.declarations.flatMap((declarator) => collectBindingNames(declarator.id));
+    }
+    if ((declaration.type === 'FunctionDeclaration' ||
+        declaration.type === 'ClassDeclaration') &&
+        declaration.id) {
+        return [declaration.id.name];
+    }
+    if (declaration.type === 'TSEnumDeclaration' ||
+        declaration.type === 'TSModuleDeclaration') {
+        return null;
+    }
+    return [];
+};
 const collectImportBinding = (statement, imports) => {
     if (statement.importKind === 'type') {
         return true;
@@ -99,7 +103,7 @@ const collectImportBinding = (statement, imports) => {
         sawValueImport = true;
         if (specifier.type === 'ImportSpecifier') {
             imports.set(specifier.local.name, {
-                imported: getImportSpecifierName(specifier),
+                imported: nameFromModuleExport(specifier.imported),
                 kind: 'named',
                 source: statement.source.value,
             });
@@ -120,18 +124,31 @@ const collectImportBinding = (statement, imports) => {
     }
     return sawValueImport || isTypeOnlyImport(statement);
 };
-const getImportSpecifierName = (specifier) => getModuleExportName(specifier.imported);
-const getLocalDeclarationNames = (declaration) => {
-    if (declaration.type === 'VariableDeclaration' ||
-        declaration.type === 'FunctionDeclaration' ||
-        declaration.type === 'ClassDeclaration') {
-        return Object.keys((0, types_1.getBindingIdentifiers)(declaration));
+const getNamedReexport = (specifier, source) => ({
+    exported: nameFromModuleExport(specifier.exported),
+    imported: nameFromModuleExport(specifier.local),
+    kind: 'named',
+    source,
+});
+const collectExportNamedDeclaration = (statement, reexports, explicitExports) => {
+    if (!statement.source) {
+        return isTypeOnlyExport(statement);
     }
-    if (declaration.type === 'TSEnumDeclaration' ||
-        declaration.type === 'TSModuleDeclaration') {
-        return null;
+    if (isTypeOnlyExport(statement)) {
+        return true;
     }
-    return [];
+    const source = statement.source.value;
+    for (const specifier of statement.specifiers) {
+        if (specifier.type !== 'ExportSpecifier') {
+            return false;
+        }
+        if (specifier.exportKind === 'type') {
+            continue;
+        }
+        explicitExports.add(nameFromModuleExport(specifier.exported));
+        reexports.push(getNamedReexport(specifier, source));
+    }
+    return statement.specifiers.length > 0;
 };
 const collectLocalExportNamedDeclaration = (statement, importedBindings, passthroughCandidates, explicitExports) => {
     let complete = true;
@@ -149,9 +166,7 @@ const collectLocalExportNamedDeclaration = (statement, importedBindings, passthr
                 ok: false,
             };
         }
-        for (const name of names) {
-            explicitExports.add(name);
-        }
+        names.forEach((name) => explicitExports.add(name));
         return {
             complete: names.length === 0,
             ok: true,
@@ -167,7 +182,7 @@ const collectLocalExportNamedDeclaration = (statement, importedBindings, passthr
         if (specifier.exportKind === 'type') {
             continue;
         }
-        const exported = getModuleExportName(specifier.exported);
+        const exported = nameFromModuleExport(specifier.exported);
         explicitExports.add(exported);
         if (specifier.local.type !== 'Identifier') {
             complete = false;
@@ -187,19 +202,46 @@ const collectLocalExportNamedDeclaration = (statement, importedBindings, passthr
         ok: true,
     };
 };
-const collectPassthroughReexports = (ast, importedBindings, passthroughCandidates, reexports) => {
+const isBindingIdentifier = (node, parent, key) => {
+    if (!parent) {
+        return false;
+    }
+    if ((parent.type === 'ImportSpecifier' ||
+        parent.type === 'ImportDefaultSpecifier' ||
+        parent.type === 'ImportNamespaceSpecifier') &&
+        key === 'local') {
+        return true;
+    }
+    if (parent.type === 'VariableDeclarator' && key === 'id') {
+        return true;
+    }
+    if ((parent.type === 'FunctionDeclaration' ||
+        parent.type === 'ClassDeclaration') &&
+        key === 'id') {
+        return true;
+    }
+    return false;
+};
+const countBindingReferences = (node, names, counts, parent = null, key = '') => {
+    if (node.type === 'ImportDeclaration' || node.type.startsWith('TS')) {
+        return;
+    }
+    if (node.type === 'Identifier' &&
+        names.has(node.name) &&
+        !isBindingIdentifier(node, parent, key) &&
+        !(parent?.type === 'ExportSpecifier' && key === 'exported') &&
+        !(parent?.type === 'Property' && parent.key === node && !parent.computed)) {
+        counts.set(node.name, (counts.get(node.name) ?? 0) + 1);
+    }
+    getChildren(node).forEach((child) => countBindingReferences(child.node, names, counts, node, child.key));
+};
+const collectPassthroughReexports = (program, importedBindings, passthroughCandidates, reexports) => {
     let complete = true;
+    const candidateNames = new Set(passthroughCandidates.keys());
     const bindingReferenceCounts = new Map();
-    (0, traverse_1.default)(ast, {
-        Program(path) {
-            for (const localName of passthroughCandidates.keys()) {
-                bindingReferenceCounts.set(localName, path.scope.getBinding(localName)?.referencePaths.length ?? -1);
-            }
-            path.stop();
-        },
-    });
+    countBindingReferences(program, candidateNames, bindingReferenceCounts);
     for (const [localName, exportedNames] of passthroughCandidates) {
-        if (bindingReferenceCounts.get(localName) !== exportedNames.length) {
+        if ((bindingReferenceCounts.get(localName) ?? 0) !== exportedNames.length) {
             complete = false;
             continue;
         }
@@ -226,14 +268,26 @@ const collectPassthroughReexports = (ast, importedBindings, passthroughCandidate
         ok: true,
     };
 };
-function analyzeBarrelProgram(ast) {
+const parseProgram = (code, filename) => {
+    const parsed = parseSync(filename, code, {
+        astType: filename.endsWith('.ts') || filename.endsWith('.tsx') ? 'ts' : 'js',
+        range: true,
+        sourceType: 'module',
+    });
+    const fatalError = parsed.errors.find((error) => error.severity === 'Error');
+    if (fatalError) {
+        throw new Error(fatalError.message);
+    }
+    return parsed.program;
+};
+const analyzeBarrelProgram = (program) => {
     const reexports = [];
     const explicitExports = new Set();
     const exportAll = [];
     const importedBindings = new Map();
     const passthroughCandidates = new Map();
     let complete = true;
-    for (const statement of ast.program.body) {
+    for (const statement of program.body) {
         if (statement.type === 'ImportDeclaration') {
             if (!collectImportBinding(statement, importedBindings)) {
                 return null;
@@ -255,13 +309,19 @@ function analyzeBarrelProgram(ast) {
             continue;
         }
         if (statement.type === 'ExportAllDeclaration') {
-            if (statement.exportKind === 'type') {
+            if (isTypeOnlyExport(statement)) {
                 continue;
             }
-            if (!statement.source) {
-                return null;
+            if (statement.exported) {
+                explicitExports.add(nameFromModuleExport(statement.exported));
+                reexports.push({
+                    exported: nameFromModuleExport(statement.exported),
+                    kind: 'namespace',
+                    source: statement.source.value,
+                });
+                continue;
             }
-            exportAll.push(getExportAllSource(statement));
+            exportAll.push(statement.source.value);
             continue;
         }
         if (statement.type === 'ExportDefaultDeclaration') {
@@ -271,7 +331,7 @@ function analyzeBarrelProgram(ast) {
             return null;
         }
     }
-    const passthroughResult = collectPassthroughReexports(ast, importedBindings, passthroughCandidates, reexports);
+    const passthroughResult = collectPassthroughReexports(program, importedBindings, passthroughCandidates, reexports);
     if (!passthroughResult.ok) {
         return null;
     }
@@ -286,10 +346,9 @@ function analyzeBarrelProgram(ast) {
         kind: 'barrel',
         reexports,
     };
-}
-const getExportAllSource = (statement) => statement.source.value;
-function analyzeBarrelFile(ast) {
-    const result = analyzeBarrelProgram(ast);
+};
+export function analyzeOxcBarrelFile(code, filename) {
+    const result = analyzeBarrelProgram(parseProgram(code, filename));
     if (!result) {
         return {
             kind: 'ineligible',

package/types/transform/rootLog.js

@@ -1,5 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rootLog = void 0;
-const shared_1 = require("@wyw-in-js/shared");
-exports.rootLog = shared_1.logger.extend('transform');
+import { logger } from '@wyw-in-js/shared';
+export const rootLog = logger.extend('transform');

package/types/transform/syntax.d.ts

@@ -0,0 +1,38 @@
+export type SyntaxEngine = 'oxc';
+export type SyntaxSourceLocation = {
+    column: number;
+    line: number;
+};
+export type SyntaxSourceRange = {
+    end: SyntaxSourceLocation;
+    start: SyntaxSourceLocation;
+};
+export type ParsedModule<TAst = unknown> = {
+    ast: TAst;
+    code: string;
+    engine: SyntaxEngine;
+    filename: string;
+};
+export type ModuleImport = {
+    imported: string;
+    source: string;
+};
+export type ModuleReexport = {
+    exported: string;
+    source: string;
+};
+export type ModuleAnalysis = {
+    exports: readonly string[];
+    imports: readonly ModuleImport[];
+    reexports: readonly ModuleReexport[];
+};
+export type EmittedModule<TSourceMap = unknown> = {
+    code: string;
+    map?: TSourceMap | null;
+};
+export type SyntaxAdapter<TAst = unknown, TParseOptions = unknown, TEmitOptions = unknown> = {
+    engine: SyntaxEngine;
+    analyze(module: ParsedModule<TAst>): ModuleAnalysis;
+    emit(module: ParsedModule<TAst>, options?: TEmitOptions): EmittedModule;
+    parse(code: string, filename: string, options?: TParseOptions): ParsedModule<TAst>;
+};

package/types/transform/syntax.js

@@ -0,0 +1 @@
+export {};

package/types/transform/types.d.ts

@@ -1,7 +1,6 @@
-import type { BabelFileResult } from '@babel/core';
 import type { ValueCache } from '@wyw-in-js/processor-utils';
 import type { Debugger, Artifact, StrictOptions } from '@wyw-in-js/shared';
-import type { Core } from '../babel';
+import type { RawSourceMap } from 'source-map';
 import type { TransformCacheCollection } from '../cache';
 import type { Options, ITransformFileResult } from '../types';
 import type { EventEmitter } from '../utils/EventEmitter';
@@ -10,8 +9,8 @@ import type { Entrypoint } from './Entrypoint';
 import type { LoadAndParseFn, IEntrypointDependency } from './Entrypoint.types';
 import type { BaseAction } from './actions/BaseAction';
 import type { IExtracted, IWorkflowActionLinariaResult, IWorkflowActionNonLinariaResult } from './actions/types';
+import type { EvalBroker } from '../eval/broker';
 export type Services = {
-    babel: Core;
     cache: TransformCacheCollection;
     emitWarning?: (message: string) => void;
     eventEmitter: EventEmitter;
@@ -20,6 +19,9 @@ export type Services = {
     options: Options & {
         pluginOptions: StrictOptions;
     };
+    asyncResolve?: (what: string, importer: string, stack: string[]) => Promise<string | null>;
+    asyncResolveKey?: string;
+    evalBroker?: EvalBroker;
 };
 export interface IBaseNode {
     type: ActionTypes;
@@ -88,9 +90,9 @@ export type GetNext = <TType extends ActionTypes, TNextAction extends ActionByTy
     AbortSignal | null
 ], TypeOfResult<TNextAction>, YieldResult>;
 export interface ICollectActionResult {
-    ast: BabelFileResult['ast'];
-    code: BabelFileResult['code'];
-    map?: BabelFileResult['map'];
+    ast: unknown;
+    code: string | null | undefined;
+    map?: RawSourceMap | null;
     metadata?: WYWTransformMetadata | null;
 }
 export interface ICollectAction extends IBaseAction<ICollectAction, ICollectActionResult, {
@@ -119,6 +121,7 @@ export interface IProcessEntrypointAction extends IBaseAction<IProcessEntrypoint
 }
 export interface IProcessImportsAction extends IBaseAction<IProcessImportsAction, void, {
     resolved: IEntrypointDependency[];
+    skipParentDependencyTracking?: string[];
 }> {
     type: 'processImports';
 }

package/types/transform/types.js

@@ -1,4 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Pending = void 0;
-exports.Pending = Symbol('pending');
+export const Pending = Symbol('pending');

package/types/transform.d.ts

@@ -5,7 +5,7 @@
  * - shakes each dependency and removes unused code
  * - runs generated code in a sandbox
  * - collects artifacts
- * - returns transformed code (without WYW template literals), generated CSS, source maps and babel metadata from transform step.
+ * - returns transformed code (without WYW template literals), generated CSS, source maps and transform metadata.
  */
 import type { PartialOptions } from './transform/helpers/loadWywOptions';
 import type { Handlers, Services } from './transform/types';
@@ -16,6 +16,6 @@ type PartialServices = Partial<Omit<Services, 'options'>> & {
     };
 };
 type AllHandlers<TMode extends 'async' | 'sync'> = Handlers<TMode>;
-export declare function transformSync(partialServices: PartialServices, originalCode: string, syncResolve: (what: string, importer: string, stack: string[]) => string, customHandlers?: Partial<AllHandlers<'sync'>>): Result;
+export declare function transformSync(_partialServices: PartialServices, _originalCode: string, _syncResolve: (what: string, importer: string, stack: string[]) => string, _customHandlers?: Partial<AllHandlers<'sync'>>): Result;
 export declare function transform(partialServices: PartialServices, originalCode: string, asyncResolve: (what: string, importer: string, stack: string[]) => Promise<string | null>, customHandlers?: Partial<AllHandlers<'sync'>>): Promise<Result>;
 export {};