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

package/types/transform/generators/resolveStaticOxcValues/processorStaticModel.js

@@ -0,0 +1,516 @@
+/* eslint-disable no-restricted-syntax,no-continue,@typescript-eslint/no-use-before-define */
+import { collectOxcProcessorImportsFromProgram } from '../../../utils/collectOxcExportsAndImports';
+import { getOxcNodeChildren } from '../../../utils/oxc/ast';
+import { getProcessorForImport } from '../../../utils/processorLookup';
+import { resolveProcessorStaticClassName } from '../../../utils/processorStaticSemantics';
+import { parseProgram } from './environment';
+import { findObjectPropertyValue, findTopLevelConstExpression, objectPropertyKeyName, } from './programAnalysis';
+import { isSafeLiteral, unwrapExpression } from './staticExpression';
+import { GENERATED_HELPER_NAME_RE } from './types';
+export const collectProcessorImportLocals = (action, program, code, filename) => {
+    const result = new Set();
+    collectOxcProcessorImportsFromProgram(program, code).forEach((item) => {
+        if (item.type !== 'esm' ||
+            item.imported === '*' ||
+            item.imported === 'side-effect') {
+            return;
+        }
+        const localName = item.local.name ?? item.local.code;
+        if (!localName) {
+            return;
+        }
+        const [processor] = getProcessorForImport({
+            imported: item.imported,
+            source: item.source,
+        }, filename, action.services.options.pluginOptions);
+        if (!processor) {
+            return;
+        }
+        result.add(localName);
+        const rootLocalName = localName.split('.')[0];
+        if (rootLocalName) {
+            result.add(rootLocalName);
+        }
+    });
+    return result;
+};
+export const isStaticWYWMetaValue = (value, seen = new Set()) => {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    if (seen.has(value)) {
+        return false;
+    }
+    seen.add(value);
+    const meta = value.__wyw_meta;
+    if (typeof meta !== 'object' || meta === null) {
+        return false;
+    }
+    const { className, extends: extended } = meta;
+    return (typeof className === 'string' &&
+        (extended === null || isStaticWYWMetaValue(extended, seen)));
+};
+export const toStaticWYWSelectorMetaValue = (value, seen = new Set()) => {
+    if (typeof value !== 'object' || value === null || seen.has(value)) {
+        return null;
+    }
+    seen.add(value);
+    const meta = value.__wyw_meta;
+    if (typeof meta !== 'object' || meta === null) {
+        return null;
+    }
+    const { className, extends: extended } = meta;
+    if (typeof className !== 'string') {
+        return null;
+    }
+    const staticExtends = extended === null ? null : toStaticWYWSelectorMetaValue(extended, seen);
+    if (extended !== null && staticExtends === null) {
+        return null;
+    }
+    return {
+        __wyw_meta: {
+            className,
+            extends: staticExtends,
+        },
+    };
+};
+export const staticWYWMetaExtendsReplacementCode = (value) => {
+    if (value === null) {
+        return 'null';
+    }
+    const selectorMeta = toStaticWYWSelectorMetaValue(value);
+    return selectorMeta ? `(${JSON.stringify(selectorMeta)})` : null;
+};
+export const unknownStaticWYWMetaValue = Symbol('unknownStaticWYWMetaValue');
+export const zeroArgFunctionExpressionBody = (expr) => {
+    const unwrapped = unwrapExpression(expr);
+    if (unwrapped.type !== 'ArrowFunctionExpression' ||
+        !Array.isArray(unwrapped.params) ||
+        unwrapped.params.length !== 0) {
+        return null;
+    }
+    const body = unwrapped.body;
+    return body && body.type !== 'BlockStatement' ? body : null;
+};
+export const isNullLiteralExpression = (node) => {
+    const unwrapped = unwrapExpression(node);
+    return isSafeLiteral(unwrapped) && unwrapped.value === null;
+};
+export const isNullReturningFunctionExpression = (expr) => {
+    const unwrapped = unwrapExpression(expr);
+    if (unwrapped.type !== 'ArrowFunctionExpression' &&
+        unwrapped.type !== 'FunctionExpression') {
+        return false;
+    }
+    if (unwrapped.async || unwrapped.generator) {
+        return false;
+    }
+    const body = unwrapped.body;
+    if (!body) {
+        return false;
+    }
+    if (body.type !== 'BlockStatement') {
+        return isNullLiteralExpression(body);
+    }
+    if (!Array.isArray(body.body) || body.body.length !== 1) {
+        return false;
+    }
+    const [statement] = body.body;
+    return (statement?.type === 'ReturnStatement' &&
+        !!statement.argument &&
+        isNullLiteralExpression(statement.argument));
+};
+export const createSameFileStaticWYWMetaHelperResolver = (code, filename) => {
+    const declarations = new Map();
+    const nullFunctionNames = new Set();
+    try {
+        const program = parseProgram(code, filename);
+        const collectDeclarations = (statement) => {
+            if (statement.type === 'VariableDeclaration') {
+                statement.declarations.forEach((declarator) => {
+                    if (declarator.id.type !== 'Identifier' || !declarator.init) {
+                        return;
+                    }
+                    const { name } = declarator.id;
+                    const init = declarator.init;
+                    if (isNullReturningFunctionExpression(init)) {
+                        nullFunctionNames.add(name);
+                        return;
+                    }
+                    const unwrapped = unwrapExpression(init);
+                    if (unwrapped.type === 'ObjectExpression' &&
+                        findObjectPropertyValue(unwrapped, '__wyw_meta')) {
+                        declarations.set(name, init);
+                        return;
+                    }
+                    const body = zeroArgFunctionExpressionBody(init);
+                    if (body && GENERATED_HELPER_NAME_RE.test(name)) {
+                        declarations.set(name, body);
+                    }
+                });
+            }
+        };
+        program.body.forEach((statement) => {
+            if (statement.type === 'ExportNamedDeclaration' &&
+                statement.declaration) {
+                collectDeclarations(statement.declaration);
+                return;
+            }
+            collectDeclarations(statement);
+        });
+    }
+    catch {
+        return () => new Map();
+    }
+    return (seedValues) => {
+        const memo = new Map();
+        const resolving = new Set();
+        const resolveName = (name) => {
+            if (seedValues.has(name)) {
+                return seedValues.get(name);
+            }
+            if (memo.has(name)) {
+                return memo.get(name);
+            }
+            const expression = declarations.get(name);
+            if (!expression || resolving.has(name)) {
+                if (nullFunctionNames.has(name)) {
+                    memo.set(name, null);
+                    return null;
+                }
+                return unknownStaticWYWMetaValue;
+            }
+            resolving.add(name);
+            const value = resolveExpression(expression);
+            resolving.delete(name);
+            memo.set(name, value);
+            return value;
+        };
+        const resolveExpression = (expression) => {
+            const unwrapped = unwrapExpression(expression);
+            if (isSafeLiteral(unwrapped)) {
+                return unwrapped.value;
+            }
+            if (unwrapped.type === 'Identifier') {
+                return resolveName(unwrapped.name);
+            }
+            if (unwrapped.type === 'CallExpression') {
+                const callee = unwrapExpression(unwrapped.callee);
+                if (callee.type === 'Identifier' && unwrapped.arguments.length === 0) {
+                    return resolveName(callee.name);
+                }
+                return unknownStaticWYWMetaValue;
+            }
+            if (unwrapped.type !== 'ObjectExpression') {
+                return unknownStaticWYWMetaValue;
+            }
+            const value = {};
+            for (const property of unwrapped.properties) {
+                if (property.type === 'SpreadElement') {
+                    return unknownStaticWYWMetaValue;
+                }
+                const propertyNode = property;
+                if (propertyNode.computed) {
+                    return unknownStaticWYWMetaValue;
+                }
+                const propertyKey = propertyNode.key;
+                const key = propertyKey ? objectPropertyKeyName(propertyKey) : null;
+                const propertyValue = propertyNode.value;
+                if (key === null || !propertyValue) {
+                    return unknownStaticWYWMetaValue;
+                }
+                const resolved = resolveExpression(propertyValue);
+                if (resolved === unknownStaticWYWMetaValue) {
+                    return unknownStaticWYWMetaValue;
+                }
+                value[key] = resolved;
+            }
+            return value;
+        };
+        const result = new Map();
+        declarations.forEach((_expression, name) => {
+            if (!GENERATED_HELPER_NAME_RE.test(name)) {
+                return;
+            }
+            const value = resolveName(name);
+            if (value !== unknownStaticWYWMetaValue &&
+                (value === null || isStaticWYWMetaValue(value))) {
+                result.set(name, value);
+            }
+        });
+        return result;
+    };
+};
+export const staticWYWMetaTreeValueStatus = (value, seen = new Set()) => {
+    if (value === null ||
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean') {
+        return {
+            hasMetadata: false,
+            safe: true,
+        };
+    }
+    if (typeof value !== 'object') {
+        return {
+            hasMetadata: false,
+            safe: false,
+        };
+    }
+    if (seen.has(value)) {
+        return {
+            hasMetadata: false,
+            safe: false,
+        };
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+        let hasMetadata = false;
+        for (const item of value) {
+            const status = staticWYWMetaTreeValueStatus(item, seen);
+            if (!status.safe) {
+                return {
+                    hasMetadata: false,
+                    safe: false,
+                };
+            }
+            hasMetadata = hasMetadata || status.hasMetadata;
+        }
+        return {
+            hasMetadata,
+            safe: true,
+        };
+    }
+    if ('__wyw_meta' in value) {
+        return {
+            hasMetadata: isStaticWYWMetaValue(value),
+            safe: isStaticWYWMetaValue(value),
+        };
+    }
+    let hasMetadata = false;
+    for (const item of Object.values(value)) {
+        const status = staticWYWMetaTreeValueStatus(item, seen);
+        if (!status.safe) {
+            return {
+                hasMetadata: false,
+                safe: false,
+            };
+        }
+        hasMetadata = hasMetadata || status.hasMetadata;
+    }
+    return {
+        hasMetadata,
+        safe: true,
+    };
+};
+export const isStaticWYWMetaTreeValue = (value) => {
+    const status = staticWYWMetaTreeValueStatus(value);
+    return status.safe && status.hasMetadata;
+};
+export const processorClassNameRuntimeValue = (processor) => resolveProcessorStaticClassName(processor) ?? processor.className;
+export const isProcessorRuntimeClassName = (processor, value) => processor.className === value ||
+    resolveProcessorStaticClassName(processor) === value;
+export const isPlainObjectRecord = (value) => typeof value === 'object' &&
+    value !== null &&
+    !Array.isArray(value) &&
+    Object.getPrototypeOf(value) === Object.prototype;
+export const isStaticObjectAssignAliasValue = (value) => isStaticWYWMetaValue(value) || isStaticWYWMetaTreeValue(value);
+export const artifactCssText = (artifact) => {
+    if (!Array.isArray(artifact) || artifact[0] !== 'css') {
+        return null;
+    }
+    const payload = artifact[1];
+    if (Array.isArray(payload)) {
+        const [rules] = payload;
+        if (typeof rules === 'object' && rules !== null) {
+            return Object.values(rules)
+                .map((rule) => typeof rule === 'object' &&
+                rule !== null &&
+                'cssText' in rule &&
+                typeof rule.cssText === 'string'
+                ? rule.cssText
+                : '')
+                .join('');
+        }
+    }
+    if (typeof payload === 'object' &&
+        payload !== null &&
+        'cssText' in payload &&
+        typeof payload.cssText === 'string') {
+        return payload.cssText;
+    }
+    return null;
+};
+export const isEmptyProcessorClassName = (value, processors, cache) => {
+    if (cache.has(value)) {
+        return cache.get(value);
+    }
+    const processor = processors.find((item) => isProcessorRuntimeClassName(item, value));
+    if (!processor) {
+        cache.set(value, false);
+        return false;
+    }
+    if (processor.artifacts.length === 0) {
+        try {
+            processor.build(new Map());
+        }
+        catch {
+            cache.set(value, false);
+            return false;
+        }
+    }
+    const result = processor.artifacts.every((artifact) => {
+        const cssText = artifactCssText(artifact);
+        return cssText !== null && cssText.trim() === '';
+    });
+    cache.set(value, result);
+    return result;
+};
+export const isProcessorClassName = (value, processors, cache) => {
+    if (cache.has(value)) {
+        return cache.get(value);
+    }
+    const processor = processors.find((item) => isProcessorRuntimeClassName(item, value));
+    if (!processor) {
+        cache.set(value, false);
+        return false;
+    }
+    if (processor.artifacts.length === 0) {
+        try {
+            processor.build(new Map());
+        }
+        catch {
+            cache.set(value, false);
+            return false;
+        }
+    }
+    const result = processor.artifacts.every((artifact) => artifactCssText(artifact) !== null);
+    cache.set(value, result);
+    return result;
+};
+export const isKnownProcessorClassName = (value, processorClassNames) => processorClassNames.has(value);
+export const isSelectorOnlyProcessorValue = (value, processors, cache, seen = new Set()) => {
+    if (typeof value === 'string') {
+        return isEmptyProcessorClassName(value, processors, cache);
+    }
+    if (Array.isArray(value)) {
+        if (seen.has(value)) {
+            return false;
+        }
+        seen.add(value);
+        return value.every((item) => isSelectorOnlyProcessorValue(item, processors, cache, seen));
+    }
+    if (typeof value === 'object' && value !== null) {
+        if (seen.has(value)) {
+            return false;
+        }
+        seen.add(value);
+        return Object.values(value).every((item) => isSelectorOnlyProcessorValue(item, processors, cache, seen));
+    }
+    return false;
+};
+export const isProcessorClassValue = (value, processors, cache, seen = new Set()) => {
+    if (typeof value === 'string') {
+        return isProcessorClassName(value, processors, cache);
+    }
+    if (Array.isArray(value)) {
+        if (seen.has(value)) {
+            return false;
+        }
+        seen.add(value);
+        return value.every((item) => isProcessorClassValue(item, processors, cache, seen));
+    }
+    if (typeof value === 'object' && value !== null) {
+        if (seen.has(value)) {
+            return false;
+        }
+        seen.add(value);
+        return Object.values(value).every((item) => isProcessorClassValue(item, processors, cache, seen));
+    }
+    return false;
+};
+export const isKnownProcessorClassValue = (value, processorClassNames, seen = new Set()) => {
+    if (typeof value === 'string') {
+        return isKnownProcessorClassName(value, processorClassNames);
+    }
+    if (Array.isArray(value)) {
+        if (seen.has(value)) {
+            return false;
+        }
+        seen.add(value);
+        return value.every((item) => isKnownProcessorClassValue(item, processorClassNames, seen));
+    }
+    if (typeof value === 'object' && value !== null) {
+        if (seen.has(value)) {
+            return false;
+        }
+        seen.add(value);
+        return Object.values(value).every((item) => isKnownProcessorClassValue(item, processorClassNames, seen));
+    }
+    return false;
+};
+export const findWYWMetaExtendsExpression = (expr) => {
+    const meta = findObjectPropertyValue(expr, '__wyw_meta');
+    if (!meta) {
+        return null;
+    }
+    return findObjectPropertyValue(meta, 'extends');
+};
+export const collectWYWMetaExtendsExpressionsDeep = (program, expr) => {
+    const result = [];
+    const seenLocals = new Set();
+    const seenRanges = new Set();
+    const visit = (node, parent = null) => {
+        const parentRecord = parent;
+        if (parentRecord &&
+            parentRecord.type === 'Property' &&
+            parentRecord.key === node &&
+            !parentRecord.computed) {
+            return;
+        }
+        if (node.type === 'ObjectExpression') {
+            const extendsExpression = findWYWMetaExtendsExpression(node);
+            if (extendsExpression) {
+                const key = `${extendsExpression.start}:${extendsExpression.end}`;
+                if (!seenRanges.has(key)) {
+                    seenRanges.add(key);
+                    result.push(extendsExpression);
+                }
+            }
+        }
+        if (node.type === 'Identifier') {
+            const local = findTopLevelConstExpression(program, node.name);
+            if (local && !seenLocals.has(node.name)) {
+                seenLocals.add(node.name);
+                visit(local);
+            }
+            return;
+        }
+        getOxcNodeChildren(node).forEach((child) => visit(child, node));
+    };
+    visit(expr);
+    return result;
+};
+export const isStaticMetaObjectExpression = (expr) => {
+    const meta = findObjectPropertyValue(expr, '__wyw_meta');
+    return !!meta && findObjectPropertyValue(meta, 'className') !== null;
+};
+export const collectWYWMetaExtendsHelperNames = (program) => {
+    const result = new Set();
+    const visit = (node) => {
+        if (node.type === 'ObjectExpression') {
+            const extendsExpression = findWYWMetaExtendsExpression(node);
+            const unwrapped = extendsExpression
+                ? unwrapExpression(extendsExpression)
+                : null;
+            if (unwrapped?.type === 'CallExpression' &&
+                unwrapped.callee.type === 'Identifier' &&
+                unwrapped.arguments.length === 0) {
+                result.add(unwrapped.callee.name);
+            }
+        }
+        getOxcNodeChildren(node).forEach(visit);
+    };
+    visit(program);
+    return result;
+};

