@remix-run/assets 0.0.0 → 0.2.0

package/dist/lib/scripts/resolve.js

@@ -0,0 +1,236 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createAssetServerCompilationError, isAssetServerCompilationError, } from "../compilation-error.js";
+import { normalizeFilePath } from "../paths.js";
+export const resolverExtensionAlias = {
+    '.js': ['.js', '.ts', '.tsx', '.jsx'],
+    '.jsx': ['.jsx', '.tsx'],
+    '.mjs': ['.mjs', '.mts'],
+};
+export const resolverExtensions = ['.ts', '.tsx', '.js', '.jsx', '.mts', '.mjs'];
+export const supportedScriptExtensions = ['.ts', '.tsx', '.js', '.jsx', '.mts', '.mjs'];
+const supportedScriptExtensionSet = new Set(supportedScriptExtensions);
+export async function resolveModule(record, transformed, args) {
+    let trackedFiles = new Set(transformed.trackedFiles);
+    let trackedResolutions = [];
+    let resolvedImports;
+    try {
+        resolvedImports =
+            transformed.unresolvedImports.length > 0
+                ? await batchResolveSpecifiers(getUniqueSpecifiers(transformed.unresolvedImports), transformed.resolvedPath, args.resolverFactory)
+                : new Map();
+    }
+    catch (error) {
+        return failResolve(error, trackedFiles, trackedResolutions, transformed.resolvedPath, {
+            isWatchIgnored: args.isWatchIgnored,
+        });
+    }
+    let importsWithPaths = [];
+    let deps = new Set();
+    for (let unresolved of transformed.unresolvedImports) {
+        let trackedResolution = getTrackedRelativeImportResolution(transformed.importerDir, unresolved.specifier, args.isWatchIgnored);
+        let resolvedSpec = resolvedImports.get(unresolved.specifier);
+        if (!resolvedSpec?.absolutePath) {
+            return failResolve(createAssetServerCompilationError(`Failed to resolve import "${unresolved.specifier}" in ${transformed.resolvedPath}. ` +
+                `Ensure it resolves to a file within the configured asset server fileMap, or mark it as external.`, {
+                code: 'IMPORT_RESOLUTION_FAILED',
+            }), trackedFiles, trackedResolutions, transformed.resolvedPath, { isWatchIgnored: args.isWatchIgnored, trackedResolution });
+        }
+        let resolvedImport = args.resolveModulePath(resolvedSpec.absolutePath);
+        if (!resolvedImport) {
+            return failResolve(createAssetServerCompilationError(`Import "${unresolved.specifier}" in ${transformed.resolvedPath}, resolved to "${resolvedSpec.absolutePath}", is not a supported script file. ` +
+                `Supported extensions are ${supportedScriptExtensions.join(', ')}.`, {
+                code: 'IMPORT_NOT_SUPPORTED',
+            }), trackedFiles, trackedResolutions, transformed.resolvedPath, { isWatchIgnored: args.isWatchIgnored, trackedResolution });
+        }
+        if (!args.isAllowed(resolvedImport.identityPath)) {
+            return failResolve(createAssetServerCompilationError(`Import "${unresolved.specifier}" in ${transformed.resolvedPath}, resolved to "${resolvedImport.identityPath}", is not allowed by the asset server allow/deny configuration. ` +
+                `Add a matching allow rule for this file path, remove a conflicting deny rule for this file path, or mark this import as external.`, {
+                code: 'IMPORT_NOT_ALLOWED',
+            }), trackedFiles, trackedResolutions, transformed.resolvedPath, { isWatchIgnored: args.isWatchIgnored, trackedResolution });
+        }
+        let stableUrlPathname = args.routes.toUrlPathname(resolvedImport.identityPath);
+        if (!stableUrlPathname) {
+            return failResolve(createAssetServerCompilationError(`Import "${unresolved.specifier}" in ${transformed.resolvedPath}, resolved to "${resolvedImport.identityPath}", is outside all configured fileMap entries. ` +
+                `Add a matching fileMap entry for this file path, or mark this import as external.`, {
+                code: 'IMPORT_OUTSIDE_FILE_MAP',
+            }), trackedFiles, trackedResolutions, transformed.resolvedPath, { isWatchIgnored: args.isWatchIgnored, trackedResolution });
+        }
+        deps.add(resolvedImport.identityPath);
+        if (transformed.packageSpecifiers.includes(unresolved.specifier)) {
+            let packageJsonPath = resolvedSpec.packageJsonPath ?? findNearestPackageJsonPath(resolvedImport.resolvedPath);
+            if (packageJsonPath && !args.isWatchIgnored(packageJsonPath)) {
+                trackedFiles.add(packageJsonPath);
+            }
+        }
+        if (trackedResolution) {
+            trackedResolutions.push({
+                ...trackedResolution,
+                resolvedIdentityPath: resolvedImport.identityPath,
+            });
+        }
+        importsWithPaths.push({
+            depPath: resolvedImport.identityPath,
+            end: unresolved.end,
+            quote: unresolved.quote,
+            start: unresolved.start,
+        });
+    }
+    return {
+        ok: true,
+        tracking: toResolveTracking(trackedFiles, trackedResolutions),
+        value: {
+            deps: [...deps],
+            fingerprint: transformed.fingerprint,
+            identityPath: record.identityPath,
+            imports: importsWithPaths,
+            trackedFiles: [...trackedFiles],
+            rawCode: transformed.rawCode,
+            resolvedPath: transformed.resolvedPath,
+            sourceMap: transformed.sourceMap,
+            stableUrlPathname: transformed.stableUrlPathname,
+        },
+    };
+}
+function findNearestPackageJsonPath(filePath) {
+    let directory = path.dirname(filePath);
+    while (true) {
+        let packageJsonPath = path.join(directory, 'package.json');
+        if (fs.existsSync(packageJsonPath)) {
+            return normalizeFilePath(packageJsonPath);
+        }
+        let parentDirectory = path.dirname(directory);
+        if (parentDirectory === directory)
+            return null;
+        directory = parentDirectory;
+    }
+}
+function isRelativeImportSpecifier(specifier) {
+    return specifier.startsWith('./') || specifier.startsWith('../');
+}
+function getTrackedRelativeImportResolution(importerDir, specifier, isWatchIgnored) {
+    if (!isRelativeImportSpecifier(specifier))
+        return null;
+    let candidatePath = resolveCandidateBasePath(importerDir, specifier);
+    let candidatePrefixes = [`${candidatePath}/`].filter((candidatePrefix) => !isWatchIgnored(candidatePrefix.replace(/\/+$/, '') || '/'));
+    let extension = path.extname(specifier);
+    if (extension === '') {
+        let candidatePaths = [
+            candidatePath,
+            ...supportedScriptExtensions.map((candidateExtension) => `${candidatePath}${candidateExtension}`),
+        ].filter((candidatePath) => !isWatchIgnored(candidatePath));
+        return candidatePaths.length === 0 && candidatePrefixes.length === 0
+            ? null
+            : {
+                candidatePaths,
+                candidatePrefixes,
+                specifier,
+            };
+    }
+    let candidateExtensions = resolverExtensionAlias[extension];
+    if (!candidateExtensions && !supportedScriptExtensionSet.has(extension)) {
+        let candidatePaths = [
+            candidatePath,
+            ...supportedScriptExtensions.map((candidateExtension) => `${candidatePath}${candidateExtension}`),
+        ].filter((candidatePath) => !isWatchIgnored(candidatePath));
+        return candidatePaths.length === 0 && candidatePrefixes.length === 0
+            ? null
+            : {
+                candidatePaths,
+                candidatePrefixes,
+                specifier,
+            };
+    }
+    if (!candidateExtensions)
+        return null;
+    let candidatePaths = [
+        candidatePath,
+        ...candidateExtensions.map((candidateExtension) => `${candidatePath.slice(0, candidatePath.length - extension.length)}${candidateExtension}`),
+    ].filter((candidatePath) => !isWatchIgnored(candidatePath));
+    return candidatePaths.length === 0 && candidatePrefixes.length === 0
+        ? null
+        : {
+            candidatePaths,
+            candidatePrefixes,
+            specifier,
+        };
+}
+function resolveCandidateBasePath(importerDir, specifier) {
+    return normalizeFilePath(path.resolve(importerDir, specifier));
+}
+async function batchResolveSpecifiers(specifiers, importerPath, resolverFactory) {
+    let resolvedBySpecifier = new Map();
+    if (specifiers.length === 0)
+        return resolvedBySpecifier;
+    try {
+        for (let specifier of specifiers) {
+            let resolutionResult = await resolverFactory.resolveFileAsync(importerPath, specifier);
+            if (resolutionResult.error) {
+                throw createAssetServerCompilationError(`Failed to resolve import "${specifier}" in ${importerPath}. ` +
+                    `Ensure it resolves to a file within the configured asset server fileMap, or mark it as external.`, {
+                    code: 'IMPORT_RESOLUTION_FAILED',
+                });
+            }
+            resolvedBySpecifier.set(specifier, {
+                absolutePath: resolutionResult.path && path.isAbsolute(resolutionResult.path)
+                    ? normalizeFilePath(resolutionResult.path)
+                    : null,
+                packageJsonPath: resolutionResult.packageJsonPath
+                    ? normalizeFilePath(resolutionResult.packageJsonPath)
+                    : null,
+                specifier,
+            });
+        }
+    }
+    catch (error) {
+        if (isAssetServerCompilationError(error) && error.code === 'IMPORT_RESOLUTION_FAILED') {
+            throw error;
+        }
+        throw createAssetServerCompilationError(`Failed to resolve imports in ${importerPath}. ${formatUnknownError(error)}`, {
+            cause: error,
+            code: 'IMPORT_RESOLUTION_FAILED',
+        });
+    }
+    return resolvedBySpecifier;
+}
+function getUniqueSpecifiers(unresolvedImports) {
+    return [...new Set(unresolvedImports.map((unresolved) => unresolved.specifier))];
+}
+function formatUnknownError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function failResolve(error, trackedFiles, trackedResolutions, importerPath, options = {}) {
+    return {
+        ok: false,
+        error: toResolveError(error, importerPath),
+        tracking: toResolveTracking(trackedFiles, appendFailedTrackedResolution(trackedResolutions, options.trackedResolution)),
+    };
+}
+function toResolveTracking(trackedFiles, trackedResolutions) {
+    return {
+        trackedFiles: [
+            ...trackedFiles,
+            ...trackedResolutions.flatMap((trackedResolution) => trackedResolution.candidatePaths),
+        ],
+        trackedDirectories: trackedResolutions.flatMap((trackedResolution) => trackedResolution.candidatePrefixes),
+    };
+}
+function appendFailedTrackedResolution(trackedResolutions, trackedResolution) {
+    if (trackedResolution == null)
+        return [...trackedResolutions];
+    return [
+        ...trackedResolutions,
+        {
+            ...trackedResolution,
+            resolvedIdentityPath: null,
+        },
+    ];
+}
+function toResolveError(error, importerPath) {
+    if (isAssetServerCompilationError(error))
+        return error;
+    return createAssetServerCompilationError(`Failed to resolve imports in ${importerPath}. ${formatUnknownError(error)}`, {
+        cause: error,
+        code: 'IMPORT_RESOLUTION_FAILED',
+    });
+}

