@wyw-in-js/transform 0.1.0

package/types/transform.js

@@ -0,0 +1,121 @@
+"use strict";
+/**
+ * This file exposes transform function that:
+ * - parse the passed code to AST
+ * - transforms the AST using Linaria babel preset ('./babel/index.js) and additional config defined in Linaria config file or passed to bundler configuration.
+ * - runs generated CSS files through default of user-defined preprocessor
+ * - generates source maps for CSS files
+ * - return transformed code (without Linaria template literals), generated CSS, source maps and babel metadata from transform step.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transform = exports.transformSync = void 0;
+const shared_1 = require("@wyw-in-js/shared");
+const cache_1 = require("./cache");
+const Entrypoint_1 = require("./transform/Entrypoint");
+const actionRunner_1 = require("./transform/actions/actionRunner");
+const generators_1 = require("./transform/generators");
+const resolveImports_1 = require("./transform/generators/resolveImports");
+const loadLinariaOptions_1 = require("./transform/helpers/loadLinariaOptions");
+const withDefaultServices_1 = require("./transform/helpers/withDefaultServices");
+function transformSync(partialServices, originalCode, syncResolve, customHandlers = {}) {
+    const { options } = partialServices;
+    const pluginOptions = (0, loadLinariaOptions_1.loadLinariaOptions)(options.pluginOptions);
+    const services = (0, withDefaultServices_1.withDefaultServices)({
+        ...partialServices,
+        options: {
+            ...options,
+            pluginOptions,
+        },
+    });
+    if (!(0, shared_1.isFeatureEnabled)(pluginOptions.features, 'globalCache', options.filename)) {
+        // If global cache is disabled, we need to create a new cache for each file
+        services.cache = new cache_1.TransformCacheCollection();
+    }
+    const entrypoint = Entrypoint_1.Entrypoint.createRoot(services, options.filename, ['__linariaPreval'], originalCode);
+    if (entrypoint.ignored) {
+        return {
+            code: originalCode,
+            sourceMap: options.inputSourceMap,
+        };
+    }
+    const workflowAction = entrypoint.createAction('workflow', undefined);
+    try {
+        const result = (0, actionRunner_1.syncActionRunner)(workflowAction, {
+            ...generators_1.baseHandlers,
+            ...customHandlers,
+            resolveImports() {
+                return resolveImports_1.syncResolveImports.call(this, syncResolve);
+            },
+        });
+        entrypoint.log('%s is ready', entrypoint.name);
+        return result;
+    }
+    catch (err) {
+        entrypoint.log('Unhandled error %O', err);
+        if ((0, shared_1.isFeatureEnabled)(pluginOptions.features, 'softErrors', options.filename)) {
+            // eslint-disable-next-line no-console
+            console.error(`Error during transform of ${entrypoint.name}:`, err);
+            return {
+                code: originalCode,
+                sourceMap: options.inputSourceMap,
+            };
+        }
+        throw err;
+    }
+}
+exports.transformSync = transformSync;
+async function transform(partialServices, originalCode, asyncResolve, customHandlers = {}) {
+    const { options } = partialServices;
+    const pluginOptions = (0, loadLinariaOptions_1.loadLinariaOptions)(options.pluginOptions);
+    const services = (0, withDefaultServices_1.withDefaultServices)({
+        ...partialServices,
+        options: {
+            ...options,
+            pluginOptions,
+        },
+    });
+    if (!(0, shared_1.isFeatureEnabled)(pluginOptions.features, 'globalCache', options.filename)) {
+        // If global cache is disabled, we need to create a new cache for each file
+        services.cache = new cache_1.TransformCacheCollection();
+    }
+    /*
+     * This method can be run simultaneously for multiple files.
+     * A shared cache is accessible for all runs, but each run has its own queue
+     * to maintain the correct processing order. The cache stores the outcome
+     * of tree-shaking, and if the result is already stored in the cache
+     * but the "only" option has changed, the file will be re-processed using
+     * the combined "only" option.
+     */
+    const entrypoint = Entrypoint_1.Entrypoint.createRoot(services, options.filename, ['__linariaPreval'], originalCode);
+    if (entrypoint.ignored) {
+        return {
+            code: originalCode,
+            sourceMap: options.inputSourceMap,
+        };
+    }
+    const workflowAction = entrypoint.createAction('workflow', undefined);
+    try {
+        const result = await (0, actionRunner_1.asyncActionRunner)(workflowAction, {
+            ...generators_1.baseHandlers,
+            ...customHandlers,
+            resolveImports() {
+                return resolveImports_1.asyncResolveImports.call(this, asyncResolve);
+            },
+        });
+        entrypoint.log('%s is ready', entrypoint.name);
+        return result;
+    }
+    catch (err) {
+        entrypoint.log('Unhandled error %O', err);
+        if ((0, shared_1.isFeatureEnabled)(pluginOptions.features, 'softErrors', options.filename)) {
+            // eslint-disable-next-line no-console
+            console.error(`Error during transform of ${entrypoint.name}:`, err);
+            return {
+                code: originalCode,
+                sourceMap: options.inputSourceMap,
+            };
+        }
+        throw err;
+    }
+}
+exports.transform = transform;

