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

package/types/utils/collectOxcTemplateDependencies/scopeAnalysis.d.ts

@@ -0,0 +1,20 @@
+import type { SourceLocation } from '@wyw-in-js/shared';
+import type { Node, Program } from 'oxc-parser';
+import type { Binding, ExpressionSpan, ExtractionContext, ProgramAnalysis, ReferenceIdentifier, SpanLookup } from './types';
+export declare const containsTaggedTemplateExpression: (node: Node) => boolean;
+export declare const parseOxc: (code: string, filename: string) => Program;
+export declare const createSpanLookup: (spans?: ExpressionSpan[]) => SpanLookup;
+export declare const getSourceLocation: (start: number, end: number, ctx: Pick<ExtractionContext, "filename" | "loc">) => SourceLocation;
+export declare const isInTypeContext: (ancestors: Node[]) => boolean;
+export declare const isPropertyOnlyIdentifier: (node: Node, parent: Node | null) => boolean;
+export declare const isObjectPropertyKey: (node: Node, parent: Node | null) => boolean;
+export declare const isBindingPosition: (node: Node, parent: Node | null) => boolean;
+export declare const analyzeProgram: (program: Program, { collectTargetExpressions, collectTemplateLiterals, expressionSpanLookup, templateSpanLookup, }?: {
+    collectTargetExpressions?: boolean;
+    collectTemplateLiterals?: boolean;
+    expressionSpanLookup?: SpanLookup;
+    templateSpanLookup?: SpanLookup;
+}) => ProgramAnalysis;
+export declare const resolveBindingAt: (ctx: Pick<ExtractionContext, "bindingResolutionCache" | "bindingsByName">, name: string, referenceStart: number) => Binding | undefined;
+export declare const findReferences: (node: Node, referenceCache?: WeakMap<Node, ReferenceIdentifier[]>) => ReferenceIdentifier[];
+export declare const isBindingDeclaredWithin: (binding: Binding, container: Node) => boolean;

package/types/utils/collectOxcTemplateDependencies/scopeAnalysis.js

