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

package/types/utils/collectTemplateDependencies.d.ts

@@ -1,17 +0,0 @@
-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 WYW 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

@@ -1,220 +0,0 @@
-"use strict";
-/* eslint @typescript-eslint/no-use-before-define: ["error", { "functions": false }] */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractExpression = extractExpression;
-exports.collectTemplateDependencies = collectTemplateDependencies;
-/**
- * This file is a visitor that checks TaggedTemplateExpressions and look for WYW template literals.
- * 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;
-    if (ex.isIdentifier()) {
-        const binding = ex.scope.getBinding(ex.node.name);
-        // Babel may "evaluate" a destructured binding to its source container
-        // object/array instead of the bound value, which changes template semantics.
-        if (binding?.path.isVariableDeclarator() &&
-            !binding.path.get('id').isIdentifier()) {
-            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%% = () => %%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 WYW 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;
-}
-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];
-}

package/types/utils/createId.d.ts

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

package/types/utils/createId.js

@@ -1,9 +0,0 @@
-"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/findIdentifiers.d.ts

@@ -1,6 +0,0 @@
-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

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.nonType = nonType;
-exports.findIdentifiers = findIdentifiers;
-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());
-}
-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;
-}

package/types/utils/getConstantStringValue.d.ts

@@ -1,2 +0,0 @@
-import type { Expression } from '@babel/types';
-export declare function getConstantStringValue(node: Expression): string | null;

package/types/utils/getConstantStringValue.js

@@ -1,94 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getConstantStringValue = getConstantStringValue;
-const t = __importStar(require("@babel/types"));
-const getMemberExpressionPropertyName_1 = require("./getMemberExpressionPropertyName");
-const unwrapExpression_1 = require("./unwrapExpression");
-function getConstantStringValue(node) {
-    const fromExpression = (value) => {
-        const expression = (0, unwrapExpression_1.unwrapExpression)(value);
-        if (t.isStringLiteral(expression)) {
-            return expression.value;
-        }
-        if (t.isTemplateLiteral(expression)) {
-            if (expression.expressions.length !== 0) {
-                return null;
-            }
-            const [quasi] = expression.quasis;
-            return quasi?.value.cooked ?? null;
-        }
-        if (t.isBinaryExpression(expression) && expression.operator === '+') {
-            if (!t.isExpression(expression.left) || !t.isExpression(expression.right))
-                return null;
-            const left = fromExpression(expression.left);
-            const right = fromExpression(expression.right);
-            if (left === null || right === null) {
-                return null;
-            }
-            return left + right;
-        }
-        if (t.isCallExpression(expression)) {
-            const concatProperty = t.isMemberExpression(expression.callee)
-                ? (0, getMemberExpressionPropertyName_1.getMemberExpressionPropertyName)(expression.callee)
-                : null;
-            if (concatProperty !== 'concat') {
-                return null;
-            }
-            const { callee } = expression;
-            if (!t.isMemberExpression(callee) || !t.isExpression(callee.object)) {
-                return null;
-            }
-            const base = fromExpression(callee.object);
-            if (base === null) {
-                return null;
-            }
-            const parts = [base];
-            for (const arg of expression.arguments) {
-                if (!t.isExpression(arg)) {
-                    return null;
-                }
-                const part = fromExpression(arg);
-                if (part === null) {
-                    return null;
-                }
-                parts.push(part);
-            }
-            return parts.join('');
-        }
-        return null;
-    };
-    return fromExpression(node);
-}

package/types/utils/getMemberExpressionPropertyName.d.ts

@@ -1,2 +0,0 @@
-import type { MemberExpression } from '@babel/types';
-export declare function getMemberExpressionPropertyName(node: MemberExpression): string | null;

package/types/utils/getMemberExpressionPropertyName.js

@@ -1,46 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMemberExpressionPropertyName = getMemberExpressionPropertyName;
-const t = __importStar(require("@babel/types"));
-function getMemberExpressionPropertyName(node) {
-    if (!node.computed && t.isIdentifier(node.property)) {
-        return node.property.name;
-    }
-    if (node.computed && t.isStringLiteral(node.property)) {
-        return node.property.value;
-    }
-    return null;
-}

package/types/utils/getScope.d.ts

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

package/types/utils/getScope.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getScope = getScope;
-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;
-}

package/types/utils/getSource.d.ts

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

package/types/utils/getSource.js

@@ -1,22 +0,0 @@
-"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

@@ -1,13 +0,0 @@
-import type { NodePath } from '@babel/traverse';
-import type { Program } from '@babel/types';
-import { BaseProcessor } from '@wyw-in-js/processor-utils';
-import type { IFileContext, TagSource } from '@wyw-in-js/processor-utils';
-import type { StrictOptions } from '@wyw-in-js/shared';
-import type { IImport } from './collectExportsAndImports';
-type DefinedProcessor = [ProcessorClass, TagSource];
-type DefinedProcessors = Map<string, DefinedProcessor>;
-export type ProcessorClass = new (...args: ConstructorParameters<typeof BaseProcessor>) => BaseProcessor;
-export declare function getProcessorForImport({ imported, source }: IImport, filename: string | null | undefined, options: Pick<StrictOptions, 'tagResolver'>): [ProcessorClass | null, TagSource];
-export declare function getDefinedProcessors(imports: IImport[], path: NodePath<Program>, filename: string | null | undefined, options: Pick<StrictOptions, 'tagResolver'>): DefinedProcessors;
-export declare function applyProcessors(path: NodePath<Program>, fileContext: IFileContext, options: Pick<StrictOptions, 'classNameSlug' | 'displayName' | 'extensions' | 'evaluate' | 'tagResolver'>, callback: (processor: BaseProcessor) => void): void;
-export {};