package/types/types.d.ts

@@ -0,0 +1,72 @@
+/// <reference types="debug" />
+import type { BabelFile, PluginPass } from '@babel/core';
+import type { NodePath } from '@babel/traverse';
+import type { File, Program } from '@babel/types';
+import type { RawSourceMap } from 'source-map';
+import type { BaseProcessor } from '@wyw-in-js/processor-utils';
+import type { Debugger, Replacement, Rules, StrictOptions } from '@wyw-in-js/shared';
+import type { WYWTransformMetadata } from './utils/TransformMetadata';
+export type PluginOptions = StrictOptions & {
+    configFile?: string | false;
+    stage?: Stage;
+};
+export type ParentEntrypoint = {
+    evaluated: boolean;
+    log: Debugger;
+    name: string;
+    parents: ParentEntrypoint[];
+    seqId: number;
+};
+export type Dependencies = string[];
+export interface IPluginState extends PluginPass {
+    dependencies: Dependencies;
+    file: BabelFile & {
+        metadata: {
+            linaria?: WYWTransformMetadata;
+        };
+    };
+    processors: BaseProcessor[];
+}
+export interface ITransformFileResult {
+    code: string;
+    metadata: WYWTransformMetadata | null;
+}
+export type Stage = 'preeval' | 'collect';
+export type Result = {
+    code: string;
+    cssSourceMapText?: string;
+    cssText?: string;
+    dependencies?: string[];
+    replacements?: Replacement[];
+    rules?: Rules;
+    sourceMap?: RawSourceMap | null;
+};
+export type Options = {
+    filename: string;
+    inputSourceMap?: RawSourceMap;
+    outputFilename?: string;
+    pluginOptions?: Partial<PluginOptions>;
+    preprocessor?: Preprocessor;
+    root?: string;
+};
+export type PreprocessorFn = (selector: string, cssText: string) => string;
+export type Preprocessor = 'none' | 'stylis' | PreprocessorFn | void;
+export type MissedBabelCoreTypes = {
+    File: new (options: {
+        filename: string;
+    }, file: {
+        ast: File;
+        code: string;
+    }) => {
+        path: NodePath<Program>;
+    };
+};
+export type JSONValue = null | string | number | boolean | JSONObject | JSONArray;
+export interface JSONObject {
+    [x: string]: JSONValue;
+}
+export type JSONArray = Array<JSONValue>;
+export type Serializable = JSONValue;
+/**
+ * CSS-related types
+ */

package/types/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * CSS-related types
+ */

package/types/utils/EventEmitter.d.ts

@@ -0,0 +1,58 @@
+export type OnEvent = (labels: Record<string, unknown>, type: 'start' | 'finish' | 'single', event?: unknown) => void;
+export interface IActionCreated {
+    actionIdx: string;
+    actionType: string;
+    type: 'actionCreated';
+}
+export interface ICreatedEvent {
+    class: string;
+    evaluatedOnly: string[];
+    filename: string;
+    generation: number;
+    idx: string;
+    isExportsInherited: boolean;
+    only: string[];
+    parentId: number | null;
+    type: 'created';
+}
+export interface ISupersededEvent {
+    type: 'superseded';
+    with: number;
+}
+export interface ISetTransformResultEvent {
+    isNull: boolean;
+    type: 'setTransformResult';
+}
+export type EntrypointEvent = IActionCreated | ICreatedEvent | ISupersededEvent | ISetTransformResultEvent;
+export type OnEntrypointEvent = (idx: number, timestamp: number, event: EntrypointEvent) => void;
+export type OnActionStartArgs = [
+    phase: 'start',
+    timestamp: number,
+    type: string,
+    idx: string,
+    entrypointRef: string
+];
+export type OnActionFinishArgs = [
+    phase: 'finish' | 'fail',
+    timestamp: number,
+    id: number,
+    isAsync: boolean,
+    error?: unknown
+];
+export declare const isOnActionStartArgs: (args: OnActionStartArgs | OnActionFinishArgs) => args is OnActionStartArgs;
+export declare const isOnActionFinishArgs: (args: OnActionStartArgs | OnActionFinishArgs) => args is OnActionFinishArgs;
+export interface OnAction {
+    (...args: OnActionStartArgs): number;
+    (...args: OnActionFinishArgs): void;
+}
+export declare class EventEmitter {
+    protected onEvent: OnEvent;
+    protected onAction: OnAction;
+    protected onEntrypointEvent: OnEntrypointEvent;
+    static dummy: EventEmitter;
+    constructor(onEvent: OnEvent, onAction: OnAction, onEntrypointEvent: OnEntrypointEvent);
+    action<TRes>(actonType: string, idx: string, entrypointRef: string, fn: () => TRes): TRes;
+    entrypointEvent(sequenceId: number, event: EntrypointEvent): void;
+    perf<TRes>(method: string, fn: () => TRes): TRes;
+    single(labels: Record<string, unknown>): void;
+}

