@remix-run/assets 0.0.0 → 0.1.0

package/dist/lib/asset-server.js

@@ -0,0 +1,242 @@
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { isAssetServerCompilationError } from "./compilation-error.js";
+import { createAccessPolicy } from "./access.js";
+import { createModuleCompiler, createResponseForModule } from "./scripts/compiler.js";
+import { normalizeFilePath } from "./paths.js";
+import { compileRoutes } from "./routes.js";
+import { createAssetServerWatcher } from "./watch.js";
+const scriptTargets = [
+    'es2015',
+    'es2016',
+    'es2017',
+    'es2018',
+    'es2019',
+    'es2020',
+    'es2021',
+    'es2022',
+    'es2023',
+    'es2024',
+    'es2025',
+    'es2026',
+    'esnext',
+];
+const scriptTargetSet = new Set(scriptTargets);
+const chokidarWatcherByAssetServer = new WeakMap();
+const watcherByAssetServer = new WeakMap();
+export function getInternalChokidarWatcher(assetServer) {
+    return chokidarWatcherByAssetServer.get(assetServer);
+}
+export function getInternalWatchTargets(assetServer) {
+    return watcherByAssetServer.get(assetServer)?.getWatchedTargets() ?? [];
+}
+/**
+ * Create an asset server instance
+ *
+ * Compiles TypeScript/JavaScript modules on demand with optional source-based URL
+ * fingerprinting, caching, and configurable file mapping.
+ *
+ * @param options Server configuration
+ * @returns A {@link AssetServer} with `fetch()`, `getHref()`, and `getPreloads()` methods
+ *
+ * @example
+ * ```ts
+ * let assetServer = createAssetServer({
+ *   fileMap: {
+ *     '/assets/app/*path': 'app/*path',
+ *   },
+ *   allow: ['app/**'],
+ * })
+ *
+ * route('/assets/*path', ({ request }) => assetServer.fetch(request))
+ * ```
+ */
+export function createAssetServer(options) {
+    let resolvedOptions = resolveAssetServerOptions(options);
+    let accessPolicy = createAccessPolicy({
+        allow: resolvedOptions.allow,
+        deny: resolvedOptions.deny,
+        rootDir: resolvedOptions.rootDir,
+    });
+    let watcher = null;
+    let chokidarWatcher = null;
+    let moduleCompiler = createModuleCompiler({
+        buildId: resolvedOptions.buildId,
+        define: resolvedOptions.define,
+        external: resolvedOptions.external,
+        fingerprintModules: resolvedOptions.fingerprintModules,
+        isAllowed: accessPolicy.isAllowed,
+        minify: resolvedOptions.minify,
+        onWatchDirectoriesChange: (delta) => {
+            if (!watcher)
+                return;
+            watcher.updateWatchedDirectories(delta);
+        },
+        rootDir: resolvedOptions.rootDir,
+        routes: resolvedOptions.routes,
+        sourceMapSourcePaths: resolvedOptions.sourceMapSourcePaths,
+        sourceMaps: resolvedOptions.sourceMaps,
+        target: resolvedOptions.scriptsTarget,
+        watchIgnore: resolvedOptions.watchOptions?.ignore,
+        watchMode: resolvedOptions.watchOptions !== null,
+    });
+    if (resolvedOptions.watchOptions) {
+        watcher = createAssetServerWatcher({
+            ...resolvedOptions.watchOptions,
+            onChokidarWatcherCreated(createdWatcher) {
+                chokidarWatcher = createdWatcher;
+            },
+            onFileEvent: handleWatchEvent,
+            rootDir: resolvedOptions.rootDir,
+        });
+    }
+    async function responseForError(error) {
+        try {
+            return (await resolvedOptions.onError(error)) ?? internalServerError();
+        }
+        catch (error) {
+            console.error(`There was an error in the asset server error handler: ${error}`);
+            return internalServerError();
+        }
+    }
+    async function handleWatchEvent(filePath, event) {
+        try {
+            let normalizedFilePath = normalizeFilePath(filePath);
+            await moduleCompiler.handleFileEvent(normalizedFilePath, event);
+        }
+        catch (error) {
+            console.error(`There was an error invalidating the asset server cache: ${error}`);
+        }
+    }
+    let assetServer = {
+        async fetch(request) {
+            if (request.method !== 'GET' && request.method !== 'HEAD')
+                return null;
+            let parsedRequestPathname = moduleCompiler.parseRequestPathname(new URL(request.url).pathname);
+            if (!parsedRequestPathname)
+                return null;
+            try {
+                let ifNoneMatch = request.headers.get('If-None-Match');
+                let moduleResult = await moduleCompiler.getModule(parsedRequestPathname.filePath, {
+                    ifNoneMatch,
+                    isSourceMapRequest: parsedRequestPathname.isSourceMapRequest,
+                    requestedFingerprint: parsedRequestPathname.requestedFingerprint,
+                });
+                if (moduleResult.type === 'not-modified') {
+                    return new Response(null, {
+                        status: 304,
+                        headers: { ETag: moduleResult.etag },
+                    });
+                }
+                let compiledModule = moduleResult.module;
+                if (parsedRequestPathname.requestedFingerprint !== null) {
+                    if (compiledModule.fingerprint !== parsedRequestPathname.requestedFingerprint)
+                        return null;
+                }
+                return createResponseForModule(compiledModule, {
+                    cacheControl: parsedRequestPathname.cacheControl,
+                    ifNoneMatch,
+                    isSourceMapRequest: parsedRequestPathname.isSourceMapRequest,
+                    method: request.method,
+                });
+            }
+            catch (error) {
+                // A direct request can race with the filesystem or fail a deeper allow check while
+                // compiling imports. In this fetch context, both cases should fall through as "not
+                // handled here" so the outer router can continue to its own 404 behavior.
+                if (isAssetServerCompilationError(error) &&
+                    (error.code === 'MODULE_NOT_FOUND' || error.code === 'MODULE_NOT_ALLOWED')) {
+                    return null;
+                }
+                return responseForError(error);
+            }
+        },
+        async getHref(filePath) {
+            return moduleCompiler.getHref(filePath);
+        },
+        async getPreloads(filePath) {
+            return moduleCompiler.getPreloadUrls(filePath);
+        },
+        async close() {
+            await watcher?.close();
+        },
+    };
+    if (chokidarWatcher) {
+        chokidarWatcherByAssetServer.set(assetServer, chokidarWatcher);
+    }
+    if (watcher) {
+        watcherByAssetServer.set(assetServer, watcher);
+    }
+    return assetServer;
+}
+function internalServerError() {
+    return new Response('Internal Server Error', {
+        status: 500,
+        headers: { 'Content-Type': 'text/plain; charset=utf-8' },
+    });
+}
+function defaultErrorHandler(error) {
+    console.error(error);
+}
+function resolveAssetServerOptions(options) {
+    let rootDir = normalizeFilePath(fs.realpathSync(path.resolve(options.rootDir ?? process.cwd())));
+    let scriptOptions = options.scripts ?? {};
+    let fingerprintOptions = normalizeFingerprintOptions({
+        fingerprint: options.fingerprint,
+        watch: options.watch,
+    });
+    return {
+        allow: options.allow,
+        buildId: fingerprintOptions.buildId,
+        define: scriptOptions.define,
+        deny: options.deny,
+        external: scriptOptions.external ?? [],
+        fingerprintModules: fingerprintOptions.enabled,
+        minify: scriptOptions.minify ?? false,
+        onError: options.onError ?? defaultErrorHandler,
+        rootDir,
+        routes: compileRoutes({
+            fileMap: options.fileMap,
+            rootDir,
+        }),
+        sourceMapSourcePaths: scriptOptions.sourceMapSourcePaths ?? 'url',
+        sourceMaps: scriptOptions.sourceMaps,
+        scriptsTarget: normalizeTarget(scriptOptions.target),
+        watchOptions: normalizeWatchOptions(options.watch),
+    };
+}
+function normalizeTarget(target) {
+    if (target == null)
+        return undefined;
+    if (typeof target !== 'string' || !scriptTargetSet.has(target)) {
+        throw new TypeError(`Expected target to be one of ${scriptTargets.map((value) => `"${value}"`).join(', ')}. Received "${target}".`);
+    }
+    return target;
+}
+function normalizeFingerprintOptions(options) {
+    if (!options.fingerprint) {
+        return {
+            enabled: false,
+        };
+    }
+    if (typeof options.fingerprint.buildId !== 'string') {
+        throw new TypeError('fingerprint.buildId must be a string');
+    }
+    if (options.fingerprint.buildId.length === 0) {
+        throw new TypeError('fingerprint.buildId must be a non-empty string');
+    }
+    if (options.watch !== false) {
+        throw new TypeError('fingerprint cannot be used with watch mode');
+    }
+    return {
+        enabled: true,
+        buildId: options.fingerprint.buildId,
+    };
+}
+function normalizeWatchOptions(options) {
+    if (options === false)
+        return null;
+    if (options == null || options === true)
+        return {};
+    return options;
+}

