@wyw-in-js/transform 0.1.0

package/types/shaker.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ShakerMetadata_1 = require("./utils/ShakerMetadata");
+const getPluginKey_1 = require("./utils/getPluginKey");
+const hasKeyInList = (plugin, list) => {
+    const pluginKey = (0, getPluginKey_1.getPluginKey)(plugin);
+    return pluginKey ? list.some((i) => pluginKey.includes(i)) : false;
+};
+const safeResolve = (id, paths) => {
+    try {
+        return require.resolve(id, {
+            paths: paths.filter((i) => i !== null),
+        });
+    }
+    catch {
+        return null;
+    }
+};
+const shaker = (evalConfig, ast, code, { highPriorityPlugins, ...config }, babel) => {
+    const preShakePlugins = evalConfig.plugins?.filter((i) => hasKeyInList(i, highPriorityPlugins)) ??
+        [];
+    const plugins = [
+        ...preShakePlugins,
+        [require.resolve('./plugins/shaker'), config],
+        ...(evalConfig.plugins ?? []).filter((i) => !hasKeyInList(i, highPriorityPlugins)),
+    ];
+    const hasCommonjsPlugin = evalConfig.plugins?.some((i) => (0, getPluginKey_1.getPluginKey)(i) === 'transform-modules-commonjs');
+    if (!hasCommonjsPlugin) {
+        plugins.push(require.resolve('@babel/plugin-transform-modules-commonjs'));
+    }
+    if (evalConfig.filename?.endsWith('.ts') ||
+        evalConfig.filename?.endsWith('.tsx')) {
+        const hasTypescriptPlugin = evalConfig.plugins?.some((i) => (0, getPluginKey_1.getPluginKey)(i) === 'transform-typescript');
+        if (!hasTypescriptPlugin) {
+            const preset = safeResolve('@babel/preset-typescript', [
+                evalConfig.filename,
+            ]);
+            const plugin = safeResolve('@babel/plugin-transform-typescript', [
+                evalConfig.filename,
+                preset,
+            ]);
+            if (plugin) {
+                plugins.push(plugin);
+            }
+        }
+    }
+    const transformOptions = {
+        ...evalConfig,
+        caller: {
+            name: 'linaria',
+        },
+        plugins,
+    };
+    const transformed = babel.transformFromAstSync(ast, code, transformOptions);
+    if (!transformed || !(0, ShakerMetadata_1.hasShakerMetadata)(transformed.metadata)) {
+        throw new Error(`${evalConfig.filename} has no shaker metadata`);
+    }
+    return [
+        transformed.ast,
+        transformed.code ?? '',
+        transformed.metadata.linariaEvaluator.imports,
+    ];
+};
+exports.default = shaker;

package/types/transform/BaseEntrypoint.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="debug" />
+import type { Debugger } from '@wyw-in-js/shared';
+import type { ParentEntrypoint } from '../types';
+import type { Services } from './types';
+export declare const createExports: (log: Debugger) => Record<string | symbol, unknown>;
+export declare abstract class BaseEntrypoint {
+    #private;
+    protected services: Services;
+    readonly evaluatedOnly: string[];
+    readonly generation: number;
+    readonly name: string;
+    readonly only: string[];
+    readonly parents: ParentEntrypoint[];
+    static createExports: (log: Debugger) => Record<string | symbol, unknown>;
+    readonly idx: string;
+    readonly log: Debugger;
+    readonly seqId: number;
+    protected constructor(services: Services, evaluatedOnly: string[], exports: Record<string | symbol, unknown> | undefined, generation: number, name: string, only: string[], parents: ParentEntrypoint[]);
+    get exports(): Record<string | symbol, unknown>;
+    set exports(value: unknown);
+    get ref(): string;
+    protected get exportsProxy(): Record<string | symbol, unknown>;
+}