package/dist/lib/scripts/transform.d.ts

@@ -0,0 +1,64 @@
+import type { TsConfigJsonResolved } from 'get-tsconfig';
+import type { AssetServerCompilationError } from '../compilation-error.ts';
+import type { ModuleRecord, ModuleTracking } from '../module-store.ts';
+import type { CompiledRoutes } from '../routes.ts';
+import type { EmittedModule } from './emit.ts';
+import type { ResolvedScriptTarget } from '../target.ts';
+import type { ResolvedModule } from './resolve.ts';
+type ScriptRecord = ModuleRecord<TransformedModule, ResolvedModule, EmittedModule>;
+export type ResolveModuleResult = {
+    identityPath: string;
+    resolvedPath: string;
+};
+type UnresolvedImport = {
+    end: number;
+    quote?: '"' | "'" | '`';
+    specifier: string;
+    start: number;
+};
+export type TransformedModule = {
+    fingerprint: string | null;
+    identityPath: string;
+    importerDir: string;
+    packageSpecifiers: string[];
+    rawCode: string;
+    resolvedPath: string;
+    sourceMap: string | null;
+    stableUrlPathname: string;
+    trackedFiles: string[];
+    unresolvedImports: UnresolvedImport[];
+};
+type TransformResult = {
+    tracking: ModuleTracking;
+} & ({
+    ok: true;
+    value: TransformedModule;
+} | {
+    ok: false;
+    error: AssetServerCompilationError;
+});
+type TsconfigTransformOptions = {
+    trackedFiles: string[];
+    tsconfigRaw?: TsConfigJsonResolved;
+};
+type TsconfigTransformOptionsResolver = ReturnType<typeof createTsconfigTransformOptionsResolver>;
+export type TransformArgs = {
+    buildId: string | null;
+    define: Record<string, string> | null;
+    externalSet: ReadonlySet<string>;
+    isWatchIgnored(filePath: string): boolean;
+    minify: boolean;
+    resolveActualPath(identityPath: string): string | null;
+    routes: CompiledRoutes;
+    sourceMapSourcePaths: 'absolute' | 'url';
+    sourceMaps: 'external' | 'inline' | null;
+    target: ResolvedScriptTarget | null;
+    tsconfigTransformOptionsResolver: TsconfigTransformOptionsResolver;
+};
+export declare function createTsconfigTransformOptionsResolver(): {
+    clear(): void;
+    getTransformOptions(filePath: string, isWatchIgnored: (filePath: string) => boolean): TsconfigTransformOptions;
+};
+export declare function transformModule(record: ScriptRecord, args: TransformArgs): Promise<TransformResult>;
+export {};
+//# sourceMappingURL=transform.d.ts.map