@@ -0,0 +1,434 @@
+/* eslint-disable no-restricted-syntax,no-continue,@typescript-eslint/no-use-before-define */
+import { getOxcNodeChildren } from '../oxc/ast';
+import { parseOxcProgram } from '../oxc/parse';
+import { createOxcSourceLocation } from '../oxc/sourceLocations';
+export const containsTaggedTemplateExpression = (node) => {
+    if (node.type === 'TaggedTemplateExpression') {
+        return true;
+    }
+    return getOxcNodeChildren(node).some(containsTaggedTemplateExpression);
+};
+export const parseOxc = (code, filename) => {
+    return parseOxcProgram(code, filename, 'unambiguous');
+};
+const toSpanKey = (start, end) => `${start}:${end}`;
+export const createSpanLookup = (spans) => {
+    if (!spans || spans.length === 0) {
+        return null;
+    }
+    return new Set(spans.map((span) => toSpanKey(span.start, span.end)));
+};
+const matchesSpanLookup = (node, spanLookup) => !spanLookup || spanLookup.has(toSpanKey(node.start, node.end));
+export const getSourceLocation = (start, end, ctx) => createOxcSourceLocation(start, end, ctx.loc, ctx.filename);
+const createScope = (parent, node, root = false, functionBoundary = false) => ({
+    bindings: new Map(),
+    depth: parent ? parent.depth + 1 : 0,
+    end: node.end,
+    functionBoundary,
+    params: new Set(),
+    parent,
+    root,
+    start: node.start,
+});
+const normalizeDeclarationKind = (declarationKind) => {
+    if (declarationKind === 'var') {
+        return 'var';
+    }
+    if (declarationKind === 'let') {
+        return 'let';
+    }
+    return 'const';
+};
+const moduleExportName = (node) => node.type === 'Literal' ? String(node.value) : node.name;
+const getImportSpecifierInfo = (statement, specifier) => {
+    const local = specifier.local?.name;
+    if (!local) {
+        return null;
+    }
+    if (specifier.type === 'ImportDefaultSpecifier') {
+        return {
+            imported: 'default',
+            local,
+        };
+    }
+    if (specifier.type === 'ImportNamespaceSpecifier') {
+        return {
+            imported: '*',
+            local,
+        };
+    }
+    if (statement.importKind === 'type' ||
+        specifier.importKind === 'type') {
+        return null;
+    }
+    return {
+        imported: moduleExportName(specifier.imported),
+        local,
+    };
+};
+const getDeclarationScope = (scope, declarationKind) => {
+    if (declarationKind !== 'var') {
+        return scope;
+    }
+    let current = scope;
+    while (current && !current.functionBoundary) {
+        current = current.parent;
+    }
+    return current ?? scope;
+};
+const collectBindingNames = (node) => {
+    if (node.type === 'Identifier') {
+        return [node.name];
+    }
+    if (node.type === 'RestElement') {
+        return collectBindingNames(node.argument);
+    }
+    if (node.type === 'AssignmentPattern') {
+        return collectBindingNames(node.left);
+    }
+    if (node.type === 'ObjectPattern') {
+        return node.properties.flatMap((property) => property.type === 'RestElement'
+            ? collectBindingNames(property.argument)
+            : collectBindingNames(property.value));
+    }
+    if (node.type === 'ArrayPattern') {
+        return node.elements.flatMap((element) => element ? collectBindingNames(element) : []);
+    }
+    if (node.type === 'TSParameterProperty') {
+        return collectBindingNames(node.parameter);
+    }
+    return [];
+};
+export const isInTypeContext = (ancestors) => ancestors.some((ancestor) => ancestor.type.startsWith('TS') || ancestor.type.startsWith('JSDoc'));
+export const isPropertyOnlyIdentifier = (node, parent) => !!parent &&
+    parent.type === 'MemberExpression' &&
+    parent.property === node &&
+    !parent.computed;
+export const isObjectPropertyKey = (node, parent) => !!parent &&
+    parent.type === 'Property' &&
+    parent.key === node &&
+    !parent.computed &&
+    parent.value !== node;
+export const isBindingPosition = (node, parent) => {
+    if (!parent) {
+        return false;
+    }
+    if (parent.type === 'VariableDeclarator' && parent.id === node) {
+        return true;
+    }
+    if ((parent.type === 'FunctionDeclaration' ||
+        parent.type === 'FunctionExpression' ||
+        parent.type === 'ClassDeclaration' ||
+        parent.type === 'ClassExpression') &&
+        parent.id === node) {
+        return true;
+    }
+    if ((parent.type === 'ImportSpecifier' ||
+        parent.type === 'ImportDefaultSpecifier' ||
+        parent.type === 'ImportNamespaceSpecifier') &&
+        'local' in parent &&
+        parent.local === node) {
+        return true;
+    }
+    return false;
+};
+const visit = (node, scope, enter, parent = null, ancestors = []) => {
+    const visitNode = (currentNode, currentScope, currentParent) => {
+        let nextScope;
+        if (currentNode.type === 'Program') {
+            nextScope = createScope(null, currentNode, true, true);
+        }
+        else if (currentNode.type === 'BlockStatement' ||
+            currentNode.type === 'FunctionDeclaration' ||
+            currentNode.type === 'FunctionExpression' ||
+            currentNode.type === 'ArrowFunctionExpression') {
+            nextScope = createScope(currentScope, currentNode, false, currentNode.type !== 'BlockStatement');
+        }
+        else if (currentScope) {
+            nextScope = currentScope;
+        }
+        else {
+            nextScope = createScope(null, currentNode, false, true);
+        }
+        if (currentNode.type === 'FunctionDeclaration' ||
+            currentNode.type === 'FunctionExpression' ||
+            currentNode.type === 'ArrowFunctionExpression') {
+            currentNode.params.forEach((param) => {
+                collectBindingNames(param).forEach((name) => {
+                    nextScope.params.add(name);
+                    nextScope.bindings.set(name, {
+                        declaredAt: param.start,
+                        declaration: null,
+                        declarator: null,
+                        functionNode: null,
+                        isRoot: false,
+                        kind: 'param',
+                        name,
+                        scope: nextScope,
+                    });
+                });
+            });
+        }
+        enter(currentNode, nextScope, currentParent, ancestors);
+        ancestors.push(currentNode);
+        getOxcNodeChildren(currentNode).forEach((child) => visitNode(child, nextScope, currentNode));
+        ancestors.pop();
+    };
+    visitNode(node, scope, parent);
+};
+export const analyzeProgram = (program, { collectTargetExpressions = false, collectTemplateLiterals = false, expressionSpanLookup = null, templateSpanLookup = null, } = {}) => {
+    const bindings = new Map();
+    const usedNames = new Set();
+    const templateLiterals = [];
+    const targetExpressions = [];
+    const addBinding = (scope, binding) => {
+        scope.bindings.set(binding.name, binding);
+        const existing = bindings.get(binding.name) ?? [];
+        existing.push(binding);
+        bindings.set(binding.name, existing);
+    };
+    const collectTargets = (node, ancestors) => {
+        if (collectTemplateLiterals &&
+            node.type === 'TemplateLiteral' &&
+            node.expressions.length > 0 &&
+            !ancestors.some((ancestor) => ancestor.type === 'TemplateLiteral') &&
+            matchesSpanLookup(node, templateSpanLookup)) {
+            templateLiterals.push(node);
+        }
+        if (collectTargetExpressions &&
+            expressionSpanLookup &&
+            matchesSpanLookup(node, expressionSpanLookup)) {
+            targetExpressions.push(node);
+        }
+    };
+    visit(program, null, (node, scope, _parent, ancestors) => {
+        collectTargets(node, ancestors);
+        if (node.type === 'Identifier') {
+            usedNames.add(node.name);
+        }
+        if (isInTypeContext(ancestors)) {
+            return;
+        }
+        if (node.type === 'FunctionDeclaration' ||
+            node.type === 'FunctionExpression' ||
+            node.type === 'ArrowFunctionExpression') {
+            node.params.forEach((param) => {
+                collectBindingNames(param).forEach((name) => {
+                    const binding = scope.bindings.get(name);
+                    if (binding) {
+                        addBinding(scope, binding);
+                    }
+                });
+            });
+            if (node.type !== 'FunctionDeclaration') {
+                return;
+            }
+        }
+        if (node.type === 'ImportDeclaration') {
+            const source = node.source.value;
+            node.specifiers.forEach((specifier) => {
+                const importInfo = getImportSpecifierInfo(node, specifier);
+                if (!importInfo) {
+                    return;
+                }
+                addBinding(scope, {
+                    declaredAt: specifier.start,
+                    declaration: null,
+                    declarator: null,
+                    functionNode: null,
+                    imported: importInfo.imported,
+                    importedFrom: source,
+                    isRoot: scope.root,
+                    kind: 'import',
+                    name: importInfo.local,
+                    scope,
+                });
+            });
+            return;
+        }
+        if (node.type !== 'VariableDeclaration') {
+            if (node.type === 'FunctionDeclaration' && node.id) {
+                const declarationScope = scope.parent ?? scope;
+                const binding = {
+                    declaredAt: node.start,
+                    declaration: null,
+                    declarator: null,
+                    functionNode: node,
+                    isRoot: declarationScope.root,
+                    kind: 'function',
+                    name: node.id.name,
+                    scope: declarationScope,
+                };
+                addBinding(declarationScope, binding);
+            }
+            return;
+        }
+        node.declarations.forEach((declarator) => {
+            collectBindingNames(declarator.id).forEach((name) => {
+                const declarationKind = normalizeDeclarationKind(node.kind);
+                const declarationScope = getDeclarationScope(scope, declarationKind);
+                const binding = {
+                    declarationKind,
+                    declaredAt: declarator.start,
+                    declaration: node,
+                    declarator,
+                    functionNode: null,
+                    isRoot: declarationScope.root,
+                    kind: 'variable',
+                    name,
+                    scope: declarationScope,
+                };
+                addBinding(declarationScope, binding);
+            });
+        });
+    });
+    return {
+        bindingsByName: bindings,
+        rootMutationsByBinding: collectRootMutations(program),
+        targetExpressions: targetExpressions.sort((a, b) => a.start - b.start),
+        templateLiterals,
+        usedNames,
+    };
+};
+export const resolveBindingAt = (ctx, name, referenceStart) => {
+    const cachedBindings = ctx.bindingResolutionCache.get(name);
+    if (cachedBindings?.has(referenceStart)) {
+        return cachedBindings.get(referenceStart) ?? undefined;
+    }
+    const bindings = ctx.bindingsByName.get(name);
+    const bindingCache = cachedBindings ?? new Map();
+    if (!cachedBindings) {
+        ctx.bindingResolutionCache.set(name, bindingCache);
+    }
+    if (!bindings || bindings.length === 0) {
+        bindingCache.set(referenceStart, null);
+        return undefined;
+    }
+    let binding;
+    bindings.forEach((candidate) => {
+        if (candidate.scope.start > referenceStart ||
+            referenceStart >= candidate.scope.end) {
+            return;
+        }
+        if (!binding ||
+            candidate.scope.depth > binding.scope.depth ||
+            (candidate.scope.depth === binding.scope.depth &&
+                candidate.declaredAt > binding.declaredAt)) {
+            binding = candidate;
+        }
+    });
+    bindingCache.set(referenceStart, binding ?? null);
+    return binding;
+};
+const collectRootMutations = (program) => {
+    const mutations = new Map();
+    const getRootMutationTarget = (node) => {
+        if (node.type === 'Identifier') {
+            return {
+                binding: node.name,
+                path: [],
+            };
+        }
+        if (node.type !== 'MemberExpression') {
+            return null;
+        }
+        const parent = getRootMutationTarget(node.object);
+        if (!parent) {
+            return null;
+        }
+        let key = null;
+        if (node.computed &&
+            node.property.type === 'Literal' &&
+            (typeof node.property.value === 'string' ||
+                typeof node.property.value === 'number')) {
+            key = node.property.value;
+        }
+        else if (!node.computed && node.property.type === 'Identifier') {
+            key = node.property.name;
+        }
+        if (key === null) {
+            return null;
+        }
+        return {
+            binding: parent.binding,
+            path: [...parent.path, key],
+        };
+    };
+    program.body.forEach((statement) => {
+        if (statement.type !== 'ExpressionStatement') {
+            return;
+        }
+        const { expression } = statement;
+        if (expression.type === 'AssignmentExpression') {
+            const target = getRootMutationTarget(expression.left);
+            if (!target || target.path.length === 0) {
+                return;
+            }
+            const bucket = mutations.get(target.binding) ?? [];
+            bucket.push(expression);
+            mutations.set(target.binding, bucket);
+            return;
+        }
+        if (expression.type === 'UpdateExpression') {
+            const target = getRootMutationTarget(expression.argument);
+            if (!target || target.path.length === 0) {
+                return;
+            }
+            const bucket = mutations.get(target.binding) ?? [];
+            bucket.push(expression);
+            mutations.set(target.binding, bucket);
+        }
+    });
+    return mutations;
+};
+const hasLocalBinding = (scope, name) => {
+    let current = scope;
+    while (current) {
+        if (current.bindings.has(name)) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+};
+const hasLocalBindingCached = (scope, name, cache) => {
+    const scopeCache = cache.get(scope);
+    if (scopeCache?.has(name)) {
+        return scopeCache.get(name);
+    }
+    const result = hasLocalBinding(scope, name);
+    const nextScopeCache = scopeCache ?? new Map();
+    nextScopeCache.set(name, result);
+    if (!scopeCache) {
+        cache.set(scope, nextScopeCache);
+    }
+    return result;
+};
+export const findReferences = (node, referenceCache) => {
+    const cachedReferences = referenceCache?.get(node);
+    if (cachedReferences) {
+        return cachedReferences;
+    }
+    const refs = new Map();
+    const localBindingCache = new WeakMap();
+    visit(node, null, (current, scope, parent, ancestors) => {
+        if (current.type !== 'Identifier' ||
+            isInTypeContext(ancestors) ||
+            isBindingPosition(current, parent) ||
+            isPropertyOnlyIdentifier(current, parent) ||
+            isObjectPropertyKey(current, parent) ||
+            hasLocalBindingCached(scope, current.name, localBindingCache)) {
+            return;
+        }
+        const key = `${current.start}:${current.end}:${current.name}`;
+        refs.set(key, {
+            end: current.end,
+            name: current.name,
+            start: current.start,
+        });
+    });
+    const resolvedReferences = [...refs.values()];
+    referenceCache?.set(node, resolvedReferences);
+    return resolvedReferences;
+};
+export const isBindingDeclaredWithin = (binding, container) => container.start <= binding.declaredAt && binding.declaredAt < container.end;

package/types/utils/collectOxcTemplateDependencies/staticBindings.d.ts

@@ -0,0 +1,7 @@
+import type { StaticBindings } from './types';
+export declare const lookupStaticBinding: (staticBindings: StaticBindings | undefined, source: string | undefined, imported: string | undefined) => {
+    found: true;
+    value: unknown;
+} | {
+    found: false;
+};

package/types/utils/collectOxcTemplateDependencies/staticBindings.js

@@ -0,0 +1,13 @@
+export const lookupStaticBinding = (staticBindings, source, imported) => {
+    if (!staticBindings || !source || !imported) {
+        return { found: false };
+    }
+    const sourceMap = staticBindings[source];
+    if (!sourceMap) {
+        return { found: false };
+    }
+    if (!Object.prototype.hasOwnProperty.call(sourceMap, imported)) {
+        return { found: false };
+    }
+    return { found: true, value: sourceMap[imported] };
+};

package/types/utils/collectOxcTemplateDependencies/staticEvaluator.d.ts

@@ -0,0 +1,13 @@
+import type { Expression } from 'oxc-parser';
+import type { ExtractionContext } from './types';
+export declare const literalCode: (value: unknown) => string | null;
+export declare const isStaticSerializableValue: (value: unknown) => boolean;
+export declare const cloneStaticValue: (value: unknown) => unknown;
+type EvalEnv = Map<string, unknown>;
+declare const oxcStaticCallableValue: unique symbol;
+type OxcStaticCallableValue = {
+    [oxcStaticCallableValue]: unknown;
+};
+export declare const createOxcStaticCallableValue: (value: unknown) => OxcStaticCallableValue;
+export declare const evaluateStatic: (expression: Expression, ctx: ExtractionContext, env?: EvalEnv, stack?: string[]) => unknown | undefined;
+export {};