@remix-run/assets 0.0.0 → 0.1.0

package/dist/lib/scripts/resolve.js

@@ -0,0 +1,230 @@
+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(`Resolved import "${unresolved.specifier}" in ${transformed.resolvedPath} is not a supported script module. ` +
+                `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(`Resolved import "${unresolved.specifier}" in ${transformed.resolvedPath} is not allowed by the asset server allow/deny configuration. ` +
+                `Add a matching allow rule, remove a conflicting deny rule, 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(`Resolved import "${unresolved.specifier}" in ${transformed.resolvedPath} 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,
+        value: {
+            deps: [...deps],
+            fingerprint: transformed.fingerprint,
+            identityPath: record.identityPath,
+            imports: importsWithPaths,
+            trackedFiles: [...trackedFiles],
+            trackedResolutions,
+            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: {
+            trackedFiles: [...trackedFiles],
+            trackedResolutions: appendFailedTrackedResolution(trackedResolutions, options.trackedResolution),
+        },
+    };
+}
+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/store.d.ts

@@ -0,0 +1,40 @@
+import type { EmittedModule } from './emit.ts';
+import type { ResolutionFailureState, ResolvedModule, TrackedResolution } from './resolve.ts';
+import type { TransformFailureState, TransformedModule } from './transform.ts';
+export type ModuleWatchEvent = 'change' | 'add' | 'unlink';
+export type FileSnapshot = {
+    mtimeNs: bigint;
+    size: bigint;
+};
+export type ModuleSnapshot = ReadonlyMap<string, FileSnapshot>;
+type ModuleRecordState = {
+    identityPath: string;
+    invalidationVersion: number;
+    transformed?: TransformedModule;
+    resolved?: ResolvedModule;
+    emitted?: EmittedModule;
+    emittedSnapshot?: ModuleSnapshot;
+    staleEmitted?: EmittedModule;
+    staleEmittedSnapshot?: ModuleSnapshot;
+    trackedFiles: ReadonlySet<string>;
+    trackedResolutions: readonly TrackedResolution[];
+};
+export type ModuleRecord = Readonly<ModuleRecordState>;
+type ModuleStore = {
+    get(identityPath: string): ModuleRecord;
+    setTransformFailure(identityPath: string, failure: TransformFailureState): void;
+    setTransformed(identityPath: string, transformed: TransformedModule): void;
+    setResolved(identityPath: string, resolved: ResolvedModule): void;
+    setResolveFailure(identityPath: string, failure: ResolutionFailureState): void;
+    setEmitted(identityPath: string, emitted: EmittedModule, snapshot: ModuleSnapshot | null): void;
+    invalidateForFileEvent(filePath: string, event: ModuleWatchEvent): void;
+    invalidateAll(): void;
+};
+export declare function createModuleStore(options?: {
+    onWatchDirectoriesChange?: (delta: {
+        add: string[];
+        remove: string[];
+    }) => void;
+}): ModuleStore;
+export {};
+//# sourceMappingURL=store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../src/lib/scripts/store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAE9C,OAAO,KAAK,EAAE,sBAAsB,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAC7F,OAAO,KAAK,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAE9E,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,KAAK,GAAG,QAAQ,CAAA;AAE1D,MAAM,MAAM,YAAY,GAAG;IACzB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,cAAc,GAAG,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,CAAA;AAE9D,KAAK,iBAAiB,GAAG;IACvB,YAAY,EAAE,MAAM,CAAA;IACpB,mBAAmB,EAAE,MAAM,CAAA;IAC3B,WAAW,CAAC,EAAE,iBAAiB,CAAA;IAC/B,QAAQ,CAAC,EAAE,cAAc,CAAA;IACzB,OAAO,CAAC,EAAE,aAAa,CAAA;IACvB,eAAe,CAAC,EAAE,cAAc,CAAA;IAChC,YAAY,CAAC,EAAE,aAAa,CAAA;IAC5B,oBAAoB,CAAC,EAAE,cAAc,CAAA;IACrC,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IACjC,kBAAkB,EAAE,SAAS,iBAAiB,EAAE,CAAA;CACjD,CAAA;AAED,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC,iBAAiB,CAAC,CAAA;AAetD,KAAK,WAAW,GAAG;IACjB,GAAG,CAAC,YAAY,EAAE,MAAM,GAAG,YAAY,CAAA;IACvC,mBAAmB,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,qBAAqB,GAAG,IAAI,CAAA;IAC/E,cAAc,CAAC,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,iBAAiB,GAAG,IAAI,CAAA;IAC1E,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,GAAG,IAAI,CAAA;IACjE,iBAAiB,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,sBAAsB,GAAG,IAAI,CAAA;IAC9E,UAAU,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,cAAc,GAAG,IAAI,GAAG,IAAI,CAAA;IAC/F,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,gBAAgB,GAAG,IAAI,CAAA;IACvE,aAAa,IAAI,IAAI,CAAA;CACtB,CAAA;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,GAAE;IACP,wBAAwB,CAAC,EAAE,CAAC,KAAK,EAAE;QAAE,GAAG,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE,KAAK,IAAI,CAAA;CAC3E,GACL,WAAW,CA4Nb"}

package/dist/lib/scripts/store.js

@@ -0,0 +1,228 @@
+import { getFilePathDirectory } from "../paths.js";
+export function createModuleStore(options = {}) {
+    let recordsByIdentityPath = new Map();
+    let recordsByTrackedFile = new Map();
+    let watchDirectoryRefCountByPath = new Map();
+    return {
+        get(identityPath) {
+            let existing = recordsByIdentityPath.get(identityPath);
+            if (existing)
+                return existing;
+            let record = {
+                identityPath,
+                invalidationVersion: 0,
+                trackedFiles: new Set(),
+                trackedResolutions: [],
+            };
+            recordsByIdentityPath.set(identityPath, record);
+            return record;
+        },
+        setTransformFailure(identityPath, failure) {
+            let record = getOrCreateMutableRecord(identityPath);
+            record.transformed = undefined;
+            record.resolved = undefined;
+            record.emitted = undefined;
+            record.emittedSnapshot = undefined;
+            record.staleEmitted = undefined;
+            record.staleEmittedSnapshot = undefined;
+            setTracking(record, {
+                trackedFiles: failure.trackedFiles,
+                trackedResolutions: [],
+            });
+        },
+        setTransformed(identityPath, transformed) {
+            let record = getOrCreateMutableRecord(identityPath);
+            record.transformed = transformed;
+            record.resolved = undefined;
+            record.emitted = undefined;
+            record.emittedSnapshot = undefined;
+            record.staleEmitted = undefined;
+            record.staleEmittedSnapshot = undefined;
+            setTracking(record, {
+                trackedFiles: transformed.trackedFiles,
+                trackedResolutions: [],
+            });
+        },
+        setResolved(identityPath, resolved) {
+            let record = getOrCreateMutableRecord(identityPath);
+            record.resolved = resolved;
+            record.emitted = undefined;
+            record.emittedSnapshot = undefined;
+            record.staleEmitted = undefined;
+            record.staleEmittedSnapshot = undefined;
+            setTracking(record, {
+                trackedFiles: resolved.trackedFiles,
+                trackedResolutions: resolved.trackedResolutions,
+            });
+        },
+        setResolveFailure(identityPath, failure) {
+            let record = getOrCreateMutableRecord(identityPath);
+            record.resolved = undefined;
+            record.emitted = undefined;
+            record.emittedSnapshot = undefined;
+            record.staleEmitted = undefined;
+            record.staleEmittedSnapshot = undefined;
+            setTracking(record, {
+                trackedFiles: failure.trackedFiles,
+                trackedResolutions: failure.trackedResolutions,
+            });
+        },
+        setEmitted(identityPath, emitted, snapshot) {
+            let record = getOrCreateMutableRecord(identityPath);
+            record.emitted = emitted;
+            record.emittedSnapshot = snapshot ?? undefined;
+            record.staleEmitted = undefined;
+            record.staleEmittedSnapshot = undefined;
+        },
+        invalidateForFileEvent(filePath, event) {
+            let affected = new Set(recordsByTrackedFile.get(filePath) ?? []);
+            if (event !== 'change') {
+                for (let record of recordsByIdentityPath.values()) {
+                    if (record.trackedResolutions.some((tracked) => mayAffectTrackedResolution(tracked, filePath))) {
+                        affected.add(record.identityPath);
+                    }
+                }
+            }
+            for (let identityPath of affected) {
+                let record = recordsByIdentityPath.get(identityPath);
+                if (record)
+                    invalidateRecord(record, { retainStale: event === 'change' });
+            }
+            if (event === 'unlink') {
+                let deletedRecord = recordsByIdentityPath.get(filePath);
+                if (deletedRecord) {
+                    clearTracking(deletedRecord);
+                }
+            }
+        },
+        invalidateAll() {
+            for (let record of recordsByIdentityPath.values()) {
+                invalidateRecord(record, { retainStale: false });
+            }
+        },
+    };
+    function getOrCreateMutableRecord(identityPath) {
+        let existing = recordsByIdentityPath.get(identityPath);
+        if (existing)
+            return existing;
+        let record = {
+            identityPath,
+            invalidationVersion: 0,
+            trackedFiles: new Set(),
+            trackedResolutions: [],
+        };
+        recordsByIdentityPath.set(identityPath, record);
+        return record;
+    }
+    function invalidateRecord(record, options) {
+        if (!options.retainStale) {
+            record.staleEmitted = undefined;
+            record.staleEmittedSnapshot = undefined;
+        }
+        else if (record.emitted && record.emittedSnapshot) {
+            record.staleEmitted = record.emitted;
+            record.staleEmittedSnapshot = record.emittedSnapshot;
+        }
+        else if (!record.staleEmitted || !record.staleEmittedSnapshot) {
+            record.staleEmitted = undefined;
+            record.staleEmittedSnapshot = undefined;
+        }
+        record.emitted = undefined;
+        record.emittedSnapshot = undefined;
+        record.resolved = undefined;
+        record.transformed = undefined;
+        record.invalidationVersion += 1;
+    }
+    function setTracking(record, tracking) {
+        let previousWatchedDirectories = getWatchedDirectories(record);
+        removeIndexes(record);
+        record.trackedFiles = new Set(tracking.trackedFiles);
+        record.trackedResolutions = [...tracking.trackedResolutions];
+        for (let trackedFile of record.trackedFiles) {
+            addToIndexedSet(recordsByTrackedFile, trackedFile, record.identityPath);
+        }
+        let nextWatchedDirectories = getWatchedDirectories(record);
+        let delta = updateWatchDirectoryRefCounts(previousWatchedDirectories, nextWatchedDirectories);
+        emitWatchDirectoryDelta(delta);
+    }
+    function clearTracking(record) {
+        setTracking(record, {
+            trackedFiles: [],
+            trackedResolutions: [],
+        });
+    }
+    function removeIndexes(record) {
+        for (let trackedFile of record.trackedFiles) {
+            removeFromIndexedSet(recordsByTrackedFile, trackedFile, record.identityPath);
+        }
+    }
+    function updateWatchDirectoryRefCounts(previousWatchedDirectories, nextWatchedDirectories) {
+        let add = [];
+        let remove = [];
+        for (let directory of previousWatchedDirectories) {
+            if (nextWatchedDirectories.has(directory))
+                continue;
+            let previousCount = watchDirectoryRefCountByPath.get(directory);
+            if (!previousCount)
+                continue;
+            if (previousCount === 1) {
+                watchDirectoryRefCountByPath.delete(directory);
+                remove.push(directory);
+            }
+            else {
+                watchDirectoryRefCountByPath.set(directory, previousCount - 1);
+            }
+        }
+        for (let directory of nextWatchedDirectories) {
+            if (previousWatchedDirectories.has(directory))
+                continue;
+            let previousCount = watchDirectoryRefCountByPath.get(directory) ?? 0;
+            watchDirectoryRefCountByPath.set(directory, previousCount + 1);
+            if (previousCount === 0) {
+                add.push(directory);
+            }
+        }
+        return { add, remove };
+    }
+    function emitWatchDirectoryDelta(delta) {
+        if (!options.onWatchDirectoriesChange)
+            return;
+        if (delta.add.length === 0 && delta.remove.length === 0)
+            return;
+        options.onWatchDirectoriesChange(delta);
+    }
+}
+function addToIndexedSet(map, key, value) {
+    let existing = map.get(key) ?? new Set();
+    existing.add(value);
+    map.set(key, existing);
+}
+function removeFromIndexedSet(map, key, value) {
+    let existing = map.get(key);
+    if (!existing)
+        return;
+    existing.delete(value);
+    if (existing.size === 0) {
+        map.delete(key);
+    }
+}
+function mayAffectTrackedResolution(trackedResolution, filePath) {
+    return (trackedResolution.candidatePaths.includes(filePath) ||
+        trackedResolution.candidatePrefixes.some((prefix) => filePath.startsWith(prefix)));
+}
+function getWatchedDirectories(record) {
+    let watchedDirectories = new Set();
+    for (let trackedFile of record.trackedFiles) {
+        watchedDirectories.add(getFilePathDirectory(trackedFile));
+    }
+    for (let trackedResolution of record.trackedResolutions) {
+        for (let candidatePath of trackedResolution.candidatePaths) {
+            watchedDirectories.add(getFilePathDirectory(candidatePath));
+        }
+        for (let candidatePrefix of trackedResolution.candidatePrefixes) {
+            let directoryPath = candidatePrefix.replace(/\/+$/, '') || '/';
+            watchedDirectories.add(directoryPath);
+        }
+    }
+    return watchedDirectories;
+}

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

@@ -0,0 +1,62 @@
+import type { TsConfigJsonResolved } from 'get-tsconfig';
+import type { AssetServerCompilationError } from '../compilation-error.ts';
+import type { CompiledRoutes } from '../routes.ts';
+import type { ScriptsTarget } from '../asset-server.ts';
+import type { ModuleRecord } from './store.ts';
+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[];
+};
+export type TransformFailureState = {
+    trackedFiles: readonly string[];
+};
+type TransformResult = {
+    ok: true;
+    value: TransformedModule;
+} | ({
+    ok: false;
+    error: AssetServerCompilationError;
+} & TransformFailureState);
+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: ScriptsTarget | null;
+    tsconfigTransformOptionsResolver: TsconfigTransformOptionsResolver;
+};
+export declare function createTsconfigTransformOptionsResolver(): {
+    clear(): void;
+    getTransformOptions(filePath: string, isWatchIgnored: (filePath: string) => boolean): TsconfigTransformOptions;
+};
+export declare function transformModule(record: ModuleRecord, 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;AAG1E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAClD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AA6B9C,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,MAAM,MAAM,qBAAqB,GAAG;IAClC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAA;CAChC,CAAA;AAED,KAAK,eAAe,GAChB;IACE,EAAE,EAAE,IAAI,CAAA;IACR,KAAK,EAAE,iBAAiB,CAAA;CACzB,GACD,CAAC;IACC,EAAE,EAAE,KAAK,CAAA;IACT,KAAK,EAAE,2BAA2B,CAAA;CACnC,GAAG,qBAAqB,CAAC,CAAA;AAE9B,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,aAAa,GAAG,IAAI,CAAA;IAC5B,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,CAiH1B"}