package/types/transform/BaseEntrypoint.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseEntrypoint = exports.createExports = void 0;
+const getFileIdx_1 = require("../utils/getFileIdx");
+const hasKey = (obj, key) => (typeof obj === 'object' || typeof obj === 'function') &&
+    obj !== null &&
+    key in obj;
+const VALUES = Symbol('values');
+const isProxy = (obj) => typeof obj === 'object' && obj !== null && VALUES in obj;
+const createExports = (log) => {
+    let exports = {};
+    const lazyFields = new Set();
+    return new Proxy(exports, {
+        get: (_target, key) => {
+            if (key === VALUES) {
+                return exports;
+            }
+            let value;
+            if (key in exports) {
+                value = exports[key];
+            }
+            else {
+                // Support Object.prototype methods on `exports`
+                // e.g `exports.hasOwnProperty`
+                value = Reflect.get(exports, key);
+            }
+            if (value === undefined && 'default' in exports) {
+                const defaultValue = exports.default;
+                if (hasKey(defaultValue, key)) {
+                    log('⚠️  %s has been found in `default`. It indicates that ESM to CJS conversion went wrong.', key);
+                    value = defaultValue[key];
+                }
+            }
+            if (value !== undefined && lazyFields.has(key)) {
+                value = value();
+            }
+            log('get %s: %o', key, value);
+            return value;
+        },
+        has: (_target, key) => {
+            if (key === VALUES)
+                return true;
+            return key in exports;
+        },
+        ownKeys: () => {
+            return Object.keys(exports);
+        },
+        set: (_target, key, value) => {
+            if (key === VALUES) {
+                exports = value;
+                return true;
+            }
+            if (key !== '__esModule') {
+                log('set %s: %o', key, value);
+            }
+            if (value !== undefined) {
+                exports[key] = value;
+                lazyFields.delete(key);
+            }
+            return true;
+        },
+        defineProperty: (_target, key, descriptor) => {
+            const { value } = descriptor;
+            if (value !== undefined) {
+                if (key !== '__esModule') {
+                    log('defineProperty %s with value %o', key, value);
+                }
+                exports[key] = value;
+                lazyFields.delete(key);
+                return true;
+            }
+            if ('get' in descriptor) {
+                if (lazyFields.has(key)) {
+                    const prev = exports[key];
+                    exports[key] = () => {
+                        const v = descriptor.get?.();
+                        if (v !== undefined) {
+                            return v;
+                        }
+                        return prev();
+                    };
+                }
+                else {
+                    const prev = exports[key];
+                    exports[key] = () => {
+                        const v = descriptor.get?.();
+                        if (v !== undefined) {
+                            return v;
+                        }
+                        return prev;
+                    };
+                }
+                lazyFields.add(key);
+                log('defineProperty %s with getter', key);
+            }
+            return true;
+        },
+        getOwnPropertyDescriptor: (_target, key) => {
+            if (key in exports)
+                return {
+                    enumerable: true,
+                    configurable: true,
+                };
+            return undefined;
+        },
+    });
+};
+exports.createExports = createExports;
+const EXPORTS = Symbol('exports');
+let entrypointSeqId = 0;
+class BaseEntrypoint {
+    services;
+    evaluatedOnly;
+    generation;
+    name;
+    only;
+    parents;
+    static createExports = exports.createExports;
+    idx;
+    log;
+    // eslint-disable-next-line no-plusplus
+    seqId = entrypointSeqId++;
+    #exports;
+    constructor(services, evaluatedOnly, exports, generation, name, only, parents) {
+        this.services = services;
+        this.evaluatedOnly = evaluatedOnly;
+        this.generation = generation;
+        this.name = name;
+        this.only = only;
+        this.parents = parents;
+        this.idx = (0, getFileIdx_1.getFileIdx)(name);
+        this.log =
+            parents[0]?.log.extend(this.ref, '->') ?? services.log.extend(this.ref);
+        let isExportsInherited = false;
+        if (exports) {
+            if (isProxy(exports)) {
+                this.#exports = exports;
+                isExportsInherited = true;
+            }
+            else {
+                this.#exports = (0, exports.createExports)(this.log);
+                this.#exports[EXPORTS] = exports;
+            }
+            this.exports = exports;
+        }
+        else {
+            this.#exports = BaseEntrypoint.createExports(this.log);
+        }
+        services.eventEmitter.entrypointEvent(this.seqId, {
+            class: this.constructor.name,
+            evaluatedOnly: this.evaluatedOnly,
+            filename: name,
+            generation,
+            idx: this.idx,
+            isExportsInherited,
+            only,
+            parentId: parents[0]?.seqId ?? null,
+            type: 'created',
+        });
+    }
+    get exports() {
+        if (EXPORTS in this.#exports) {
+            return this.#exports[EXPORTS];
+        }
+        return this.#exports;
+    }
+    set exports(value) {
+        if (isProxy(value)) {
+            this.#exports[VALUES] = value[VALUES];
+        }
+        else {
+            this.#exports[EXPORTS] = value;
+        }
+    }
+    get ref() {
+        return `${this.idx}#${this.generation}`;
+    }
+    get exportsProxy() {
+        return this.#exports;
+    }
+}
+exports.BaseEntrypoint = BaseEntrypoint;