package/dist/lib/compilation-error.d.ts

@@ -0,0 +1,33 @@
+type AssetServerCompilationErrorCode = 'MODULE_NOT_FOUND' | 'MODULE_NOT_ALLOWED' | 'MODULE_OUTSIDE_FILE_MAP' | 'MODULE_COMMONJS_NOT_SUPPORTED' | 'MODULE_TRANSFORM_FAILED' | 'MODULE_EMIT_FAILED' | 'IMPORT_RESOLUTION_FAILED' | 'IMPORT_NOT_SUPPORTED' | 'IMPORT_NOT_ALLOWED' | 'IMPORT_OUTSIDE_FILE_MAP';
+/**
+ * Internal error used by the request-time module compilation pipeline.
+ */
+export declare class AssetServerCompilationError extends Error {
+    code: AssetServerCompilationErrorCode;
+    constructor(message: string, options: {
+        cause?: unknown;
+        code: AssetServerCompilationErrorCode;
+    });
+}
+/**
+ * Returns true when a value is an `AssetServerCompilationError`.
+ *
+ * @param error Value thrown by the compilation pipeline.
+ * @returns Whether the value is an `AssetServerCompilationError`.
+ */
+export declare function isAssetServerCompilationError(error: unknown): error is AssetServerCompilationError;
+/**
+ * Creates an `AssetServerCompilationError` with a stable internal code.
+ *
+ * @param message Human-readable error message.
+ * @param options Structured internal error details.
+ * @param options.cause Original error cause, when available.
+ * @param options.code Stable internal compilation error code.
+ * @returns A `AssetServerCompilationError`.
+ */
+export declare function createAssetServerCompilationError(message: string, options: {
+    cause?: unknown;
+    code: AssetServerCompilationErrorCode;
+}): AssetServerCompilationError;
+export {};
+//# sourceMappingURL=compilation-error.d.ts.map

