@wyw-in-js/transform 0.1.0

package/types/utils/collectTemplateDependencies.d.ts

@@ -0,0 +1,17 @@
+import type { NodePath } from '@babel/traverse';
+import type { Expression, TaggedTemplateExpression, TemplateElement } from '@babel/types';
+import type { ExpressionValue } from '@wyw-in-js/shared';
+import type { IImport } from './collectExportsAndImports';
+/**
+ * Only an expression that can be evaluated in the root scope can be
+ * used in a Linaria template. This function tries to hoist the expression.
+ * @param ex The expression to hoist.
+ * @param evaluate If true, we try to statically evaluate the expression.
+ * @param imports All the imports of the file.
+ */
+export declare function extractExpression(ex: NodePath<Expression>, evaluate?: boolean, imports?: IImport[]): Omit<ExpressionValue, 'buildCodeFrameError' | 'source'>;
+/**
+ * Collects, hoists, and makes lazy all expressions in the given template
+ * If evaluate is true, it will try to evaluate the expressions
+ */
+export declare function collectTemplateDependencies(path: NodePath<TaggedTemplateExpression>, evaluate?: boolean): [quasis: TemplateElement[], expressionValues: ExpressionValue[]];

package/types/utils/collectTemplateDependencies.js

@@ -0,0 +1,212 @@
+"use strict";
+/* eslint @typescript-eslint/no-use-before-define: ["error", { "functions": false }] */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectTemplateDependencies = exports.extractExpression = void 0;
+/**
+ * This file is a visitor that checks TaggedTemplateExpressions and look for Linaria css or styled templates.
+ * For each template it makes a list of dependencies, try to evaluate expressions, and if it is not possible, mark them as lazy dependencies.
+ */
+const template_1 = require("@babel/template");
+const types_1 = require("@babel/types");
+const shared_1 = require("@wyw-in-js/shared");
+const createId_1 = require("./createId");
+const findIdentifiers_1 = require("./findIdentifiers");
+const getSource_1 = require("./getSource");
+const scopeHelpers_1 = require("./scopeHelpers");
+const valueToLiteral_1 = require("./valueToLiteral");
+function staticEval(ex, evaluate = false) {
+    if (!evaluate)
+        return undefined;
+    const result = ex.evaluate();
+    if (result.confident && !(0, shared_1.hasEvalMeta)(result.value)) {
+        return [result.value];
+    }
+    return undefined;
+}
+const expressionDeclarationTpl = (0, template_1.statement)('const %%expId%% = /*#__PURE__*/ () => %%expression%%', {
+    preserveComments: true,
+});
+const unsupported = (ex, reason) => ex.buildCodeFrameError(`This ${ex.isIdentifier() ? 'identifier' : 'expression'} cannot be used in the template${reason ? `, because it ${reason}` : ''}.`);
+function getUidInRootScope(path) {
+    const { name } = path.node;
+    const rootScope = path.scope.getProgramParent();
+    if (rootScope.hasBinding(name)) {
+        return rootScope.generateUid(name);
+    }
+    return name;
+}
+function hoistVariableDeclarator(ex) {
+    if (!ex.scope.parent) {
+        // It is already in the root scope
+        return;
+    }
+    const referencedIdentifiers = (0, findIdentifiers_1.findIdentifiers)([ex], 'reference');
+    referencedIdentifiers.forEach((identifier) => {
+        if (identifier.isIdentifier()) {
+            hoistIdentifier(identifier);
+        }
+    });
+    const bindingIdentifiers = (0, findIdentifiers_1.findIdentifiers)([ex], 'declaration');
+    bindingIdentifiers.forEach((path) => {
+        const newName = getUidInRootScope(path);
+        if (newName !== path.node.name) {
+            path.scope.rename(path.node.name, newName);
+        }
+    });
+    const rootScope = ex.scope.getProgramParent();
+    const statementInRoot = ex.findParent((p) => p.parentPath?.isProgram() === true);
+    const declaration = {
+        type: 'VariableDeclaration',
+        kind: 'let',
+        declarations: [(0, types_1.cloneNode)(ex.node)],
+    };
+    const [inserted] = statementInRoot.insertBefore(declaration);
+    (0, scopeHelpers_1.referenceAll)(inserted);
+    rootScope.registerDeclaration(inserted);
+}
+function hoistIdentifier(idPath) {
+    if (!idPath.isReferenced()) {
+        throw unsupported(idPath);
+    }
+    const binding = idPath.scope.getBinding(idPath.node.name);
+    if (!binding) {
+        // It's something strange
+        throw unsupported(idPath, 'is undefined');
+    }
+    if (binding.kind === 'module') {
+        // Modules are global by default
+        return;
+    }
+    if (!['var', 'let', 'const', 'hoisted'].includes(binding.kind)) {
+        // This is not a variable, we can't hoist it
+        throw unsupported(binding.path, 'is a function parameter');
+    }
+    const { scope, path: bindingPath } = binding;
+    // parent here can be null or undefined in different versions of babel
+    if (!scope.parent) {
+        // The variable is already in the root scope
+        return;
+    }
+    if (bindingPath.isVariableDeclarator()) {
+        hoistVariableDeclarator(bindingPath);
+        return;
+    }
+    throw unsupported(idPath);
+}
+/**
+ * Only an expression that can be evaluated in the root scope can be
+ * used in a Linaria template. This function tries to hoist the expression.
+ * @param ex The expression to hoist.
+ * @param evaluate If true, we try to statically evaluate the expression.
+ * @param imports All the imports of the file.
+ */
+function extractExpression(ex, evaluate = false, imports = []) {
+    if (ex.isLiteral() &&
+        ('value' in ex.node || ex.node.type === 'NullLiteral')) {
+        return {
+            ex: ex.node,
+            kind: shared_1.ValueType.CONST,
+            value: ex.node.type === 'NullLiteral' ? null : ex.node.value,
+        };
+    }
+    const { loc } = ex.node;
+    const rootScope = ex.scope.getProgramParent();
+    const statementInRoot = ex.findParent((p) => p.parentPath?.isProgram() === true);
+    const isFunction = ex.isFunctionExpression() || ex.isArrowFunctionExpression();
+    // Generate next _expN name
+    const expUid = rootScope.generateUid('exp');
+    const evaluated = staticEval(ex, evaluate);
+    if (!evaluated) {
+        // If expression is not statically evaluable,
+        // we need to hoist all its referenced identifiers
+        // Collect all referenced identifiers
+        (0, findIdentifiers_1.findIdentifiers)([ex], 'reference').forEach((id) => {
+            if (!id.isIdentifier())
+                return;
+            // Try to evaluate and inline them…
+            const evaluatedId = staticEval(id, evaluate);
+            if (evaluatedId) {
+                (0, scopeHelpers_1.mutate)(id, (p) => {
+                    p.replaceWith((0, valueToLiteral_1.valueToLiteral)(evaluatedId[0], ex));
+                });
+            }
+            else {
+                // … or hoist them to the root scope
+                hoistIdentifier(id);
+            }
+        });
+    }
+    const kind = isFunction ? shared_1.ValueType.FUNCTION : shared_1.ValueType.LAZY;
+    // Declare _expN const with the lazy expression
+    const declaration = expressionDeclarationTpl({
+        expId: (0, createId_1.createId)(expUid),
+        expression: evaluated
+            ? (0, valueToLiteral_1.valueToLiteral)(evaluated[0], ex)
+            : (0, types_1.cloneNode)(ex.node),
+    });
+    // Insert the declaration as close as possible to the original expression
+    const [inserted] = statementInRoot.insertBefore(declaration);
+    (0, scopeHelpers_1.referenceAll)(inserted);
+    rootScope.registerDeclaration(inserted);
+    const importedFrom = [];
+    function findImportSourceOfIdentifier(idPath) {
+        const exBindingIdentifier = idPath.scope.getBinding(idPath.node.name)
+            ?.identifier;
+        const exImport = imports.find((i) => i.local.node === exBindingIdentifier) ?? null;
+        if (exImport) {
+            importedFrom.push(exImport.source);
+        }
+    }
+    if (ex.isIdentifier()) {
+        findImportSourceOfIdentifier(ex);
+    }
+    else {
+        ex.traverse({
+            Identifier: findImportSourceOfIdentifier,
+        });
+    }
+    // Replace the expression with the _expN() call
+    (0, scopeHelpers_1.mutate)(ex, (p) => {
+        p.replaceWith({
+            type: 'CallExpression',
+            callee: (0, createId_1.createId)(expUid),
+            arguments: [],
+        });
+    });
+    // eslint-disable-next-line no-param-reassign
+    ex.node.loc = loc;
+    // noinspection UnnecessaryLocalVariableJS
+    const result = {
+        kind,
+        ex: (0, createId_1.createId)(expUid, loc),
+        importedFrom,
+    };
+    return result;
+}
+exports.extractExpression = extractExpression;
+const debug = shared_1.logger.extend('template-parse:identify-expressions');
+/**
+ * Collects, hoists, and makes lazy all expressions in the given template
+ * If evaluate is true, it will try to evaluate the expressions
+ */
+function collectTemplateDependencies(path, evaluate = false) {
+    const quasi = path.get('quasi');
+    const quasis = quasi.get('quasis');
+    const expressions = quasi.get('expressions');
+    debug('Found: %s', expressions.length);
+    const expressionValues = expressions.map((ex) => {
+        const buildCodeFrameError = ex.buildCodeFrameError.bind(ex);
+        const source = (0, getSource_1.getSource)(ex);
+        if (!ex.isExpression()) {
+            throw buildCodeFrameError(`The expression '${source}' is not supported.`);
+        }
+        const extracted = extractExpression(ex, evaluate);
+        return {
+            ...extracted,
+            source,
+            buildCodeFrameError,
+        };
+    });
+    return [quasis.map((p) => p.node), expressionValues];
+}
+exports.collectTemplateDependencies = collectTemplateDependencies;