package/types/utils/EventEmitter.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventEmitter = exports.isOnActionFinishArgs = exports.isOnActionStartArgs = void 0;
+const isOnActionStartArgs = (args) => {
+    return args[0] === 'start';
+};
+exports.isOnActionStartArgs = isOnActionStartArgs;
+const isOnActionFinishArgs = (args) => {
+    return args[0] === 'finish' || args[0] === 'fail';
+};
+exports.isOnActionFinishArgs = isOnActionFinishArgs;
+class EventEmitter {
+    onEvent;
+    onAction;
+    onEntrypointEvent;
+    static dummy = new EventEmitter(() => { }, () => 0, () => { });
+    constructor(onEvent, onAction, onEntrypointEvent) {
+        this.onEvent = onEvent;
+        this.onAction = onAction;
+        this.onEntrypointEvent = onEntrypointEvent;
+    }
+    action(actonType, idx, entrypointRef, fn) {
+        const id = this.onAction('start', performance.now(), actonType, idx, entrypointRef);
+        try {
+            const result = fn();
+            if (result instanceof Promise) {
+                result.then(() => this.onAction('finish', performance.now(), id, true), (e) => this.onAction('fail', performance.now(), id, true, e));
+            }
+            else {
+                this.onAction('finish', performance.now(), id, false);
+            }
+            return result;
+        }
+        catch (e) {
+            this.onAction('fail', performance.now(), id, false, e);
+            throw e;
+        }
+    }
+    entrypointEvent(sequenceId, event) {
+        this.onEntrypointEvent(sequenceId, performance.now(), event);
+    }
+    perf(method, fn) {
+        const labels = { method };
+        this.onEvent(labels, 'start');
+        const result = fn();
+        if (result instanceof Promise) {
+            result.then(() => this.onEvent(labels, 'finish'), () => this.onEvent(labels, 'finish'));
+        }
+        else {
+            this.onEvent(labels, 'finish');
+        }
+        return result;
+    }
+    single(labels) {
+        this.onEvent({
+            ...labels,
+            datetime: new Date(),
+        }, 'single');
+    }
+}
+exports.EventEmitter = EventEmitter;

package/types/utils/ShakerMetadata.d.ts

@@ -0,0 +1,7 @@
+export interface IShakerMetadata {
+    imports: Map<string, string[]>;
+}
+export interface IMetadata {
+    linariaEvaluator: IShakerMetadata;
+}
+export declare const hasShakerMetadata: (metadata: object | undefined) => metadata is IMetadata;

package/types/utils/ShakerMetadata.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasShakerMetadata = void 0;
+const hasShakerMetadata = (metadata) => metadata !== undefined && 'linariaEvaluator' in metadata;
+exports.hasShakerMetadata = hasShakerMetadata;

package/types/utils/TransformMetadata.d.ts

@@ -0,0 +1,13 @@
+import type { Artifact, Replacement, Rules } from '@wyw-in-js/shared';
+export type WYWTransformMetadata = {
+    dependencies: string[];
+    processors: {
+        artifacts: Artifact[];
+    }[];
+    replacements: Replacement[];
+    rules: Rules;
+};
+export declare const withTransformMetadata: (value: unknown) => value is {
+    wywInJS: WYWTransformMetadata;
+};
+export declare const getTransformMetadata: (value: unknown) => WYWTransformMetadata | undefined;

package/types/utils/TransformMetadata.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTransformMetadata = exports.withTransformMetadata = void 0;
+const withTransformMetadata = (value) => typeof value === 'object' &&
+    value !== null &&
+    typeof value.wywInJS === 'object';
+exports.withTransformMetadata = withTransformMetadata;
+const getTransformMetadata = (value) => {
+    if ((0, exports.withTransformMetadata)(value) && value.wywInJS !== null) {
+        const metadata = value.wywInJS;
+        // eslint-disable-next-line no-param-reassign
+        delete value.wywInJS;
+        return metadata;
+    }
+    return undefined;
+};
+exports.getTransformMetadata = getTransformMetadata;