package/dist/lib/compilation-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compilation-error.d.ts","sourceRoot":"","sources":["../../src/lib/compilation-error.ts"],"names":[],"mappings":"AAAA,KAAK,+BAA+B,GAChC,kBAAkB,GAClB,oBAAoB,GACpB,yBAAyB,GACzB,+BAA+B,GAC/B,yBAAyB,GACzB,oBAAoB,GACpB,0BAA0B,GAC1B,sBAAsB,GACtB,oBAAoB,GACpB,yBAAyB,CAAA;AAE7B;;GAEG;AACH,qBAAa,2BAA4B,SAAQ,KAAK;IACpD,IAAI,EAAE,+BAA+B,CAAA;IAErC,YACE,OAAO,EAAE,MAAM,EACf,OAAO,EAAE;QACP,KAAK,CAAC,EAAE,OAAO,CAAA;QACf,IAAI,EAAE,+BAA+B,CAAA;KACtC,EAKF;CACF;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,2BAA2B,CAEtC;AAED;;;;;;;;GAQG;AACH,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,MAAM,EACf,OAAO,EAAE;IACP,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,IAAI,EAAE,+BAA+B,CAAA;CACtC,GACA,2BAA2B,CAE7B"}

package/dist/lib/compilation-error.js

@@ -0,0 +1,32 @@
+/**
+ * Internal error used by the request-time module compilation pipeline.
+ */
+export class AssetServerCompilationError extends Error {
+    code;
+    constructor(message, options) {
+        super(message, options.cause === undefined ? undefined : { cause: options.cause });
+        this.name = 'AssetServerCompilationError';
+        this.code = options.code;
+    }
+}
+/**
+ * Returns true when a value is an `AssetServerCompilationError`.
+ *
+ * @param error Value thrown by the compilation pipeline.
+ * @returns Whether the value is an `AssetServerCompilationError`.
+ */
+export function isAssetServerCompilationError(error) {
+    return error instanceof AssetServerCompilationError;
+}
+/**
+ * Creates an `AssetServerCompilationError` with a stable internal code.
+ *
+ * @param message Human-readable error message.
+ * @param options Structured internal error details.
+ * @param options.cause Original error cause, when available.
+ * @param options.code Stable internal compilation error code.
+ * @returns A `AssetServerCompilationError`.
+ */
+export function createAssetServerCompilationError(message, options) {
+    return new AssetServerCompilationError(message, options);
+}