package/dist/lib/scripts/transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../src/lib/scripts/transform.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAS,oBAAoB,EAAE,MAAM,cAAc,CAAA;AAQ/D,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAA;AAE1E,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAEtE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAElD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAC9C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAA;AACxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAElD,KAAK,YAAY,GAAG,YAAY,CAAC,iBAAiB,EAAE,cAAc,EAAE,aAAa,CAAC,CAAA;AA4BlF,MAAM,MAAM,mBAAmB,GAAG;IAChC,YAAY,EAAE,MAAM,CAAA;IACpB,YAAY,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,KAAK,gBAAgB,GAAG;IACtB,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,CAAA;IACvB,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,YAAY,EAAE,MAAM,CAAA;IACpB,WAAW,EAAE,MAAM,CAAA;IACnB,iBAAiB,EAAE,MAAM,EAAE,CAAA;IAC3B,OAAO,EAAE,MAAM,CAAA;IACf,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,iBAAiB,EAAE,MAAM,CAAA;IACzB,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB,iBAAiB,EAAE,gBAAgB,EAAE,CAAA;CACtC,CAAA;AAED,KAAK,eAAe,GAAG;IACrB,QAAQ,EAAE,cAAc,CAAA;CACzB,GAAG,CACA;IACE,EAAE,EAAE,IAAI,CAAA;IACR,KAAK,EAAE,iBAAiB,CAAA;CACzB,GACD;IACE,EAAE,EAAE,KAAK,CAAA;IACT,KAAK,EAAE,2BAA2B,CAAA;CACnC,CACJ,CAAA;AAED,KAAK,wBAAwB,GAAG;IAC9B,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB,WAAW,CAAC,EAAE,oBAAoB,CAAA;CACnC,CAAA;AAED,KAAK,gCAAgC,GAAG,UAAU,CAAC,OAAO,sCAAsC,CAAC,CAAA;AAEjG,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAA;IACrC,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IAChC,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAA;IACzC,MAAM,EAAE,OAAO,CAAA;IACf,iBAAiB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;IACtD,MAAM,EAAE,cAAc,CAAA;IACtB,oBAAoB,EAAE,UAAU,GAAG,KAAK,CAAA;IACxC,UAAU,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAAA;IACxC,MAAM,EAAE,oBAAoB,GAAG,IAAI,CAAA;IACnC,gCAAgC,EAAE,gCAAgC,CAAA;CACnE,CAAA;AAED,wBAAgB,sCAAsC;;;EAkCrD;AAED,wBAAsB,eAAe,CACnC,MAAM,EAAE,YAAY,EACpB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,eAAe,CAAC,CA6H1B"}