package/types/utils/createId.d.ts

@@ -0,0 +1,2 @@
+import type { Identifier, SourceLocation } from '@babel/types';
+export declare const createId: (name: string, loc?: SourceLocation | null) => Identifier;

package/types/utils/createId.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createId = void 0;
+const createId = (name, loc) => ({
+    type: 'Identifier',
+    name,
+    loc,
+});
+exports.createId = createId;

package/types/utils/dispose-polyfill.js

@@ -0,0 +1,5 @@
+"use strict";
+// @ts-expect-error
+Symbol.dispose ??= Symbol('Symbol.dispose');
+// @ts-expect-error
+Symbol.asyncDispose ??= Symbol('Symbol.asyncDispose');

package/types/utils/findIdentifiers.d.ts

@@ -0,0 +1,6 @@
+import type { NodePath } from '@babel/traverse';
+import type { Node, Identifier, JSXIdentifier } from '@babel/types';
+type FindType = 'any' | 'binding' | 'declaration' | 'reference';
+export declare function nonType(path: NodePath): boolean;
+export declare function findIdentifiers(expressions: NodePath<Node | null | undefined>[], type?: FindType): NodePath<Identifier | JSXIdentifier>[];
+export {};

package/types/utils/findIdentifiers.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findIdentifiers = exports.nonType = void 0;
+const getScope_1 = require("./getScope");
+function isInUnary(path) {
+    return path.parentPath?.isUnaryExpression() ?? false;
+}
+// It's possible for non-strict mode code to have variable deletions.
+function isInDelete(path) {
+    return path.parentPath.node.operator === 'delete';
+}
+function isBindingIdentifier(path) {
+    return path.isBindingIdentifier() && (!isInUnary(path) || isInDelete(path));
+}
+function isReferencedIdentifier(path) {
+    return (path.isReferencedIdentifier() || (isInUnary(path) && !isInDelete(path)));
+}
+// For some reasons, `isBindingIdentifier` returns true for identifiers inside unary expressions.
+const checkers = {
+    any: (ex) => isBindingIdentifier(ex) || isReferencedIdentifier(ex),
+    binding: (ex) => isBindingIdentifier(ex),
+    declaration: (ex) => isBindingIdentifier(ex) &&
+        ex.scope.getBinding(ex.node.name)?.identifier === ex.node,
+    reference: (ex) => isReferencedIdentifier(ex),
+};
+function nonType(path) {
+    return !path.find((p) => p.isTSTypeReference() ||
+        p.isTSTypeQuery() ||
+        p.isFlowType() ||
+        p.isFlowDeclaration() ||
+        p.isTSInterfaceDeclaration());
+}
+exports.nonType = nonType;
+function findIdentifiers(expressions, type = 'reference') {
+    const identifiers = [];
+    expressions.forEach((ex) => {
+        const emit = (path) => {
+            if (!path.node || path.removed || !checkers[type](path)) {
+                return;
+            }
+            // TODO: Is there a better way to check that it's a local variable?
+            const binding = (0, getScope_1.getScope)(path).getBinding(path.node.name);
+            if (!binding) {
+                return;
+            }
+            if (type === 'reference' && ex.isAncestor(binding.path)) {
+                // This identifier is declared inside the expression. We don't need it.
+                return;
+            }
+            identifiers.push(path);
+        };
+        if (ex.isIdentifier() || ex.isJSXIdentifier()) {
+            emit(ex);
+        }
+        else {
+            ex.traverse({
+                Identifier(path) {
+                    emit(path);
+                },
+                JSXIdentifier(path) {
+                    emit(path);
+                },
+            });
+        }
+    });
+    return identifiers;
+}
+exports.findIdentifiers = findIdentifiers;