package/dist/lib/file-matcher.d.ts

@@ -0,0 +1,6 @@
+export type FileMatcher = (filePath: string) => boolean;
+export declare function createFileMatcher(pattern: string, rootDir: string, options?: {
+    allowDirectories?: boolean;
+    allowMissing?: boolean;
+}): FileMatcher;
+//# sourceMappingURL=file-matcher.d.ts.map

package/dist/lib/file-matcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-matcher.d.ts","sourceRoot":"","sources":["../../src/lib/file-matcher.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,WAAW,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAA;AAEvD,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;IACP,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,YAAY,CAAC,EAAE,OAAO,CAAA;CAClB,GACL,WAAW,CA0Bb"}

package/dist/lib/file-matcher.js

@@ -0,0 +1,43 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { normalizeFilePath, resolveFilePath } from "./paths.js";
+export function createFileMatcher(pattern, rootDir, options = {}) {
+    let resolvedPatternPath = resolveFilePath(rootDir, pattern);
+    let allowDirectories = options.allowDirectories ?? true;
+    let allowMissing = options.allowMissing ?? true;
+    if (!containsGlobSyntax(pattern)) {
+        try {
+            resolvedPatternPath = normalizeFilePath(fs.realpathSync(resolvedPatternPath));
+        }
+        catch (error) {
+            if (!allowMissing || !isPathNotFoundError(error))
+                throw error;
+        }
+        if (allowDirectories) {
+            try {
+                if (fs.statSync(resolveFilePath(rootDir, pattern)).isDirectory()) {
+                    return (filePath) => isSameOrDescendantPath(filePath, resolvedPatternPath);
+                }
+            }
+            catch (error) {
+                if (!isPathNotFoundError(error))
+                    throw error;
+            }
+        }
+        return (filePath) => filePath === resolvedPatternPath;
+    }
+    return (filePath) => path.posix.matchesGlob(filePath, resolvedPatternPath);
+}
+function isSameOrDescendantPath(filePath, directoryPath) {
+    let normalizedDirectoryPath = directoryPath.replace(/\/+$/, '');
+    return filePath === normalizedDirectoryPath || filePath.startsWith(`${normalizedDirectoryPath}/`);
+}
+function containsGlobSyntax(pattern) {
+    return /[*?[\]{}()!+@]/.test(pattern);
+}
+function isPathNotFoundError(error) {
+    return (error instanceof Error &&
+        'code' in error &&
+        (error.code === 'ENOENT' ||
+            error.code === 'ENOTDIR'));
+}

package/dist/lib/fingerprint.d.ts

@@ -0,0 +1,12 @@
+export declare function hashContent(content: string): Promise<string>;
+export declare function generateFingerprint(options: {
+    buildId: string;
+    content: string;
+}): Promise<string>;
+export declare function parseFingerprintSuffix(pathname: string): {
+    pathname: string;
+    requestedFingerprint: string | null;
+};
+export declare function formatFingerprintedPathname(pathname: string, fingerprint: string | null): string;
+export declare function getFingerprintRequestCacheControl(requestedFingerprint: string | null): string;
+//# sourceMappingURL=fingerprint.d.ts.map

