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

package/types/utils/applyOxcProcessors/shared.js

@@ -0,0 +1,37 @@
+import { printOxcAstServiceImport } from '../oxcAstService';
+import { parseOxcProgram } from '../oxc/parse';
+import { createOxcSourceLocation, } from '../oxc/sourceLocations';
+export const GENERATED_HELPER_NAME_RE = /^_exp\d*$/;
+export const WYW_META_EXTENDS_HELPER_RE = /(?:\bextends|["']extends["'])\s*:\s*(_exp\d*)\s*\(\s*\)/g;
+export const JS_IDENTIFIER_RE = /[$A-Z_a-z][$\w]*/g;
+export const parseOxc = (code, filename) => {
+    return parseOxcProgram(code, filename, 'module');
+};
+export const insertAddedImports = (code, program, addedImports) => {
+    if (addedImports.length === 0) {
+        return code;
+    }
+    const uniqueImports = [
+        ...new Map(addedImports.map((item) => [
+            `${item.source}\0${item.imported}\0${item.local}`,
+            item,
+        ])).values(),
+    ];
+    const importBlock = uniqueImports.map(printOxcAstServiceImport).join('\n');
+    const lastImport = [...program.body]
+        .reverse()
+        .find((statement) => statement.type === 'ImportDeclaration');
+    const hashbangEnd = code.startsWith('#!')
+        ? (() => {
+            const newline = code.indexOf('\n');
+            return newline === -1 ? code.length : newline + 1;
+        })()
+        : 0;
+    const insertionPoint = lastImport?.end ?? hashbangEnd;
+    const prefix = code.slice(0, insertionPoint);
+    const suffix = code.slice(insertionPoint);
+    const leadingBreak = prefix.length > 0 && !prefix.endsWith('\n') ? '\n' : '';
+    const trailingBreak = suffix.length > 0 && !suffix.startsWith('\n') ? '\n' : '';
+    return `${prefix}${leadingBreak}${importBlock}${trailingBreak}${suffix}`;
+};
+export const getSourceLocation = (start, end, loc, filename) => createOxcSourceLocation(start, end, loc, filename);

package/types/utils/applyOxcProcessors/types.d.ts

@@ -0,0 +1,88 @@
+import type { BaseProcessor } from '@wyw-in-js/processor-utils';
+import type { CallExpression, Expression, Node, TaggedTemplateExpression } from 'oxc-parser';
+import type { OxcStaticValue, OxcStaticValueCandidate } from '../collectOxcTemplateDependencies';
+import type { OxcAstService } from '../oxcAstService';
+import type { OxcValueReplacement } from '../oxc/replacements';
+import type { OxcLocationLookup } from '../oxc/sourceLocations';
+import type { ProcessorClass } from '../processorLookup';
+export type DefinedProcessor = [
+    ProcessorClass,
+    {
+        imported: string;
+        source: string;
+    }
+];
+export type Replacement = OxcValueReplacement;
+export type ApplyOxcProcessorsResult = {
+    code: string;
+    processorClassNamesByLocal: Map<string, string>;
+    processors: BaseProcessor[];
+    staticValueCandidates: OxcStaticValueCandidate[];
+    staticValues: OxcStaticValue[];
+};
+export type AnyNode = Node & Record<string, unknown>;
+export type OxcIdentifier = Expression & {
+    name: string;
+    type: 'Identifier';
+};
+export type ProcessorUsage = {
+    ancestors: Node[];
+    callee: Expression;
+    collapseQualifiedCallee: boolean;
+    definedProcessor: DefinedProcessor;
+    kind: 'call';
+    replacementTarget: Expression;
+    target: CallExpression;
+} | {
+    ancestors: Node[];
+    callee: Expression;
+    collapseQualifiedCallee: boolean;
+    definedProcessor: DefinedProcessor;
+    kind: 'template';
+    replacementTarget: Expression;
+    target: TaggedTemplateExpression;
+};
+export type ExpressionSpan = {
+    end: number;
+    start: number;
+};
+export type CreatedProcessor = {
+    astService: OxcAstService;
+    processor: BaseProcessor;
+};
+export type QualifiedExpression = Expression & {
+    expressions?: Expression[];
+};
+export type CallExpressionLike = Expression & {
+    arguments: Node[];
+    callee: Expression;
+    type: 'CallExpression';
+};
+export type SequenceExpressionLike = Expression & {
+    expressions: Expression[];
+    type: 'SequenceExpression';
+};
+export type LocationLookup = OxcLocationLookup;
+export type TopLevelStatementInfo = {
+    bindings: Set<string>;
+    node: Node;
+    references: Set<string>;
+};
+export type ScopedBindingKind = 'function' | 'import' | 'param' | 'variable';
+export type ScopedBindingInfo = {
+    declaration: Node;
+    dependencies: Set<string>;
+    externalReferences: number;
+    id: string;
+    incomingFromBindings: Set<string>;
+    kind: ScopedBindingKind;
+    name: string;
+};
+export type ScopedCleanupScope = {
+    bindings: Map<string, string>;
+    parent: ScopedCleanupScope | null;
+};
+export type SameFileProcessorObject = {
+    properties: Map<string, BaseProcessor>;
+    propertyNames: Set<string>;
+};

package/types/utils/applyOxcProcessors/types.js

@@ -0,0 +1 @@
+export {};

package/types/utils/applyOxcProcessors.d.ts

@@ -0,0 +1 @@
+export { applyOxcProcessors } from './applyOxcProcessors/applyOxcProcessors';

package/types/utils/applyOxcProcessors.js

@@ -0,0 +1 @@
+export { applyOxcProcessors } from './applyOxcProcessors/applyOxcProcessors';

package/types/utils/collectOxcExportsAndImports.d.ts

@@ -0,0 +1,35 @@
+import type { Program } from 'oxc-parser';
+type ImportKind = 'cjs' | 'dynamic' | 'esm';
+export type OxcLocal = {
+    code: string;
+    end: number;
+    name?: string;
+    start: number;
+};
+export type OxcCollectedImport = {
+    imported: string | 'default' | '*' | 'side-effect';
+    local: OxcLocal;
+    source: string;
+    type: ImportKind;
+};
+export type OxcCollectedExport = {
+    exported: string | 'default' | '*';
+    local: OxcLocal;
+};
+export type OxcCollectedReexport = {
+    exported: string | 'default' | '*';
+    imported: string | 'default' | '*';
+    local: OxcLocal;
+    source: string;
+};
+export type OxcCollectedState = {
+    deadExports: string[];
+    exports: Record<string | 'default' | '*', OxcLocal>;
+    imports: OxcCollectedImport[];
+    isEsModule: boolean;
+    reexports: OxcCollectedReexport[];
+};
+export declare function collectOxcExportsAndImportsFromProgram(program: Program, code: string, isEsModule: boolean): OxcCollectedState;
+export declare function collectOxcProcessorImportsFromProgram(program: Program, code: string): OxcCollectedImport[];
+export declare function collectOxcExportsAndImports(code: string, filename: string): OxcCollectedState;
+export {};