package/types/utils/addIdentifierToLinariaPreval.d.ts

@@ -0,0 +1,4 @@
+import type { NodePath, Scope } from '@babel/traverse';
+import type { ObjectExpression } from '@babel/types';
+export declare function getOrAddLinariaPreval(scope: Scope): NodePath<ObjectExpression>;
+export declare function addIdentifierToLinariaPreval(scope: Scope, name: string): void;

package/types/utils/addIdentifierToLinariaPreval.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addIdentifierToLinariaPreval = exports.getOrAddLinariaPreval = void 0;
+const createId_1 = require("./createId");
+const scopeHelpers_1 = require("./scopeHelpers");
+function getOrAddLinariaPreval(scope) {
+    const rootScope = scope.getProgramParent();
+    const programPath = rootScope.path;
+    let object = programPath.getData('__linariaPreval');
+    if (object) {
+        return object;
+    }
+    if (programPath.node.sourceType === 'script') {
+        // CJS exports.__linariaPreval = {};
+        const prevalExport = {
+            expression: {
+                type: 'AssignmentExpression',
+                operator: '=',
+                left: {
+                    computed: false,
+                    object: (0, createId_1.createId)('exports'),
+                    property: (0, createId_1.createId)('__linariaPreval'),
+                    type: 'MemberExpression',
+                },
+                right: {
+                    properties: [],
+                    type: 'ObjectExpression',
+                },
+            },
+            type: 'ExpressionStatement',
+        };
+        const [inserted] = programPath.pushContainer('body', [prevalExport]);
+        object = inserted.get('expression.right');
+    }
+    else {
+        // ESM export const __linariaPreval = {};
+        const prevalExport = {
+            declaration: {
+                declarations: [
+                    {
+                        id: (0, createId_1.createId)('__linariaPreval'),
+                        init: {
+                            properties: [],
+                            type: 'ObjectExpression',
+                        },
+                        type: 'VariableDeclarator',
+                    },
+                ],
+                kind: 'const',
+                type: 'VariableDeclaration',
+            },
+            specifiers: [],
+            type: 'ExportNamedDeclaration',
+        };
+        const [inserted] = programPath.pushContainer('body', [prevalExport]);
+        object = inserted.get('declaration.declarations.0.init');
+    }
+    programPath.setData('__linariaPreval', object);
+    return object;
+}
+exports.getOrAddLinariaPreval = getOrAddLinariaPreval;
+function addIdentifierToLinariaPreval(scope, name) {
+    const rootScope = scope.getProgramParent();
+    const object = getOrAddLinariaPreval(rootScope);
+    const newProperty = {
+        type: 'ObjectProperty',
+        key: (0, createId_1.createId)(name),
+        value: (0, createId_1.createId)(name),
+        computed: false,
+        shorthand: false,
+    };
+    const [inserted] = object.pushContainer('properties', [newProperty]);
+    (0, scopeHelpers_1.reference)(inserted.get('value'));
+}
+exports.addIdentifierToLinariaPreval = addIdentifierToLinariaPreval;

package/types/utils/collectExportsAndImports.d.ts

@@ -0,0 +1,31 @@
+import type { NodePath } from '@babel/traverse';
+import type { Identifier, MemberExpression, Program } from '@babel/types';
+export interface ISideEffectImport {
+    imported: 'side-effect';
+    local: NodePath;
+    source: string;
+}
+export interface IImport {
+    imported: string | 'default' | '*';
+    local: NodePath<Identifier | MemberExpression>;
+    source: string;
+    type: 'cjs' | 'dynamic' | 'esm';
+}
+export type Exports = Record<string | 'default' | '*', NodePath>;
+export interface IReexport {
+    exported: string | 'default' | '*';
+    imported: string | 'default' | '*';
+    local: NodePath;
+    source: string;
+}
+export interface IState {
+    deadExports: string[];
+    exportRefs: Map<string, NodePath<MemberExpression>[]>;
+    exports: Exports;
+    imports: (IImport | ISideEffectImport)[];
+    isEsModule: boolean;
+    reexports: IReexport[];
+}
+export declare const sideEffectImport: (item: IImport | ISideEffectImport) => item is ISideEffectImport;
+export declare const explicitImport: (item: IImport | ISideEffectImport) => item is IImport;
+export declare function collectExportsAndImports(path: NodePath<Program>, cacheMode?: 'disabled' | 'force' | 'enabled'): IState;