package/dist/lib/fingerprint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fingerprint.d.ts","sourceRoot":"","sources":["../../src/lib/fingerprint.ts"],"names":[],"mappings":"AAGA,wBAAsB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAKlE;AAED,wBAAsB,mBAAmB,CAAC,OAAO,EAAE;IACjD,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;CAChB,GAAG,OAAO,CAAC,MAAM,CAAC,CAElB;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG;IACxD,QAAQ,EAAE,MAAM,CAAA;IAChB,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAA;CACpC,CAyBA;AAED,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAahG;AAED,wBAAgB,iCAAiC,CAAC,oBAAoB,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAE7F"}

package/dist/lib/fingerprint.js

@@ -0,0 +1,49 @@
+const fingerprintedExtensionRE = /^(.+)\.@([A-Za-z0-9_-]+)(\.[^./]+)$/;
+const fingerprintedBasenameRE = /^(.+)\.@([A-Za-z0-9_-]+)$/;
+export async function hashContent(content) {
+    let encoder = new TextEncoder();
+    let data = encoder.encode(content);
+    let hashBuffer = await crypto.subtle.digest('SHA-256', data);
+    return Buffer.from(hashBuffer).toString('base64url').slice(0, 6);
+}
+export async function generateFingerprint(options) {
+    return hashContent(JSON.stringify([options.content, options.buildId]));
+}
+export function parseFingerprintSuffix(pathname) {
+    let lastSlashIndex = pathname.lastIndexOf('/');
+    let directory = lastSlashIndex >= 0 ? pathname.slice(0, lastSlashIndex + 1) : '';
+    let basename = lastSlashIndex >= 0 ? pathname.slice(lastSlashIndex + 1) : pathname;
+    let extensionMatch = basename.match(fingerprintedExtensionRE);
+    if (extensionMatch) {
+        return {
+            pathname: `${directory}${extensionMatch[1]}${extensionMatch[3]}`,
+            requestedFingerprint: extensionMatch[2],
+        };
+    }
+    let basenameMatch = basename.match(fingerprintedBasenameRE);
+    if (basenameMatch) {
+        return {
+            pathname: `${directory}${basenameMatch[1]}`,
+            requestedFingerprint: basenameMatch[2],
+        };
+    }
+    return {
+        pathname,
+        requestedFingerprint: null,
+    };
+}
+export function formatFingerprintedPathname(pathname, fingerprint) {
+    if (fingerprint === null)
+        return pathname;
+    let lastSlashIndex = pathname.lastIndexOf('/');
+    let directory = lastSlashIndex >= 0 ? pathname.slice(0, lastSlashIndex + 1) : '';
+    let basename = lastSlashIndex >= 0 ? pathname.slice(lastSlashIndex + 1) : pathname;
+    let lastDotIndex = basename.lastIndexOf('.');
+    if (lastDotIndex <= 0) {
+        return `${pathname}.@${fingerprint}`;
+    }
+    return `${directory}${basename.slice(0, lastDotIndex)}.@${fingerprint}${basename.slice(lastDotIndex)}`;
+}
+export function getFingerprintRequestCacheControl(requestedFingerprint) {
+    return requestedFingerprint === null ? 'no-cache' : 'public, max-age=31536000, immutable';
+}

package/dist/lib/paths.d.ts

@@ -0,0 +1,8 @@
+export declare function normalizeWindowsPath(filePath: string): string;
+export declare function normalizePathname(pathname: string): string;
+export declare function isAbsoluteFilePath(filePath: string): boolean;
+export declare function normalizeFilePath(filePath: string): string;
+export declare function resolveFilePath(rootDir: string, filePath: string): string;
+export declare function getFilePathDirectory(filePath: string): string;
+export declare function getFilePathBaseName(filePath: string): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/lib/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../src/lib/paths.ts"],"names":[],"mappings":"AAKA,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAI7D;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAQ1D;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAG5D;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAmB1D;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAMzE;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE5D"}

package/dist/lib/paths.js