package/types/transform/generators/resolveStaticOxcValues/processorTarget.d.ts

@@ -0,0 +1,5 @@
+import type { Program } from 'oxc-parser';
+import type { ExportTarget, PreparedProcessorTarget } from './types';
+export declare const prepareProcessorTarget: (code: string, filename: string, program: Program, target: Extract<ExportTarget, {
+    kind: "expression";
+}>, exportedName: string, opaqueImportNames?: Set<string>) => PreparedProcessorTarget | null;

package/types/transform/generators/resolveStaticOxcValues/processorTarget.js

@@ -0,0 +1,62 @@
+/* eslint-disable no-restricted-syntax,no-continue,@typescript-eslint/no-use-before-define */
+import { applyOxcReplacements } from '../../../utils/oxc/replacements';
+import { parseProgram } from './environment';
+import { findExportTarget } from './exportTargets';
+import { collectWYWMetaExtendsExpressionsDeep } from './processorStaticModel';
+import { hasOnlySafeObjectAssignCallArgumentUses, resolveObjectAssignProcessorExpression, } from './objectAssign';
+import { isOpaqueRuntimeComponentExpression } from './opaqueRuntime';
+import { collectStaticExpressionDependencies } from './staticExpressionDependencies';
+export const prepareProcessorTarget = (code, filename, program, target, exportedName, opaqueImportNames = new Set()) => {
+    const ignoredMutableCallArgumentNames = target.localName &&
+        hasOnlySafeObjectAssignCallArgumentUses(program, target.localName)
+        ? new Set([target.localName])
+        : undefined;
+    const dependencyOptions = {
+        allowMetadataCalls: true,
+        ignoredMutableCallArgumentNames,
+    };
+    const expression = resolveObjectAssignProcessorExpression(program, target.expression);
+    const extendsExpressions = collectWYWMetaExtendsExpressionsDeep(program, expression);
+    const opaqueExtendsExpressions = extendsExpressions.filter((extendsExpression) => isOpaqueRuntimeComponentExpression(program, extendsExpression, opaqueImportNames));
+    if (opaqueExtendsExpressions.length > 0) {
+        const replacements = opaqueExtendsExpressions.map((extendsExpression) => ({
+            end: extendsExpression.end,
+            start: extendsExpression.start,
+            text: 'null',
+        }));
+        const evaluationCode = applyOxcReplacements(code, replacements);
+        const evaluationProgram = parseProgram(evaluationCode, filename);
+        const evaluationTarget = findExportTarget(evaluationProgram, exportedName);
+        if (!evaluationTarget || evaluationTarget.kind === 'import') {
+            return null;
+        }
+        const evaluationExpression = resolveObjectAssignProcessorExpression(evaluationProgram, evaluationTarget.expression);
+        const dependencies = collectStaticExpressionDependencies(evaluationProgram, {
+            ...evaluationTarget,
+            expression: evaluationExpression,
+        }, dependencyOptions);
+        return dependencies
+            ? {
+                dependencies,
+                evaluationCode,
+                evaluationSpan: {
+                    end: evaluationExpression.end,
+                    start: evaluationExpression.start,
+                },
+                expression: evaluationExpression,
+                opaqueRuntimeBase: true,
+            }
+            : null;
+    }
+    const dependencies = collectStaticExpressionDependencies(program, {
+        ...target,
+        expression,
+    }, dependencyOptions);
+    return dependencies
+        ? {
+            dependencies,
+            expression,
+            opaqueRuntimeBase: false,
+        }
+        : null;
+};

package/types/transform/generators/resolveStaticOxcValues/programAnalysis.d.ts

@@ -0,0 +1,11 @@
+import type { Expression, Node, Program } from 'oxc-parser';
+export declare const collectLocalConstExpressions: (program: Program) => Map<string, Expression>;
+export declare const objectPropertyKeyName: (node: Node) => string | null;
+export declare const findObjectPropertyValue: (expr: Node, name: string) => Expression | null;
+export declare const topLevelStatements: (program: Program) => Node[];
+export declare const findTopLevelConstExpression: (program: Program, name: string) => Expression | null;
+export declare const hasTopLevelBinding: (program: Program, name: string) => boolean;
+export declare const isTopLevelFunctionOrClass: (program: Program, name: string) => boolean;
+export declare const functionReturnExpression: (expr: Node, options?: {
+    allowParams?: boolean;
+}) => Expression | null;