package/types/utils/findPackageJSON.d.ts

@@ -0,0 +1 @@
+export declare function findPackageJSON(pkgName: string, filename: string | null | undefined): string | undefined;

package/types/utils/findPackageJSON.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findPackageJSON = void 0;
+const path_1 = require("path");
+const find_up_1 = __importDefault(require("find-up"));
+const cache = new Map();
+function findPackageJSON(pkgName, filename) {
+    try {
+        const pkgPath = pkgName === '.' && filename && (0, path_1.isAbsolute)(filename)
+            ? filename
+            : require.resolve(pkgName, filename ? { paths: [(0, path_1.dirname)(filename)] } : {});
+        if (!cache.has(pkgPath)) {
+            cache.set(pkgPath, find_up_1.default.sync('package.json', { cwd: pkgPath }));
+        }
+        return cache.get(pkgPath);
+    }
+    catch (er) {
+        if (typeof er === 'object' &&
+            er !== null &&
+            er.code === 'MODULE_NOT_FOUND') {
+            return undefined;
+        }
+        throw er;
+    }
+}
+exports.findPackageJSON = findPackageJSON;

package/types/utils/getFileIdx.d.ts

@@ -0,0 +1 @@
+export declare function getFileIdx(name: string): string;

package/types/utils/getFileIdx.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFileIdx = void 0;
+let nextIdx = 1;
+const processed = new Map();
+function getFileIdx(name) {
+    if (!processed.has(name)) {
+        // eslint-disable-next-line no-plusplus
+        processed.set(name, nextIdx++);
+    }
+    return processed.get(name).toString().padStart(5, '0');
+}
+exports.getFileIdx = getFileIdx;