@@ -0,0 +1,50 @@
+import * as path from 'node:path';
+const windowsDriveLetterRE = /^[A-Za-z]:\//;
+const uncPrefixRE = /^\/\/[^/]+\/[^/]+/;
+export function normalizeWindowsPath(filePath) {
+    return filePath
+        .replace(/\\/g, '/')
+        .replace(windowsDriveLetterRE, (prefix) => `${prefix[0].toUpperCase()}${prefix.slice(1)}`);
+}
+export function normalizePathname(pathname) {
+    let normalized = path.posix.normalize(normalizeWindowsPath(pathname));
+    if (!normalized.startsWith('/')) {
+        normalized = `/${normalized}`;
+    }
+    return normalized;
+}
+export function isAbsoluteFilePath(filePath) {
+    let normalized = normalizeWindowsPath(filePath);
+    return normalized.startsWith('/') || windowsDriveLetterRE.test(normalized);
+}
+export function normalizeFilePath(filePath) {
+    let normalized = normalizeWindowsPath(filePath);
+    let uncRoot = getUncRoot(normalized);
+    if (uncRoot) {
+        let remainder = normalized.slice(uncRoot.length);
+        let normalizedRemainder = path.posix.normalize(remainder || '/');
+        return `${uncRoot}${normalizedRemainder === '/' ? '' : normalizedRemainder}`;
+    }
+    if (windowsDriveLetterRE.test(normalized)) {
+        return path.posix.normalize(normalized);
+    }
+    if (normalized.startsWith('/')) {
+        return path.posix.normalize(normalized);
+    }
+    return path.posix.normalize(normalizeWindowsPath(path.resolve(normalized)));
+}
+export function resolveFilePath(rootDir, filePath) {
+    if (isAbsoluteFilePath(filePath)) {
+        return normalizeFilePath(filePath);
+    }
+    return normalizeFilePath(`${rootDir.replace(/\/+$/, '')}/${normalizeWindowsPath(filePath)}`);
+}
+export function getFilePathDirectory(filePath) {
+    return path.posix.dirname(normalizeWindowsPath(filePath));
+}
+export function getFilePathBaseName(filePath) {
+    return path.posix.basename(normalizeWindowsPath(filePath));
+}
+function getUncRoot(filePath) {
+    return filePath.startsWith('//') ? (filePath.match(uncPrefixRE)?.[0] ?? null) : null;
+}

package/dist/lib/routes.d.ts

@@ -0,0 +1,13 @@
+export interface AssetRouteDefinition {
+    urlPattern: string;
+    filePattern: string;
+}
+export interface CompiledRoutes {
+    resolveUrlPathname(pathname: string): string | null;
+    toUrlPathname(filePath: string): string | null;
+}
+export declare function compileRoutes(options: {
+    fileMap: Readonly<Record<string, string>>;
+    rootDir: string;
+}): CompiledRoutes;
+//# sourceMappingURL=routes.d.ts.map

package/dist/lib/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/lib/routes.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,oBAAoB;IACnC,UAAU,EAAE,MAAM,CAAA;IAClB,WAAW,EAAE,MAAM,CAAA;CACpB;AAQD,MAAM,WAAW,cAAc;IAC7B,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;IACnD,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;CAC/C;AAYD,wBAAgB,aAAa,CAAC,OAAO,EAAE;IACrC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IACzC,OAAO,EAAE,MAAM,CAAA;CAChB,GAAG,cAAc,CA0CjB"}

package/dist/lib/routes.js