package/types/transform/Entrypoint.d.ts

@@ -0,0 +1,50 @@
+import type { ParentEntrypoint, ITransformFileResult } from '../types';
+import { BaseEntrypoint } from './BaseEntrypoint';
+import type { IEntrypointCode, IEntrypointDependency, IIgnoredEntrypoint } from './Entrypoint.types';
+import { EvaluatedEntrypoint } from './EvaluatedEntrypoint';
+import type { ActionByType } from './actions/BaseAction';
+import { BaseAction } from './actions/BaseAction';
+import type { Services, ActionTypes } from './types';
+export declare class Entrypoint extends BaseEntrypoint {
+    #private;
+    readonly initialCode: string | undefined;
+    protected readonly resolveTasks: Map<string, Promise<IEntrypointDependency>>;
+    protected readonly dependencies: Map<string, IEntrypointDependency>;
+    readonly evaluated = false;
+    readonly loadedAndParsed: IEntrypointCode | IIgnoredEntrypoint;
+    protected onSupersedeHandlers: Array<(newEntrypoint: Entrypoint) => void>;
+    private actionsCache;
+    private constructor();
+    get ignored(): boolean;
+    get originalCode(): string | undefined;
+    get supersededWith(): Entrypoint | null;
+    get transformedCode(): string | null;
+    static createRoot(services: Services, name: string, only: string[], loadedCode: string | undefined): Entrypoint;
+    /**
+     * Creates an entrypoint for the specified file.
+     * If there is already an entrypoint for this file, there will be four possible outcomes:
+     * 1. If `loadedCode` is specified and is different from the one that was used to create the existing entrypoint,
+     *   the existing entrypoint will be superseded by a new one and all cached results for it will be invalidated.
+     *   It can happen if the file was changed and the watcher notified us about it, or we received a new version
+     *   of the file from a loader whereas the previous one was loaded from the filesystem.
+     *   The new entrypoint will be returned.
+     * 2. If `only` is subset of the existing entrypoint's `only`, the existing entrypoint will be returned.
+     * 3. If `only` is superset of the existing entrypoint's `only`, the existing entrypoint will be superseded and the new one will be returned.
+     * 4. If a loop is detected, 'ignored' will be returned, the existing entrypoint will be superseded or not depending on the `only` value.
+     */
+    protected static create(services: Services, parent: ParentEntrypoint | null, name: string, only: string[], loadedCode: string | undefined): Entrypoint | 'loop';
+    private static innerCreate;
+    addDependency(dependency: IEntrypointDependency): void;
+    addResolveTask(name: string, dependency: Promise<IEntrypointDependency>): void;
+    assertNotSuperseded(): void;
+    assertTransformed(): void;
+    createAction<TType extends ActionTypes, TAction extends ActionByType<TType>>(actionType: TType, data: TAction['data'], abortSignal?: AbortSignal | null): BaseAction<TAction>;
+    createChild(name: string, only: string[], loadedCode?: string): Entrypoint | 'loop';
+    createEvaluated(): EvaluatedEntrypoint;
+    getDependency(name: string): IEntrypointDependency | undefined;
+    getResolveTask(name: string): Promise<IEntrypointDependency> | undefined;
+    hasLinariaMetadata(): boolean;
+    onSupersede(callback: (newEntrypoint: Entrypoint) => void): () => void;
+    setTransformResult(res: ITransformFileResult | null): void;
+    private supersede;
+}

