@wyw-in-js/transform 0.1.0

package/types/transform/generators/collect.d.ts

@@ -0,0 +1,6 @@
+import type { ICollectAction, SyncScenarioForAction } from '../types';
+/**
+ * Parses the specified file, finds tags, applies run-time replacements,
+ * removes dead code.
+ */
+export declare function collect(this: ICollectAction): SyncScenarioForAction<ICollectAction>;

package/types/transform/generators/collect.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collect = void 0;
+const buildOptions_1 = require("../../options/buildOptions");
+const collector_1 = require("../../plugins/collector");
+const TransformMetadata_1 = require("../../utils/TransformMetadata");
+/**
+ * Parses the specified file, finds tags, applies run-time replacements,
+ * removes dead code.
+ */
+// eslint-disable-next-line require-yield
+function* collect() {
+    const { babel, options } = this.services;
+    const { valueCache } = this.data;
+    const { entrypoint } = this;
+    const { loadedAndParsed, name } = entrypoint;
+    if (loadedAndParsed.evaluator === 'ignored') {
+        throw new Error('entrypoint was ignored');
+    }
+    const transformPlugins = [
+        [
+            collector_1.filename,
+            {
+                ...options.pluginOptions,
+                values: valueCache,
+            },
+        ],
+    ];
+    const transformConfig = (0, buildOptions_1.buildOptions)({
+        envName: 'linaria',
+        plugins: transformPlugins,
+        sourceMaps: true,
+        sourceFileName: name,
+        inputSourceMap: options.inputSourceMap,
+        root: options.root,
+        ast: true,
+        babelrc: false,
+        configFile: false,
+        sourceType: 'unambiguous',
+    });
+    const result = babel.transformFromAstSync(loadedAndParsed.ast, loadedAndParsed.code, {
+        ...transformConfig,
+        cwd: options.root,
+        filename: name,
+    });
+    if (!result || !result.ast?.program) {
+        throw new Error('Babel transform failed');
+    }
+    const transformMetadata = (0, TransformMetadata_1.getTransformMetadata)(result.metadata);
+    return {
+        ast: result.ast,
+        code: result.code,
+        map: result.map,
+        metadata: transformMetadata ?? null,
+    };
+}
+exports.collect = collect;

package/types/transform/generators/evalFile.d.ts

@@ -0,0 +1,6 @@
+import type { IEvalAction, SyncScenarioForAction } from '../types';
+/**
+ * Executes the code prepared in previous steps within the current `Entrypoint`.
+ * Returns all exports that were requested in `only`.
+ */
+export declare function evalFile(this: IEvalAction): SyncScenarioForAction<IEvalAction>;

