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

package/types/utils/getFileIdx.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFileIdx = getFileIdx;
 let nextIdx = 1;
 const processed = new Map();
-function getFileIdx(name) {
+export function getFileIdx(name) {
     if (!processed.has(name)) {
         // eslint-disable-next-line no-plusplus
         processed.set(name, nextIdx++);

package/types/utils/getPluginKey.d.ts

@@ -1,2 +1,5 @@
-import type { PluginItem } from '@babel/core';
-export declare const getPluginKey: (plugin: PluginItem) => string | null;
+type PluginItemLike = string | readonly [PluginItemLike, ...unknown[]] | {
+    key?: string | null;
+} | object | null | undefined;
+export declare const getPluginKey: (plugin: PluginItemLike) => string | null;
+export {};

package/types/utils/getPluginKey.js

@@ -1,16 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPluginKey = void 0;
-const getPluginKey = (plugin) => {
+export const getPluginKey = (plugin) => {
     if (typeof plugin === 'string') {
         return plugin;
     }
     if (Array.isArray(plugin)) {
-        return (0, exports.getPluginKey)(plugin[0]);
+        return getPluginKey(plugin[0]);
     }
     if (typeof plugin === 'object' && plugin !== null && 'key' in plugin) {
         return plugin.key ?? null;
     }
     return null;
 };
-exports.getPluginKey = getPluginKey;

package/types/utils/getVisitorKeys.d.ts

@@ -1,5 +1,5 @@
-import type { Node } from '@babel/types';
-export type VisitorKeys<T extends Node> = {
-    [K in keyof T]: Exclude<T[K], undefined> extends Node | Node[] | null ? K : never;
+import type { AstNode } from '@wyw-in-js/shared';
+export type VisitorKeys<T extends AstNode> = {
+    [K in keyof T]: Exclude<T[K], undefined> extends AstNode | AstNode[] | null ? K : never;
 }[keyof T] & string;
-export declare function getVisitorKeys<TNode extends Node>(node: TNode): VisitorKeys<TNode>[];
+export declare function getVisitorKeys<TNode extends AstNode>(node: TNode): VisitorKeys<TNode>[];

package/types/utils/getVisitorKeys.js

@@ -1,7 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVisitorKeys = getVisitorKeys;
-const core_1 = require("@babel/core");
-function getVisitorKeys(node) {
-    return core_1.types.VISITOR_KEYS[node.type];
+import { isNode } from './isNode';
+export function getVisitorKeys(node) {
+    return Object.keys(node).filter((key) => {
+        const value = node[key];
+        if (isNode(value)) {
+            return true;
+        }
+        return Array.isArray(value) && value.some(isNode);
+    });
 }

package/types/utils/hasCachedWywPrevalExport.d.ts

@@ -0,0 +1,14 @@
+import type { Services } from '../transform/types';
+type CachedEntrypointLike = {
+    evaluated?: boolean;
+    ignored?: boolean;
+    initialCode?: string;
+    loadedAndParsed?: {
+        code?: string;
+        evalConfig?: {
+            filename?: string;
+        };
+    };
+};
+export declare const hasCachedWywPrevalExport: (services: Services, resolved: string, cached: CachedEntrypointLike | undefined) => boolean;
+export type { CachedEntrypointLike };

package/types/utils/hasCachedWywPrevalExport.js

@@ -0,0 +1,30 @@
+import fs from 'node:fs';
+import { collectOxcExportsAndImports } from './collectOxcExportsAndImports';
+import { stripQueryAndHash } from './parseRequest';
+export const hasCachedWywPrevalExport = (services, resolved, cached) => {
+    const knownExports = services.cache.get('exports', resolved);
+    if (knownExports) {
+        return knownExports.includes('__wywPreval') || knownExports.includes('*');
+    }
+    const filename = stripQueryAndHash(resolved);
+    const code = cached?.initialCode ??
+        cached?.loadedAndParsed?.code ??
+        fs.readFileSync(filename, 'utf-8');
+    try {
+        const analyzed = collectOxcExportsAndImports(code, filename);
+        if (analyzed.reexports.some((reexport) => reexport.exported === '*')) {
+            return true;
+        }
+        const exportNames = Array.from(new Set([
+            ...Object.keys(analyzed.exports),
+            ...analyzed.reexports
+                .filter((reexport) => reexport.exported !== '*')
+                .map((reexport) => reexport.exported),
+        ]));
+        services.cache.add('exports', resolved, exportNames);
+        return exportNames.includes('__wywPreval');
+    }
+    catch {
+        return true;
+    }
+};

package/types/utils/hasWywPreval.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = hasWywPreval;
-function hasWywPreval(exports) {
+export default function hasWywPreval(exports) {
     if (!exports || typeof exports !== 'object') {
         return false;
     }

package/types/utils/importOverrides.js

@@ -1,40 +1,30 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toCanonicalFileKey = toCanonicalFileKey;
-exports.toImportKey = toImportKey;
-exports.resolveMockSpecifier = resolveMockSpecifier;
-exports.applyImportOverrideToOnly = applyImportOverrideToOnly;
-exports.getImportOverride = getImportOverride;
-const path_1 = __importDefault(require("path"));
-const shared_1 = require("@wyw-in-js/shared");
-const minimatch_1 = require("minimatch");
-function toCanonicalFileKey(resolved, root) {
-    const rootDir = root ? path_1.default.resolve(root) : process.cwd();
-    const normalizedResolved = path_1.default.resolve(resolved);
-    let relative = path_1.default.relative(rootDir, normalizedResolved);
-    if (path_1.default.sep !== path_1.default.posix.sep) {
-        relative = relative.split(path_1.default.sep).join(path_1.default.posix.sep);
+import path from 'path';
+import { syncResolve, } from '@wyw-in-js/shared';
+import { Minimatch } from 'minimatch';
+export function toCanonicalFileKey(resolved, root) {
+    const rootDir = root ? path.resolve(root) : process.cwd();
+    const normalizedResolved = path.resolve(resolved);
+    let relative = path.relative(rootDir, normalizedResolved);
+    if (path.sep !== path.posix.sep) {
+        relative = relative.split(path.sep).join(path.posix.sep);
     }
     if (!relative.startsWith('.')) {
         relative = `./${relative}`;
     }
     return relative;
 }
-function toImportKey({ source, resolved, root, }) {
-    const isFileImport = source.startsWith('.') || path_1.default.isAbsolute(source);
+export function toImportKey({ source, resolved, root, }) {
+    const isFileImport = source.startsWith('.') || path.isAbsolute(source);
     if (isFileImport && resolved) {
         return { key: toCanonicalFileKey(resolved, root), kind: 'file' };
     }
     return { key: source, kind: 'package' };
 }
-function resolveMockSpecifier({ importer, mock, root, stack, }) {
-    const specifier = mock.startsWith('.') && root ? path_1.default.resolve(root, mock) : mock;
-    return (0, shared_1.syncResolve)(specifier, importer, stack);
+export function resolveMockSpecifier({ importer, mock, root, stack, }) {
+    const specifier = mock.startsWith('.') && root ? path.resolve(root, mock) : mock;
+    return syncResolve(specifier, importer, stack);
 }
-function applyImportOverrideToOnly(only, override) {
+export function applyImportOverrideToOnly(only, override) {
     if (override?.noShake) {
         return ['*'];
     }
@@ -66,7 +56,7 @@ function compileImportOverrides(importOverrides) {
     const matchers = Object.entries(importOverrides)
         .map(([pattern, override]) => {
         return {
-            matcher: new minimatch_1.Minimatch(pattern, minimatchOptions),
+            matcher: new Minimatch(pattern, minimatchOptions),
             override,
             pattern,
             specificity: getPatternSpecificity(pattern),
@@ -91,7 +81,7 @@ function getCompiledImportOverrides(importOverrides) {
     compiledImportOverridesCache.set(importOverrides, compiled);
     return compiled;
 }
-function getImportOverride(importOverrides, key) {
+export function getImportOverride(importOverrides, key) {
     if (!importOverrides) {
         return undefined;
     }

package/types/utils/isNode.d.ts

@@ -1,2 +1,2 @@
-import type { Node } from '@babel/types';
-export declare const isNode: (obj: unknown) => obj is Node;
+import type { AstNode } from '@wyw-in-js/shared';
+export declare const isNode: (obj: unknown) => obj is AstNode;

package/types/utils/isNode.js

@@ -1,7 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNode = void 0;
-const isNode = (obj) => typeof obj === 'object' &&
+export const isNode = (obj) => typeof obj === 'object' &&
     obj !== null &&
-    obj?.type !== undefined;
-exports.isNode = isNode;
+    typeof obj.type === 'string';

package/types/utils/isNotNull.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNotNull = isNotNull;
-function isNotNull(x) {
+export function isNotNull(x) {
     return x !== null;
 }

package/types/utils/isSerializable.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSerializable = isSerializable;
-const shared_1 = require("@wyw-in-js/shared");
-function isSerializable(o) {
+import { isBoxedPrimitive } from '@wyw-in-js/shared';
+export function isSerializable(o) {
     if (Array.isArray(o)) {
         return o.every(isSerializable);
     }
     if (o === null)
         return true;
-    if ((0, shared_1.isBoxedPrimitive)(o))
+    if (isBoxedPrimitive(o))
         return true;
     if (typeof o === 'object') {
         return Object.values(o).every(isSerializable);

package/types/utils/oxcAstService.d.ts

@@ -0,0 +1,11 @@
+import type { AstService } from '@wyw-in-js/processor-utils';
+export type AddedImport = {
+    imported: 'default' | string;
+    local: string;
+    source: string;
+};
+export type OxcAstService = AstService & {
+    getAddedImports(): AddedImport[];
+};
+export declare const createOxcAstService: (usedNames?: Iterable<string>) => OxcAstService;
+export declare const printOxcAstServiceImport: ({ imported, local, source, }: AddedImport) => string;

package/types/utils/oxcAstService.js

@@ -0,0 +1,79 @@
+const createIdentifier = (name) => ({
+    name,
+    type: 'Identifier',
+});
+const createNameAllocator = (usedNames) => {
+    const used = new Set(usedNames);
+    return (hint) => {
+        let candidate = hint.replace(/[^A-Za-z0-9_$]/g, '_') || '_import';
+        if (!/^[A-Za-z_$]/.test(candidate)) {
+            candidate = `_${candidate}`;
+        }
+        let next = candidate;
+        let idx = 2;
+        while (used.has(next)) {
+            next = `${candidate}${idx}`;
+            idx += 1;
+        }
+        used.add(next);
+        return next;
+    };
+};
+export const createOxcAstService = (usedNames = []) => {
+    const addedImports = [];
+    const allocateName = createNameAllocator(usedNames);
+    return {
+        addDefaultImport(source, nameHint = 'defaultImport') {
+            const local = allocateName(nameHint);
+            addedImports.push({ imported: 'default', local, source });
+            return createIdentifier(local);
+        },
+        addNamedImport(name, source, nameHint = name) {
+            const local = allocateName(nameHint);
+            addedImports.push({ imported: name, local, source });
+            return createIdentifier(local);
+        },
+        arrayExpression(elements) {
+            return { elements, type: 'ArrayExpression' };
+        },
+        arrowFunctionExpression(params, body) {
+            return { body, params, type: 'ArrowFunctionExpression' };
+        },
+        blockStatement(body) {
+            return { body, type: 'BlockStatement' };
+        },
+        booleanLiteral(value) {
+            return { type: 'BooleanLiteral', value };
+        },
+        callExpression(callee, args) {
+            return { arguments: args, callee, type: 'CallExpression' };
+        },
+        getAddedImports() {
+            return [...addedImports];
+        },
+        identifier(name) {
+            return createIdentifier(name);
+        },
+        memberExpression(object, property, computed = false) {
+            return { computed, object, property, type: 'MemberExpression' };
+        },
+        nullLiteral() {
+            return { type: 'NullLiteral' };
+        },
+        numericLiteral(value) {
+            return { type: 'NumericLiteral', value };
+        },
+        objectExpression(properties) {
+            return { properties, type: 'ObjectExpression' };
+        },
+        objectProperty(key, value) {
+            return { key, type: 'ObjectProperty', value };
+        },
+        stringLiteral(value) {
+            return { type: 'StringLiteral', value };
+        },
+    };
+};
+export const printOxcAstServiceImport = ({ imported, local, source, }) => imported === 'default'
+    ? `import ${local} from ${JSON.stringify(source)};`
+    : `import { ${imported}${imported === local ? '' : ` as ${local}`} } from ${JSON.stringify(source)};`;

package/types/utils/oxcEmit.d.ts

@@ -0,0 +1,19 @@
+type SourceMap = {
+    file?: string;
+    mappings: string;
+    names: string[];
+    sourceRoot?: string;
+    sources: string[];
+    sourcesContent?: string[];
+    version: number;
+    x_google_ignoreList?: number[];
+};
+export type OxcEmitResult = {
+    code: string;
+    map?: SourceMap;
+};
+export declare const stripTypesAndJsxWithOxc: (code: string, filename: string, options?: {
+    sourcemap?: boolean;
+}) => OxcEmitResult;
+export declare const emitOxcCommonJS: (code: string, filename: string) => OxcEmitResult;
+export {};