package/types/transform/Entrypoint.helpers.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="debug" />
+import type { TransformOptions } from '@babel/core';
+import type { File } from '@babel/types';
+import type { Debugger, EvalRule } from '@wyw-in-js/shared';
+import type { Core } from '../babel';
+import type { ParentEntrypoint } from '../types';
+import type { IEntrypointCode, IIgnoredEntrypoint } from './Entrypoint.types';
+import type { Services } from './types';
+export declare function getMatchedRule(rules: EvalRule[], filename: string, code: string): EvalRule;
+export declare function parseFile(babel: Core, filename: string, originalCode: string, parseConfig: TransformOptions): File;
+export declare function loadAndParse(services: Services, name: string, loadedCode: string | undefined, log: Debugger): IEntrypointCode | IIgnoredEntrypoint;
+export declare function getStack(entrypoint: ParentEntrypoint): string[];
+export declare function mergeOnly(a: string[], b: string[]): string[];
+export declare const isSuperSet: <T>(a: (T | "*")[], b: (T | "*")[]) => boolean;

package/types/transform/Entrypoint.helpers.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSuperSet = exports.mergeOnly = exports.getStack = exports.loadAndParse = exports.parseFile = exports.getMatchedRule = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const shared_1 = require("@wyw-in-js/shared");
+const buildOptions_1 = require("../options/buildOptions");
+const loadBabelOptions_1 = require("../options/loadBabelOptions");
+const getFileIdx_1 = require("../utils/getFileIdx");
+const getPluginKey_1 = require("../utils/getPluginKey");
+function getMatchedRule(rules, filename, code) {
+    for (let i = rules.length - 1; i >= 0; i--) {
+        const rule = rules[i];
+        if (!rule.test) {
+            return rule;
+        }
+        if (typeof rule.test === 'function' && rule.test(filename, code)) {
+            return rule;
+        }
+        if (rule.test instanceof RegExp && rule.test.test(filename)) {
+            return rule;
+        }
+    }
+    return { action: 'ignore' };
+}
+exports.getMatchedRule = getMatchedRule;
+function parseFile(babel, filename, originalCode, parseConfig) {
+    const log = shared_1.logger.extend('transform:parse').extend((0, getFileIdx_1.getFileIdx)(filename));
+    const parseResult = babel.parseSync(originalCode, parseConfig);
+    if (!parseResult) {
+        throw new Error(`Failed to parse ${filename}`);
+    }
+    log('stage-1', `${filename} has been parsed`);
+    return parseResult;
+}
+exports.parseFile = parseFile;
+const isModuleResolver = (plugin) => {
+    const key = (0, getPluginKey_1.getPluginKey)(plugin);
+    if (!key)
+        return false;
+    if (['module-resolver', 'babel-plugin-module-resolver'].includes(key)) {
+        return true;
+    }
+    return /([\\/])babel-plugin-module-resolver\1/.test(key);
+};
+let moduleResolverWarned = false;
+function buildConfigs(services, name, pluginOptions, babelOptions) {
+    const { babel, options } = services;
+    const commonOptions = {
+        ast: true,
+        filename: name,
+        inputSourceMap: options.inputSourceMap,
+        root: options.root,
+        sourceFileName: name,
+        sourceMaps: true,
+    };
+    const rawConfig = (0, buildOptions_1.buildOptions)(pluginOptions?.babelOptions, babelOptions, commonOptions);
+    const useBabelConfigs = (0, shared_1.isFeatureEnabled)(pluginOptions.features, 'useBabelConfigs', name);
+    if (!useBabelConfigs) {
+        rawConfig.configFile = false;
+    }
+    const parseConfig = (0, loadBabelOptions_1.loadBabelOptions)(babel, name, {
+        babelrc: useBabelConfigs,
+        ...rawConfig,
+    });
+    const parseHasModuleResolver = parseConfig.plugins?.some(isModuleResolver);
+    const rawHasModuleResolver = rawConfig.plugins?.some(isModuleResolver);
+    if (parseHasModuleResolver && !rawHasModuleResolver) {
+        if (!moduleResolverWarned) {
+            // eslint-disable-next-line no-console
+            console.warn(`[linaria] ${name} has a module-resolver plugin in its babelrc, but it is not present ` +
+                `in the babelOptions for the linaria plugin. This works for now but will be an error in the future. ` +
+                `Please add the module-resolver plugin to the babelOptions for the linaria plugin.`);
+            moduleResolverWarned = true;
+        }
+        rawConfig.plugins = [
+            ...(parseConfig.plugins?.filter((plugin) => isModuleResolver(plugin)) ??
+                []),
+            ...(rawConfig.plugins ?? []),
+        ];
+    }
+    const evalConfig = (0, loadBabelOptions_1.loadBabelOptions)(babel, name, {
+        babelrc: false,
+        ...rawConfig,
+    });
+    return {
+        evalConfig,
+        parseConfig,
+    };
+}
+function loadAndParse(services, name, loadedCode, log) {
+    const { babel, eventEmitter, options: { pluginOptions }, } = services;
+    const extension = (0, path_1.extname)(name);
+    if (!pluginOptions.extensions.includes(extension)) {
+        log('[createEntrypoint] %s is ignored. If you want it to be processed, you should add \'%s\' to the "extensions" option.', name, extension);
+        return {
+            get code() {
+                if ((0, path_1.isAbsolute)(name)) {
+                    return loadedCode ?? (0, fs_1.readFileSync)(name, 'utf-8');
+                }
+                return ''; // it is a built-in module
+            },
+            evaluator: 'ignored',
+            reason: 'extension',
+        };
+    }
+    const code = loadedCode ?? (0, fs_1.readFileSync)(name, 'utf-8');
+    const { action, babelOptions } = getMatchedRule(pluginOptions.rules, name, code);
+    let ast;
+    const { evalConfig, parseConfig } = buildConfigs(services, name, pluginOptions, babelOptions);
+    const getOrParse = () => {
+        if (ast)
+            return ast;
+        ast = eventEmitter.perf('parseFile', () => parseFile(babel, name, code, parseConfig));
+        return ast;
+    };
+    if (action === 'ignore') {
+        log('[createEntrypoint] %s is ignored by rule', name);
+        return {
+            get ast() {
+                return getOrParse();
+            },
+            code,
+            evaluator: 'ignored',
+            reason: 'rule',
+        };
+    }
+    const evaluator = typeof action === 'function'
+        ? action
+        : require(require.resolve(action, {
+            paths: [(0, path_1.dirname)(name)],
+        })).default;
+    return {
+        get ast() {
+            return getOrParse();
+        },
+        code,
+        evaluator,
+        evalConfig,
+    };
+}
+exports.loadAndParse = loadAndParse;
+function getStack(entrypoint) {
+    if (!entrypoint)
+        return [];
+    const stack = [entrypoint.name];
+    let { parents } = entrypoint;
+    while (parents.length) {
+        stack.push(parents[0].name);
+        parents = parents[0].parents;
+    }
+    return stack;
+}
+exports.getStack = getStack;
+function mergeOnly(a, b) {
+    const result = new Set(a);
+    b.forEach((item) => result.add(item));
+    return [...result].filter((i) => i).sort();
+}
+exports.mergeOnly = mergeOnly;
+const isSuperSet = (a, b) => {
+    if (a.includes('*'))
+        return true;
+    if (b.length === 0)
+        return true;
+    const aSet = new Set(a);
+    return b.every((item) => aSet.has(item));
+};
+exports.isSuperSet = isSuperSet;