package/types/transform/generators/evalFile.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evalFile = void 0;
+const evaluators_1 = __importDefault(require("../../evaluators"));
+const hasLinariaPreval_1 = __importDefault(require("../../utils/hasLinariaPreval"));
+const UnprocessedEntrypointError_1 = require("../actions/UnprocessedEntrypointError");
+const wrap = (fn) => {
+    try {
+        return fn();
+    }
+    catch (e) {
+        return e;
+    }
+};
+/**
+ * Executes the code prepared in previous steps within the current `Entrypoint`.
+ * Returns all exports that were requested in `only`.
+ */
+// eslint-disable-next-line require-yield
+function* evalFile() {
+    const { entrypoint } = this;
+    const { log } = entrypoint;
+    log(`>> evaluate __linariaPreval`);
+    let evaluated;
+    while (evaluated === undefined) {
+        try {
+            evaluated = (0, evaluators_1.default)(this.services, entrypoint);
+        }
+        catch (e) {
+            if ((0, UnprocessedEntrypointError_1.isUnprocessedEntrypointError)(e)) {
+                entrypoint.log('Evaluation has been aborted because one if the required files is not processed. Schedule reprocessing and repeat evaluation.');
+                yield ['processEntrypoint', e.entrypoint, undefined];
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    const linariaPreval = (0, hasLinariaPreval_1.default)(evaluated.value)
+        ? evaluated.value.__linariaPreval
+        : undefined;
+    if (!linariaPreval) {
+        return null;
+    }
+    const valueCache = new Map();
+    Object.entries(linariaPreval).forEach(([key, lazyValue]) => {
+        const value = wrap(lazyValue);
+        valueCache.set(key, value);
+    });
+    log(`<< evaluated __linariaPreval %O`, valueCache);
+    return [valueCache, evaluated.dependencies];
+}
+exports.evalFile = evalFile;

package/types/transform/generators/explodeReexports.d.ts

@@ -0,0 +1,7 @@
+import type { IExplodeReexportsAction, SyncScenarioForAction } from '../types';
+/**
+ * Replaces wildcard reexports with named reexports.
+ * Recursively emits getExports for each reexported module,
+ * and replaces wildcard with resolved named.
+ */
+export declare function explodeReexports(this: IExplodeReexportsAction): SyncScenarioForAction<IExplodeReexportsAction>;

package/types/transform/generators/explodeReexports.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.explodeReexports = void 0;
+const generator_1 = __importDefault(require("@babel/generator"));
+const getExports_1 = require("./getExports");
+const getWildcardReexport = (babel, ast) => {
+    const reexportsFrom = [];
+    ast.program.body.forEach((node) => {
+        if (babel.types.isExportAllDeclaration(node) &&
+            node.source &&
+            babel.types.isStringLiteral(node.source)) {
+            reexportsFrom.push({
+                source: node.source.value,
+                node,
+            });
+        }
+    });
+    return reexportsFrom;
+};
+/**
+ * Replaces wildcard reexports with named reexports.
+ * Recursively emits getExports for each reexported module,
+ * and replaces wildcard with resolved named.
+ */
+function* explodeReexports() {
+    const { babel } = this.services;
+    const { log, loadedAndParsed } = this.entrypoint;
+    if (loadedAndParsed.evaluator === 'ignored') {
+        return;
+    }
+    const reexportsFrom = getWildcardReexport(babel, loadedAndParsed.ast);
+    if (!reexportsFrom.length) {
+        return;
+    }
+    log('has wildcard reexport from %o', reexportsFrom);
+    const resolvedImports = yield* this.getNext('resolveImports', this.entrypoint, {
+        imports: new Map(reexportsFrom.map((i) => [i.source, []])),
+    });
+    const importedEntrypoints = (0, getExports_1.findExportsInImports)(this.entrypoint, resolvedImports);
+    const replacements = new Map();
+    for (const importedEntrypoint of importedEntrypoints) {
+        const exports = yield* this.getNext('getExports', importedEntrypoint.entrypoint, undefined);
+        const reexport = reexportsFrom.find((i) => i.source === importedEntrypoint.import);
+        if (reexport) {
+            replacements.set(reexport.node, exports.length
+                ? babel.types.exportNamedDeclaration(null, exports.map((i) => babel.types.exportSpecifier(babel.types.identifier(i), babel.types.identifier(i))), babel.types.stringLiteral(importedEntrypoint.import))
+                : null);
+        }
+    }
+    // Replace wildcard reexport with named reexports
+    babel.traverse(loadedAndParsed.ast, {
+        ExportAllDeclaration(path) {
+            const replacement = replacements.get(path.node);
+            if (replacement) {
+                path.replaceWith(replacement);
+            }
+            else {
+                path.remove();
+            }
+        },
+    });
+    loadedAndParsed.code = (0, generator_1.default)(loadedAndParsed.ast).code;
+}
+exports.explodeReexports = explodeReexports;

package/types/transform/generators/extract.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import path from 'path';
+import type { IExtractAction, SyncScenarioForAction } from '../types';
+export declare function transformUrl(url: string, outputFilename: string, sourceFilename: string, platformPath?: typeof path): string;
+/**
+ * Extract artifacts (e.g. CSS) from processors
+ */
+export declare function extract(this: IExtractAction): SyncScenarioForAction<IExtractAction>;

package/types/transform/generators/extract.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extract = exports.transformUrl = void 0;
+const path_1 = __importDefault(require("path"));
+const source_map_1 = require("source-map");
+const stylis_1 = __importDefault(require("stylis"));
+const STYLIS_DECLARATION = 1;
+const posixSep = path_1.default.posix.sep;
+function transformUrl(url, outputFilename, sourceFilename, platformPath = path_1.default) {
+    // Replace asset path with new path relative to the output CSS
+    const relative = platformPath.relative(platformPath.dirname(outputFilename), 
+    // Get the absolute path to the asset from the path relative to the JS file
+    platformPath.resolve(platformPath.dirname(sourceFilename), url));
+    if (platformPath.sep === posixSep) {
+        return relative;
+    }
+    return relative.split(platformPath.sep).join(posixSep);
+}
+exports.transformUrl = transformUrl;
+function extractCssFromAst(rules, originalCode, options) {
+    const mappings = [];
+    let cssText = '';
+    let preprocessor;
+    if (typeof options.preprocessor === 'function') {
+        // eslint-disable-next-line prefer-destructuring
+        preprocessor = options.preprocessor;
+    }
+    else {
+        switch (options.preprocessor) {
+            case 'none':
+                preprocessor = (selector, text) => `${selector} {${text}}\n`;
+                break;
+            case 'stylis':
+            default:
+                stylis_1.default.use(null)((context, decl) => {
+                    const { outputFilename } = options;
+                    if (context === STYLIS_DECLARATION && outputFilename) {
+                        // When writing to a file, we need to adjust the relative paths inside url(..) expressions
+                        // It'll allow css-loader to resolve an imported asset properly
+                        return decl.replace(/\b(url\((["']?))(\.[^)]+?)(\2\))/g, (match, p1, p2, p3, p4) => p1 + transformUrl(p3, outputFilename, options.filename) + p4);
+                    }
+                    return decl;
+                });
+                preprocessor = stylis_1.default;
+        }
+    }
+    Object.keys(rules).forEach((selector, index) => {
+        mappings.push({
+            generated: {
+                line: index + 1,
+                column: 0,
+            },
+            original: rules[selector].start,
+            name: selector,
+            source: '',
+        });
+        if (rules[selector].atom) {
+            // For atoms, we just directly insert cssText, to give the atomizer full control over the rules
+            cssText += `${rules[selector].cssText}\n`;
+        }
+        else {
+            // Run each rule through stylis to support nesting
+            cssText += `${preprocessor(selector, rules[selector].cssText)}\n`;
+        }
+    });
+    return {
+        cssText,
+        rules,
+        get cssSourceMapText() {
+            if (mappings?.length) {
+                const generator = new source_map_1.SourceMapGenerator({
+                    file: options.filename.replace(/\.js$/, '.css'),
+                });
+                mappings.forEach((mapping) => generator.addMapping({ ...mapping, source: options.filename }));
+                generator.setSourceContent(options.filename, originalCode);
+                return generator.toString();
+            }
+            return '';
+        },
+    };
+}
+/**
+ * Extract artifacts (e.g. CSS) from processors
+ */
+// eslint-disable-next-line require-yield
+function* extract() {
+    const { options } = this.services;
+    const { entrypoint } = this;
+    const { processors } = this.data;
+    const { loadedAndParsed } = entrypoint;
+    if (loadedAndParsed.evaluator === 'ignored') {
+        throw new Error('entrypoint was ignored');
+    }
+    let allRules = {};
+    const allReplacements = [];
+    processors.forEach((processor) => {
+        processor.artifacts.forEach((artifact) => {
+            if (artifact[0] !== 'css')
+                return;
+            const [rules, replacements] = artifact[1];
+            allRules = {
+                ...allRules,
+                ...rules,
+            };
+            allReplacements.push(...replacements);
+        });
+    });
+    return {
+        ...extractCssFromAst(allRules, loadedAndParsed.code, options),
+        replacements: allReplacements,
+    };
+}
+exports.extract = extract;

package/types/transform/generators/getExports.d.ts

@@ -0,0 +1,8 @@
+import type { Entrypoint } from '../Entrypoint';
+import type { IEntrypointDependency } from '../Entrypoint.types';
+import type { IGetExportsAction, SyncScenarioForAction } from '../types';
+export declare function findExportsInImports(entrypoint: Entrypoint, imports: IEntrypointDependency[]): {
+    entrypoint: Entrypoint;
+    import: string;
+}[];
+export declare function getExports(this: IGetExportsAction): SyncScenarioForAction<IGetExportsAction>;

package/types/transform/generators/getExports.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExports = exports.findExportsInImports = void 0;
+const collectExportsAndImports_1 = require("../../utils/collectExportsAndImports");
+function findExportsInImports(entrypoint, imports) {
+    const results = [];
+    for (const imp of imports) {
+        const { resolved } = imp;
+        if (!resolved) {
+            throw new Error(`Could not resolve import ${imp.source}`);
+        }
+        const newEntrypoint = entrypoint.createChild(resolved, []);
+        if (newEntrypoint === 'loop') {
+            // eslint-disable-next-line no-continue
+            continue;
+        }
+        results.push({
+            entrypoint: newEntrypoint,
+            import: imp.source,
+        });
+    }
+    return results;
+}
+exports.findExportsInImports = findExportsInImports;
+function* getExports() {
+    const { entrypoint, services: { cache }, } = this;
+    const { loadedAndParsed } = entrypoint;
+    if (loadedAndParsed.ast === undefined) {
+        return [];
+    }
+    entrypoint.log(`get exports from %s`, entrypoint.name);
+    if (cache.has('exports', entrypoint.name)) {
+        return cache.get('exports', entrypoint.name);
+    }
+    let withWildcardReexport = [];
+    const result = [];
+    this.services.babel.traverse(loadedAndParsed.ast, {
+        Program(path) {
+            const { exports, reexports } = (0, collectExportsAndImports_1.collectExportsAndImports)(path, 'disabled');
+            Object.keys(exports).forEach((token) => {
+                result.push(token);
+            });
+            reexports.forEach((e) => {
+                if (e.exported !== '*') {
+                    result.push(e.exported);
+                }
+            });
+            withWildcardReexport = reexports.filter((e) => e.exported === '*');
+        },
+    });
+    if (withWildcardReexport.length) {
+        const resolvedImports = yield* this.getNext('resolveImports', entrypoint, {
+            imports: new Map(withWildcardReexport.map((i) => [i.source, []])),
+        });
+        const importedEntrypoints = findExportsInImports(entrypoint, resolvedImports);
+        for (const importedEntrypoint of importedEntrypoints) {
+            const exports = yield* this.getNext('getExports', importedEntrypoint.entrypoint, undefined);
+            result.push(...exports);
+        }
+    }
+    entrypoint.log(`exports: %o`, result);
+    cache.add('exports', entrypoint.name, result);
+    return result;
+}
+exports.getExports = getExports;

package/types/transform/generators/index.d.ts

@@ -0,0 +1,15 @@
+import { collect } from './collect';
+import { evalFile } from './evalFile';
+import { extract } from './extract';
+import { workflow } from './workflow';
+export declare const baseHandlers: {
+    collect: typeof collect;
+    evalFile: typeof evalFile;
+    extract: typeof extract;
+    workflow: typeof workflow;
+    explodeReexports: typeof import("./explodeReexports").explodeReexports;
+    getExports: typeof import("./getExports").getExports;
+    processEntrypoint: typeof import("./processEntrypoint").processEntrypoint;
+    processImports: typeof import("./processImports").processImports;
+    transform: typeof import("./transform").transform;
+};

package/types/transform/generators/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseHandlers = void 0;
+const baseProcessingHandlers_1 = require("./baseProcessingHandlers");
+const collect_1 = require("./collect");
+const evalFile_1 = require("./evalFile");
+const extract_1 = require("./extract");
+const workflow_1 = require("./workflow");
+exports.baseHandlers = {
+    ...baseProcessingHandlers_1.baseProcessingHandlers,
+    collect: collect_1.collect,
+    evalFile: evalFile_1.evalFile,
+    extract: extract_1.extract,
+    workflow: workflow_1.workflow,
+};

package/types/transform/generators/processEntrypoint.d.ts

@@ -0,0 +1,9 @@
+import type { IProcessEntrypointAction, SyncScenarioForAction } from '../types';
+/**
+ * The first stage of processing an entrypoint.
+ * This stage is responsible for:
+ * - scheduling the explodeReexports action
+ * - scheduling the transform action
+ * - rescheduling itself if the entrypoint is superseded
+ */
+export declare function processEntrypoint(this: IProcessEntrypointAction): SyncScenarioForAction<IProcessEntrypointAction>;

package/types/transform/generators/processEntrypoint.js

@@ -0,0 +1,88 @@
+"use strict";
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        function next() {
+            while (env.stack.length) {
+                var rec = env.stack.pop();
+                try {
+                    var result = rec.dispose && rec.dispose.call(rec.value);
+                    if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processEntrypoint = void 0;
+const AbortError_1 = require("../actions/AbortError");
+/**
+ * The first stage of processing an entrypoint.
+ * This stage is responsible for:
+ * - scheduling the explodeReexports action
+ * - scheduling the transform action
+ * - rescheduling itself if the entrypoint is superseded
+ */
+function* processEntrypoint() {
+    const { only, log } = this.entrypoint;
+    log('start processing (only: %o)', only);
+    try {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const abortSignal = __addDisposableResource(env_1, this.createAbortSignal(), false);
+            yield ['explodeReexports', this.entrypoint, undefined, abortSignal];
+            const result = yield* this.getNext('transform', this.entrypoint, undefined, abortSignal);
+            this.entrypoint.assertNotSuperseded();
+            this.entrypoint.setTransformResult(result);
+            log('entrypoint processing finished');
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
+        }
+    }
+    catch (e) {
+        if ((0, AbortError_1.isAborted)(e) && this.entrypoint.supersededWith) {
+            log('processing aborted, schedule the next attempt');
+            yield* this.getNext('processEntrypoint', this.entrypoint.supersededWith, undefined, null);
+            return;
+        }
+        log(`Unhandled error: %O`, e);
+        throw e;
+    }
+}
+exports.processEntrypoint = processEntrypoint;

package/types/transform/generators/processImports.d.ts

@@ -0,0 +1,5 @@
+import type { IProcessImportsAction, SyncScenarioForAction } from '../types';
+/**
+ * Creates new entrypoints and emits processEntrypoint for each resolved import
+ */
+export declare function processImports(this: IProcessImportsAction): SyncScenarioForAction<IProcessImportsAction>;

package/types/transform/generators/processImports.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processImports = void 0;
+/**
+ * Creates new entrypoints and emits processEntrypoint for each resolved import
+ */
+function* processImports() {
+    for (const dependency of this.data.resolved) {
+        const { resolved, only } = dependency;
+        if (!resolved) {
+            continue;
+        }
+        this.entrypoint.addDependency(dependency);
+        const nextEntrypoint = this.entrypoint.createChild(resolved, only);
+        if (nextEntrypoint === 'loop' || nextEntrypoint.ignored) {
+            continue;
+        }
+        yield* this.getNext('processEntrypoint', nextEntrypoint, undefined, null);
+    }
+}
+exports.processImports = processImports;

package/types/transform/generators/resolveImports.d.ts

@@ -0,0 +1,9 @@
+import type { AsyncScenarioForAction, IResolveImportsAction, SyncScenarioForAction } from '../types';
+/**
+ * Synchronously resolves specified imports with a provided resolver.
+ */
+export declare function syncResolveImports(this: IResolveImportsAction, resolve: (what: string, importer: string, stack: string[]) => string): SyncScenarioForAction<IResolveImportsAction>;
+/**
+ * Asynchronously resolves specified imports with a provided resolver.
+ */
+export declare function asyncResolveImports(this: IResolveImportsAction, resolve: (what: string, importer: string, stack: string[]) => Promise<string | null>): AsyncScenarioForAction<IResolveImportsAction>;