package/dist/lib/scripts/transform.js

@@ -0,0 +1,373 @@
+import * as fs from 'node:fs';
+import * as fsp from 'node:fs/promises';
+import * as path from 'node:path';
+import { getTsconfig } from 'get-tsconfig';
+import { minify } from 'oxc-minify';
+import { transform as oxcTransform } from 'oxc-transform';
+import { init as esModuleLexerInit, parse as esModuleLexer } from 'es-module-lexer';
+import { isCommonJS, mayContainCommonJSModuleGlobals } from "./cjs-check.js";
+import { createAssetServerCompilationError, isAssetServerCompilationError, } from "../compilation-error.js";
+import { generateFingerprint } from "../fingerprint.js";
+import { normalizeFilePath } from "../paths.js";
+import { composeSourceMaps, rewriteSourceMapSources, stringifySourceMap } from "../source-maps.js";
+const scriptModuleTypes = [
+    { extension: '.js', lang: 'js' },
+    { extension: '.jsx', lang: 'jsx' },
+    { extension: '.mjs', lang: 'js' },
+    { extension: '.mts', lang: 'ts' },
+    { extension: '.ts', lang: 'ts' },
+    { extension: '.tsx', lang: 'tsx' },
+];
+const sourceLanguageByExtension = new Map(scriptModuleTypes.map(({ extension, lang }) => [extension, lang]));
+const supportedTsconfigTransformCompilerOptions = {
+    allowNamespaces: 'allowNamespaces',
+    emitDecoratorMetadata: 'emitDecoratorMetadata',
+    experimentalDecorators: 'experimentalDecorators',
+    jsx: 'jsx',
+    jsxFactory: 'jsxFactory',
+    jsxFragmentFactory: 'jsxFragmentFactory',
+    jsxImportSource: 'jsxImportSource',
+    useDefineForClassFields: 'useDefineForClassFields',
+};
+export function createTsconfigTransformOptionsResolver() {
+    let fileSystemCache = new Map();
+    let transformOptionsByDirectory = new Map();
+    return {
+        clear() {
+            fileSystemCache = new Map();
+            transformOptionsByDirectory.clear();
+        },
+        getTransformOptions(filePath, isWatchIgnored) {
+            let directory = path.dirname(filePath);
+            let cached = transformOptionsByDirectory.get(directory);
+            if (cached)
+                return cached;
+            let tsconfig = getTsconfig(directory, 'tsconfig.json', fileSystemCache);
+            if (!tsconfig) {
+                let transformOptions = { trackedFiles: [] };
+                transformOptionsByDirectory.set(directory, transformOptions);
+                return transformOptions;
+            }
+            let tsconfigPath = findNearestTsconfigPath(directory);
+            let transformOptions = {
+                trackedFiles: tsconfigPath && !isWatchIgnored(tsconfigPath) ? [tsconfigPath] : [],
+                tsconfigRaw: tsconfig.config,
+            };
+            transformOptionsByDirectory.set(directory, transformOptions);
+            return transformOptions;
+        },
+    };
+}
+export async function transformModule(record, args) {
+    let resolvedPath = args.resolveActualPath(record.identityPath);
+    if (!resolvedPath) {
+        return {
+            ok: false,
+            error: createAssetServerCompilationError(`File not found: ${record.identityPath}`, {
+                code: 'FILE_NOT_FOUND',
+            }),
+            tracking: {
+                trackedFiles: args.isWatchIgnored(record.identityPath) ? [] : [record.identityPath],
+            },
+        };
+    }
+    let transformOptions = args.tsconfigTransformOptionsResolver.getTransformOptions(resolvedPath, args.isWatchIgnored);
+    let trackedFiles = [
+        ...(args.isWatchIgnored(resolvedPath) ? [] : [resolvedPath]),
+        ...transformOptions.trackedFiles,
+    ];
+    let sourceText;
+    try {
+        sourceText = await fsp.readFile(resolvedPath, 'utf-8');
+    }
+    catch (error) {
+        if (isNoEntityError(error)) {
+            return {
+                ok: false,
+                error: createAssetServerCompilationError(`File not found: ${resolvedPath}`, {
+                    cause: error,
+                    code: 'FILE_NOT_FOUND',
+                }),
+                tracking: {
+                    trackedFiles,
+                },
+            };
+        }
+        return {
+            ok: false,
+            error: toTransformFailedError(error, resolvedPath),
+            tracking: {
+                trackedFiles,
+            },
+        };
+    }
+    try {
+        let analysis = await analyzeModuleSource(sourceText, resolvedPath, transformOptions, {
+            define: args.define ?? undefined,
+            minify: args.minify,
+            sourceMaps: args.sourceMaps ?? undefined,
+            target: args.target ?? undefined,
+        });
+        analysis.unresolvedImports = analysis.unresolvedImports.filter((unresolved) => !args.externalSet.has(unresolved.specifier));
+        if (mayContainCommonJSModuleGlobals(sourceText) && isCommonJS(analysis.rawCode)) {
+            throw createAssetServerCompilationError(`CommonJS module detected: ${resolvedPath}. ` +
+                `This module uses CommonJS (require/module.exports) which is not supported. ` +
+                `Please use an ESM-compatible module.`, {
+                code: 'COMMONJS_NOT_SUPPORTED',
+            });
+        }
+        let stableUrlPathname = args.routes.toUrlPathname(record.identityPath);
+        if (!stableUrlPathname) {
+            throw createAssetServerCompilationError(`File ${record.identityPath} is outside all configured fileMap entries.`, {
+                code: 'FILE_OUTSIDE_FILE_MAP',
+            });
+        }
+        let sourceMap = analysis.sourceMap
+            ? rewriteSourceMapSources(analysis.sourceMap, resolvedPath, stableUrlPathname, args.sourceMapSourcePaths, sourceText)
+            : null;
+        return {
+            ok: true,
+            tracking: {
+                trackedFiles,
+            },
+            value: {
+                fingerprint: args.buildId === null
+                    ? null
+                    : await generateFingerprint({
+                        buildId: args.buildId,
+                        content: sourceText,
+                    }),
+                identityPath: record.identityPath,
+                importerDir: path.dirname(resolvedPath),
+                packageSpecifiers: analysis.unresolvedImports
+                    .filter((unresolved) => isPackageImportSpecifier(unresolved.specifier))
+                    .map((unresolved) => unresolved.specifier),
+                rawCode: analysis.rawCode,
+                resolvedPath,
+                sourceMap,
+                stableUrlPathname,
+                trackedFiles,
+                unresolvedImports: analysis.unresolvedImports,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: toTransformFailedError(error, resolvedPath),
+            tracking: {
+                trackedFiles,
+            },
+        };
+    }
+}
+function findNearestTsconfigPath(directory) {
+    let currentDirectory = directory;
+    while (true) {
+        let tsconfigPath = path.join(currentDirectory, 'tsconfig.json');
+        if (fs.existsSync(tsconfigPath)) {
+            return normalizeFilePath(tsconfigPath);
+        }
+        let parentDirectory = path.dirname(currentDirectory);
+        if (parentDirectory === currentDirectory)
+            return null;
+        currentDirectory = parentDirectory;
+    }
+}
+function isPackageImportSpecifier(specifier) {
+    return !specifier.startsWith('./') && !specifier.startsWith('../') && !specifier.startsWith('/');
+}
+async function analyzeModuleSource(sourceText, resolvedPath, transformOptions, options) {
+    let transformResult;
+    try {
+        transformResult = await oxcTransform(resolvedPath, sourceText, getTransformOptions(resolvedPath, transformOptions, options));
+        assertNoCompilerErrors(transformResult.errors, resolvedPath, 'transform');
+    }
+    catch (error) {
+        if (isAssetServerCompilationError(error))
+            throw error;
+        throw createAssetServerCompilationError(`Failed to transform script ${resolvedPath}. ${formatUnknownError(error)}`, {
+            cause: error,
+            code: 'TRANSFORM_FAILED',
+        });
+    }
+    let rawCode = transformResult.code.trimEnd();
+    let sourceMap = stringifySourceMap(transformResult.map);
+    if (options.minify) {
+        let minifyResult = await minifyModule(rawCode, resolvedPath, options.target, options.sourceMaps);
+        rawCode = minifyResult.code.trimEnd();
+        let minifyMap = stringifySourceMap(minifyResult.map);
+        sourceMap =
+            minifyMap == null
+                ? sourceMap
+                : sourceMap == null
+                    ? minifyMap
+                    : composeSourceMaps(minifyMap, sourceMap);
+    }
+    return {
+        rawCode,
+        sourceMap,
+        unresolvedImports: await getUnresolvedImportsFromLexer(rawCode),
+    };
+}
+async function minifyModule(rawCode, resolvedPath, target, sourceMaps) {
+    try {
+        let result = await minify(resolvedPath, rawCode, {
+            compress: target ? { target } : true,
+            mangle: true,
+            module: true,
+            sourcemap: sourceMaps != null,
+        });
+        assertNoCompilerErrors(result.errors, resolvedPath, 'minify');
+        return result;
+    }
+    catch (error) {
+        if (isAssetServerCompilationError(error))
+            throw error;
+        throw createAssetServerCompilationError(`Failed to minify script ${resolvedPath}. ${formatUnknownError(error)}`, {
+            cause: error,
+            code: 'TRANSFORM_FAILED',
+        });
+    }
+}
+function getTransformOptions(resolvedPath, transformOptions, options) {
+    let compilerOptions = transformOptions.tsconfigRaw?.compilerOptions;
+    let useDefineForClassFields = getBooleanOption(compilerOptions, supportedTsconfigTransformCompilerOptions.useDefineForClassFields);
+    let jsxFactory = getStringOption(compilerOptions, supportedTsconfigTransformCompilerOptions.jsxFactory);
+    let jsxFragmentFactory = getStringOption(compilerOptions, supportedTsconfigTransformCompilerOptions.jsxFragmentFactory);
+    return {
+        assumptions: useDefineForClassFields === false
+            ? {
+                setPublicClassFields: true,
+            }
+            : undefined,
+        decorator: getDecoratorOptions(compilerOptions),
+        define: options.define,
+        jsx: getJsxOptions(resolvedPath, compilerOptions),
+        lang: getSourceLanguageForPath(resolvedPath),
+        sourceType: 'module',
+        sourcemap: options.sourceMaps != null,
+        target: options.target,
+        typescript: {
+            allowNamespaces: getBooleanOption(compilerOptions, supportedTsconfigTransformCompilerOptions.allowNamespaces),
+            jsxPragma: jsxFactory,
+            jsxPragmaFrag: jsxFragmentFactory,
+            removeClassFieldsWithoutInitializer: useDefineForClassFields === false ? true : undefined,
+        },
+    };
+}
+function getJsxOptions(resolvedPath, compilerOptions) {
+    let language = getSourceLanguageForPath(resolvedPath);
+    if (language !== 'jsx' && language !== 'tsx')
+        return undefined;
+    let jsx = getStringOption(compilerOptions, supportedTsconfigTransformCompilerOptions.jsx);
+    let importSource = getStringOption(compilerOptions, supportedTsconfigTransformCompilerOptions.jsxImportSource);
+    let pragma = getStringOption(compilerOptions, supportedTsconfigTransformCompilerOptions.jsxFactory);
+    let pragmaFrag = getStringOption(compilerOptions, supportedTsconfigTransformCompilerOptions.jsxFragmentFactory);
+    if (jsx === 'preserve' || jsx === 'react-native') {
+        throw createAssetServerCompilationError(`Unsupported tsconfig compilerOptions.jsx = "${jsx}" for ${resolvedPath}. ` +
+            `Asset server must compile JSX to browser-runnable JavaScript.`, {
+            code: 'TRANSFORM_FAILED',
+        });
+    }
+    if (jsx === 'react-jsx' || jsx === 'react-jsxdev') {
+        return {
+            development: jsx === 'react-jsxdev',
+            importSource,
+            runtime: 'automatic',
+        };
+    }
+    return {
+        pragma,
+        pragmaFrag,
+        runtime: 'classic',
+    };
+}
+function getDecoratorOptions(compilerOptions) {
+    let legacy = getBooleanOption(compilerOptions, supportedTsconfigTransformCompilerOptions.experimentalDecorators);
+    let emitDecoratorMetadata = getBooleanOption(compilerOptions, supportedTsconfigTransformCompilerOptions.emitDecoratorMetadata);
+    if (legacy !== true && emitDecoratorMetadata !== true)
+        return undefined;
+    return {
+        emitDecoratorMetadata,
+        legacy,
+    };
+}
+function getBooleanOption(compilerOptions, key) {
+    let value = compilerOptions?.[key];
+    return typeof value === 'boolean' ? value : undefined;
+}
+function getStringOption(compilerOptions, key) {
+    let value = compilerOptions?.[key];
+    return typeof value === 'string' ? value : undefined;
+}
+function assertNoCompilerErrors(errors, resolvedPath, operation) {
+    if (!errors || errors.length === 0)
+        return;
+    throw createAssetServerCompilationError(`Failed to ${operation} script ${resolvedPath}. ${errors[0].message ?? 'Unknown error'}`, {
+        code: 'TRANSFORM_FAILED',
+    });
+}
+async function getUnresolvedImportsFromLexer(rawCode) {
+    await esModuleLexerInit;
+    let [imports] = esModuleLexer(rawCode);
+    let unresolvedImports = [];
+    for (let imported of imports) {
+        let specifier = getStaticImportSpecifier(rawCode, imported);
+        if (specifier == null || shouldSkipImportSpecifier(specifier))
+            continue;
+        unresolvedImports.push({
+            specifier,
+            start: imported.s,
+            end: imported.e,
+            quote: getImportQuote(rawCode, imported.s),
+        });
+    }
+    return unresolvedImports;
+}
+function getStaticImportSpecifier(source, imported) {
+    if (imported.n != null) {
+        return imported.n;
+    }
+    if (imported.d < 0) {
+        return null;
+    }
+    let rawSpecifier = source.slice(imported.s, imported.e);
+    if (!isStaticTemplateLiteral(rawSpecifier)) {
+        return null;
+    }
+    return rawSpecifier.slice(1, -1);
+}
+function isStaticTemplateLiteral(specifier) {
+    return specifier.startsWith('`') && specifier.endsWith('`') && !specifier.includes('${');
+}
+function shouldSkipImportSpecifier(specifier) {
+    return (specifier.startsWith('data:') ||
+        specifier.startsWith('http://') ||
+        specifier.startsWith('https://'));
+}
+function getImportQuote(source, start) {
+    let firstCharacter = source[start];
+    if (firstCharacter === '"' || firstCharacter === "'" || firstCharacter === '`') {
+        return firstCharacter;
+    }
+    return undefined;
+}
+function getSourceLanguageForPath(resolvedPath) {
+    let extension = path.extname(resolvedPath).toLowerCase();
+    return sourceLanguageByExtension.get(extension) ?? 'js';
+}
+function formatUnknownError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function toTransformFailedError(error, resolvedPath) {
+    if (isAssetServerCompilationError(error))
+        return error;
+    return createAssetServerCompilationError(`Failed to transform script ${resolvedPath}. ${formatUnknownError(error)}`, {
+        cause: error,
+        code: 'TRANSFORM_FAILED',
+    });
+}
+function isNoEntityError(error) {
+    return (error instanceof Error && 'code' in error && error.code === 'ENOENT');
+}

package/dist/lib/source-maps.d.ts

@@ -0,0 +1,4 @@
+export declare function composeSourceMaps(rewriteSourceMap: string, transformSourceMap: string): string;
+export declare function rewriteSourceMapSources(sourceMap: string, resolvedPath: string, stableUrlPathname: string, sourceMapSourcePaths: 'absolute' | 'url', sourceContent?: string): string;
+export declare function stringifySourceMap(map: unknown): string | null;
+//# sourceMappingURL=source-maps.d.ts.map