package/types/utils/getPluginKey.d.ts

@@ -0,0 +1,2 @@
+import type { PluginItem } from '@babel/core';
+export declare const getPluginKey: (plugin: PluginItem) => string | null;

package/types/utils/getPluginKey.js

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

package/types/utils/getScope.d.ts

@@ -0,0 +1,2 @@
+import type { NodePath } from '@babel/traverse';
+export declare function getScope(path: NodePath): import("@babel/traverse").Scope;

package/types/utils/getScope.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getScope = void 0;
+function getScope(path) {
+    // In some nodes (like FunctionDeclaration) `scope` for `id` returns
+    // local function scope instead of a scope where function is declared.
+    return path.key === 'id' && path.parent === path.scope.block
+        ? path.scope.parent
+        : path.scope;
+}
+exports.getScope = getScope;

package/types/utils/getSource.d.ts

@@ -0,0 +1,2 @@
+import type { NodePath } from '@babel/traverse';
+export declare const getSource: (path: NodePath, force?: boolean) => string;

package/types/utils/getSource.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSource = void 0;
+const generator_1 = __importDefault(require("@babel/generator"));
+const getSource = (path, force = false) => {
+    if (path.isIdentifier()) {
+        // Fast-lane for identifiers
+        return path.node.name;
+    }
+    let source;
+    try {
+        source = force ? undefined : path.getSource();
+        // eslint-disable-next-line no-empty
+    }
+    catch { }
+    source = source || (0, generator_1.default)(path.node).code;
+    return path.node.extra?.parenthesized ? `(${source})` : source;
+};
+exports.getSource = getSource;

package/types/utils/getTagProcessor.d.ts

@@ -0,0 +1,6 @@
+import type { NodePath } from '@babel/traverse';
+import type { Identifier } from '@babel/types';
+import { BaseProcessor } from '@wyw-in-js/processor-utils';
+import type { IFileContext } from '@wyw-in-js/processor-utils';
+import type { StrictOptions } from '@wyw-in-js/shared';
+export declare function getTagProcessor(path: NodePath<Identifier>, fileContext: IFileContext, options: Pick<StrictOptions, 'classNameSlug' | 'displayName' | 'evaluate' | 'tagResolver'>): BaseProcessor | null;