@@ -0,0 +1,94 @@
+import * as path from 'node:path';
+import { RoutePattern } from '@remix-run/route-pattern';
+import { isAbsoluteFilePath, normalizeFilePath, normalizePathname, resolveFilePath, } from "./paths.js";
+function normalizeFilePattern(pattern) {
+    if (isAbsoluteFilePath(pattern)) {
+        throw new Error(`File route patterns must be relative to the asset server root.\nPattern: ${pattern}`);
+    }
+    return normalizePathname(pattern);
+}
+export function compileRoutes(options) {
+    if (Object.keys(options.fileMap).length === 0) {
+        throw new Error('createAssetServer() requires at least one configured fileMap entry.');
+    }
+    let compiledRoutes = Object.entries(options.fileMap).map(([urlPattern, filePattern]) => compileRoute({
+        urlPattern,
+        filePattern,
+    }, { rootDir: options.rootDir }));
+    return {
+        resolveUrlPathname(pathname) {
+            let normalizedPathname = normalizePathname(pathname);
+            for (let route of compiledRoutes) {
+                let match = route.urlPattern.match(`http://remix.run${normalizedPathname}`);
+                if (!match)
+                    continue;
+                let relativeFilePath = route.filePattern.href(match.params).replace(/^\/+/, '');
+                return resolveFilePath(route.rootDir, relativeFilePath);
+            }
+            return null;
+        },
+        toUrlPathname(filePath) {
+            let normalizedFilePath = normalizeFilePath(filePath);
+            for (let route of compiledRoutes) {
+                let relativeFilePath = getRelativeFilePath(normalizedFilePath, route.rootDir);
+                if (relativeFilePath === null)
+                    continue;
+                let match = route.filePattern.ast.pathname.match(relativeFilePath);
+                if (!match)
+                    continue;
+                return normalizePathname(route.urlPattern.href(getPathnameParams(route.filePattern, match)));
+            }
+            return null;
+        },
+    };
+}
+function compileRoute(route, options) {
+    let urlPatternSource = normalizePathname(route.urlPattern);
+    let filePatternSource = normalizeFilePattern(route.filePattern);
+    let urlPattern = new RoutePattern(urlPatternSource);
+    let filePattern = new RoutePattern(filePatternSource);
+    validateNoUnnamedWildcards(urlPattern, 'URL');
+    validateNoUnnamedWildcards(filePattern, 'File');
+    validateRoutePatterns(urlPattern, filePattern);
+    return {
+        rootDir: normalizeFilePath(options.rootDir).replace(/\/+$/, ''),
+        urlPattern,
+        filePattern,
+    };
+}
+function getRelativeFilePath(filePath, rootDir) {
+    if (filePath[1] === ':' && rootDir[1] === ':' && filePath[0] !== rootDir[0])
+        return null;
+    return path.posix.relative(rootDir, filePath);
+}
+function getPathnameParams(pattern, match) {
+    let params = {};
+    for (let param of pattern.ast.pathname.params) {
+        if (param.name === '*')
+            continue;
+        params[param.name] = undefined;
+    }
+    for (let param of match) {
+        if (param.name === '*')
+            continue;
+        params[param.name] = param.value;
+    }
+    return params;
+}
+function validateRoutePatterns(urlPattern, filePattern) {
+    let urlParams = urlPattern.ast.pathname.params.map((param) => `${param.type}:${param.name}`);
+    let fileParams = filePattern.ast.pathname.params.map((param) => `${param.type}:${param.name}`);
+    if (urlParams.length !== fileParams.length) {
+        throw new Error(`Route patterns must have matching capture structure.\nURL: ${urlPattern}\nFile: ${filePattern}`);
+    }
+    for (let i = 0; i < urlParams.length; i++) {
+        if (urlParams[i] !== fileParams[i]) {
+            throw new Error(`Route patterns must have matching capture structure.\nURL: ${urlPattern}\nFile: ${filePattern}`);
+        }
+    }
+}
+function validateNoUnnamedWildcards(pattern, label) {
+    if (pattern.ast.pathname.params.some((param) => param.type === '*' && param.name === '*')) {
+        throw new Error(`${label} route patterns must use named wildcards for reversible mapping.\nPattern: ${pattern}`);
+    }
+}

package/dist/lib/scripts/cjs-check.d.ts

@@ -0,0 +1,3 @@
+export declare function mayContainCommonJSModuleGlobals(source: string): boolean;
+export declare function isCommonJS(source: string): boolean;
+//# sourceMappingURL=cjs-check.d.ts.map

package/dist/lib/scripts/cjs-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cjs-check.d.ts","sourceRoot":"","sources":["../../../src/lib/scripts/cjs-check.ts"],"names":[],"mappings":"AAoBA,wBAAgB,+BAA+B,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEvE;AAGD,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAalD"}