@remix-run/assets 0.2.0 → 0.4.0

package/dist/lib/files/config.js

@@ -0,0 +1,219 @@
+import { supportedScriptExtensions } from "../scripts/resolve.js";
+export function defineFileTransform(transform) {
+    return transform;
+}
+const reservedFileExtensions = new Set([...supportedScriptExtensions, '.css', '.map']);
+const defaultMaxRequestTransforms = 5;
+export function normalizeFilesOptions(files) {
+    if (files == null) {
+        return {
+            extensions: [],
+            globalTransforms: [],
+            hasTransforms: false,
+            maxRequestTransforms: defaultMaxRequestTransforms,
+            transforms: new Map(),
+        };
+    }
+    if (!Array.isArray(files.extensions)) {
+        throw new TypeError('files.extensions must be an array');
+    }
+    let normalizedExtensions = [];
+    let seen = new Set();
+    for (let extension of files.extensions) {
+        if (typeof extension !== 'string') {
+            throw new TypeError('files.extensions values must be strings');
+        }
+        let normalizedExtension = extension.trim().toLowerCase();
+        if (!/^\.[A-Za-z0-9_-]+$/.test(normalizedExtension)) {
+            throw new TypeError(`files.extensions values must use ".ext" format. Received "${extension}".`);
+        }
+        if (reservedFileExtensions.has(normalizedExtension)) {
+            throw new TypeError(`files.extensions cannot include compiled asset extensions like "${normalizedExtension}".`);
+        }
+        if (seen.has(normalizedExtension))
+            continue;
+        seen.add(normalizedExtension);
+        normalizedExtensions.push(normalizedExtension);
+    }
+    let transforms = files.transforms ?? {};
+    if (transforms === null || typeof transforms !== 'object' || Array.isArray(transforms)) {
+        throw new TypeError('files.transforms must be an object');
+    }
+    let normalizedTransforms = new Map();
+    for (let [name, transform] of Object.entries(transforms)) {
+        if (!/^[A-Za-z0-9_-]+$/.test(name)) {
+            throw new TypeError(`files.transforms keys must use "transform-name" format. Received "${name}".`);
+        }
+        if (transform === null ||
+            typeof transform !== 'object' ||
+            typeof transform.transform !== 'function') {
+            throw new TypeError(`files.transforms.${name} must define a transform() function`);
+        }
+        if ('param' in transform &&
+            transform.param !== undefined &&
+            transform.param !== true &&
+            transform.param !== 'optional') {
+            throw new TypeError(`files.transforms.${name}.param must be true or "optional"`);
+        }
+        normalizedTransforms.set(name, {
+            ...transform,
+            extensions: normalizeTransformExtensions(transform.extensions, `files.transforms.${name}.extensions`),
+        });
+    }
+    let globalTransforms = files.globalTransforms ?? [];
+    if (!Array.isArray(globalTransforms)) {
+        throw new TypeError('files.globalTransforms must be an array');
+    }
+    let normalizedGlobalTransforms = [];
+    for (let [index, transform] of globalTransforms.entries()) {
+        if (typeof transform === 'function') {
+            normalizedGlobalTransforms.push({ transform });
+            continue;
+        }
+        if (transform === null || typeof transform !== 'object') {
+            throw new TypeError(`files.globalTransforms[${index}] must be a function or object`);
+        }
+        if ('name' in transform && transform.name !== undefined && typeof transform.name !== 'string') {
+            throw new TypeError(`files.globalTransforms[${index}].name must be a string`);
+        }
+        if (typeof transform.transform !== 'function') {
+            throw new TypeError(`files.globalTransforms[${index}] must define a transform() function`);
+        }
+        normalizedGlobalTransforms.push({
+            ...transform,
+            extensions: normalizeTransformExtensions(transform.extensions, `files.globalTransforms[${index}].extensions`),
+        });
+    }
+    let maxRequestTransforms = files.maxRequestTransforms ?? defaultMaxRequestTransforms;
+    if (!Number.isInteger(maxRequestTransforms) || maxRequestTransforms < 1) {
+        throw new TypeError('files.maxRequestTransforms must be a positive integer');
+    }
+    if (files.cache !== undefined) {
+        if (files.cache === null ||
+            typeof files.cache !== 'object' ||
+            typeof files.cache.get !== 'function' ||
+            typeof files.cache.set !== 'function') {
+            throw new TypeError('files.cache must implement the FileStorage interface');
+        }
+    }
+    return {
+        cache: files.cache,
+        extensions: normalizedExtensions,
+        globalTransforms: normalizedGlobalTransforms,
+        hasTransforms: normalizedTransforms.size > 0 || normalizedGlobalTransforms.length > 0,
+        maxRequestTransforms,
+        transforms: normalizedTransforms,
+    };
+}
+function normalizeTransformExtensions(extensions, optionPath) {
+    if (extensions === undefined)
+        return undefined;
+    if (!Array.isArray(extensions)) {
+        throw new TypeError(`${optionPath} must be an array`);
+    }
+    if (extensions.length === 0) {
+        throw new TypeError(`${optionPath} must include at least one extension`);
+    }
+    let normalizedExtensions = [];
+    let seen = new Set();
+    for (let extension of extensions) {
+        if (typeof extension !== 'string') {
+            throw new TypeError(`${optionPath} values must be strings`);
+        }
+        let normalizedExtension = extension.trim().toLowerCase();
+        if (!/^\.[A-Za-z0-9_-]+$/.test(normalizedExtension)) {
+            throw new TypeError(`${optionPath} values must use ".ext" format. Received "${extension}".`);
+        }
+        if (seen.has(normalizedExtension))
+            continue;
+        seen.add(normalizedExtension);
+        normalizedExtensions.push(normalizedExtension);
+    }
+    return normalizedExtensions;
+}
+export function serializeAssetTransformInvocations(transforms, transformsByName, maxTransforms = defaultMaxRequestTransforms) {
+    if (transforms.length > maxTransforms) {
+        throw new TypeError(`Expected at most ${maxTransforms} request transforms`);
+    }
+    return transforms.map((transformInvocation) => normalizeAssetTransformInvocation(transformInvocation, transformsByName, (message) => {
+        throw new TypeError(message);
+    }));
+}
+export function parseAssetTransformInvocations(transformsQuery, transformsByName, maxTransforms = defaultMaxRequestTransforms) {
+    if (transformsQuery.length > maxTransforms) {
+        throw new TypeError(`Expected at most ${maxTransforms} request transforms`);
+    }
+    return transformsQuery.map((transformQuery) => parseSerializedAssetTransformInvocation(transformQuery, transformsByName, (message) => {
+        throw new TypeError(message);
+    }));
+}
+function normalizeAssetTransformInvocation(transformInvocation, transformsByName, onError) {
+    if (typeof transformInvocation === 'string') {
+        if (!/^[A-Za-z0-9_-]+$/.test(transformInvocation)) {
+            return onError('Expected each transform name to use "transform-name" format');
+        }
+        let transform = transformsByName.get(transformInvocation);
+        if (transform === undefined) {
+            return onError(`Unknown file transform "${transformInvocation}"`);
+        }
+        if (transform.param === true) {
+            return onError(`File transform "${transformInvocation}" requires a param`);
+        }
+        return transformInvocation;
+    }
+    if (!Array.isArray(transformInvocation)) {
+        return onError('Expected each transform to be a string name or tuple');
+    }
+    if (transformInvocation.length === 0 || transformInvocation.length > 2) {
+        return onError('Expected each transform tuple to have one or two items');
+    }
+    let [name, rawParam] = transformInvocation;
+    if (typeof name !== 'string' || !/^[A-Za-z0-9_-]+$/.test(name)) {
+        return onError('Expected each transform name to use "transform-name" format');
+    }
+    let transform = transformsByName.get(name);
+    if (transform === undefined) {
+        return onError(`Unknown file transform "${name}"`);
+    }
+    if (transformInvocation.length === 1) {
+        if (transform.param === true) {
+            return onError(`File transform "${name}" requires a param`);
+        }
+        return name;
+    }
+    if (typeof rawParam !== 'string') {
+        return onError(`Invalid param for file transform "${name}": expected a string`);
+    }
+    if (transform.param === undefined) {
+        if (transformInvocation.length === 2) {
+            return onError(`File transform "${name}" does not accept a param`);
+        }
+        return name;
+    }
+    return `${name}:${rawParam}`;
+}
+function parseSerializedAssetTransformInvocation(transformQuery, transformsByName, onError) {
+    let separatorIndex = transformQuery.indexOf(':');
+    let name = separatorIndex === -1 ? transformQuery : transformQuery.slice(0, separatorIndex);
+    let param = separatorIndex === -1 ? undefined : transformQuery.slice(separatorIndex + 1);
+    if (!/^[A-Za-z0-9_-]+$/.test(name)) {
+        return onError('Expected each transform name to use "transform-name" format');
+    }
+    let transform = transformsByName.get(name);
+    if (transform === undefined) {
+        return onError(`Unknown file transform "${name}"`);
+    }
+    if (transform.param === undefined) {
+        if (param !== undefined) {
+            return onError(`File transform "${name}" does not accept a param`);
+        }
+        return name;
+    }
+    if (transform.param === true && param === undefined) {
+        return onError(`File transform "${name}" requires a param`);
+    }
+    if (param === undefined) {
+        return name;
+    }
+    return [name, param];
+}

package/dist/lib/files/store.d.ts

@@ -0,0 +1,31 @@
+export type FileSnapshot = {
+    filePath: string;
+    mtimeNs: bigint;
+    size: bigint;
+};
+export type SourceFileMetadata = {
+    contentType: string;
+    etag: string;
+    extension: string;
+    fingerprint: string | null;
+};
+type SourceFileRecordState = {
+    metadata?: SourceFileMetadata;
+    metadataSnapshot?: FileSnapshot;
+    identityPath: string;
+    invalidationVersion: number;
+    staleMetadata?: SourceFileMetadata;
+    staleMetadataSnapshot?: FileSnapshot;
+};
+export type SourceFileRecord = Readonly<SourceFileRecordState>;
+export type SourceFileStore = {
+    get(identityPath: string): SourceFileRecord;
+    invalidate(identityPath: string, options?: {
+        retainStale: boolean;
+    }): void;
+    invalidateForFileEvent(filePath: string, event: 'add' | 'change' | 'unlink'): void;
+    set(identityPath: string, metadata: SourceFileMetadata, snapshot: FileSnapshot | null): void;
+};
+export declare function createSourceFileStore(): SourceFileStore;
+export {};
+//# sourceMappingURL=store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../src/lib/files/store.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;CAC3B,CAAA;AAED,KAAK,qBAAqB,GAAG;IAC3B,QAAQ,CAAC,EAAE,kBAAkB,CAAA;IAC7B,gBAAgB,CAAC,EAAE,YAAY,CAAA;IAC/B,YAAY,EAAE,MAAM,CAAA;IACpB,mBAAmB,EAAE,MAAM,CAAA;IAC3B,aAAa,CAAC,EAAE,kBAAkB,CAAA;IAClC,qBAAqB,CAAC,EAAE,YAAY,CAAA;CACrC,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC,qBAAqB,CAAC,CAAA;AAW9D,MAAM,MAAM,eAAe,GAAG;IAC5B,GAAG,CAAC,YAAY,EAAE,MAAM,GAAG,gBAAgB,CAAA;IAC3C,UAAU,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,WAAW,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAA;IAC1E,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,QAAQ,GAAG,QAAQ,GAAG,IAAI,CAAA;IAClF,GAAG,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,kBAAkB,EAAE,QAAQ,EAAE,YAAY,GAAG,IAAI,GAAG,IAAI,CAAA;CAC7F,CAAA;AAED,wBAAgB,qBAAqB,IAAI,eAAe,CAoEvD"}

package/dist/lib/files/store.js

@@ -0,0 +1,63 @@
+export function createSourceFileStore() {
+    let recordsByIdentityPath = new Map();
+    let invalidationVersionByIdentityPath = new Map();
+    return {
+        get(identityPath) {
+            return getOrCreateRecord(identityPath);
+        },
+        invalidate(identityPath, options = { retainStale: false }) {
+            let record = recordsByIdentityPath.get(identityPath);
+            if (!record)
+                return;
+            invalidateRecord(record, options);
+        },
+        invalidateForFileEvent(filePath, event) {
+            let record = recordsByIdentityPath.get(filePath);
+            if (!record)
+                return;
+            invalidateRecord(record, { retainStale: event === 'change' });
+            if (event === 'unlink') {
+                recordsByIdentityPath.delete(filePath);
+            }
+        },
+        set(identityPath, metadata, snapshot) {
+            let record = recordsByIdentityPath.get(identityPath);
+            if (!record) {
+                record = getOrCreateRecord(identityPath);
+            }
+            record.metadata = metadata;
+            record.metadataSnapshot = snapshot ?? undefined;
+            record.staleMetadata = undefined;
+            record.staleMetadataSnapshot = undefined;
+        },
+    };
+    function invalidateRecord(record, options) {
+        if (!options.retainStale) {
+            record.staleMetadata = undefined;
+            record.staleMetadataSnapshot = undefined;
+        }
+        else if (record.metadata && record.metadataSnapshot) {
+            record.staleMetadata = record.metadata;
+            record.staleMetadataSnapshot = record.metadataSnapshot;
+        }
+        else if (!record.staleMetadata || !record.staleMetadataSnapshot) {
+            record.staleMetadata = undefined;
+            record.staleMetadataSnapshot = undefined;
+        }
+        record.metadata = undefined;
+        record.metadataSnapshot = undefined;
+        record.invalidationVersion += 1;
+        invalidationVersionByIdentityPath.set(record.identityPath, record.invalidationVersion);
+    }
+    function getOrCreateRecord(identityPath) {
+        let existing = recordsByIdentityPath.get(identityPath);
+        if (existing)
+            return existing;
+        let record = {
+            identityPath,
+            invalidationVersion: invalidationVersionByIdentityPath.get(identityPath) ?? 0,
+        };
+        recordsByIdentityPath.set(identityPath, record);
+        return record;
+    }
+}

package/dist/lib/fingerprint.d.ts

@@ -1,7 +1,7 @@
-export declare function hashContent(content: string): Promise<string>;
-export declare function generateFingerprint(options: {
+export declare function hashContent(content: string | Uint8Array<ArrayBufferLike>): Promise<string>;
+export declare function generateFingerprint(args: {
     buildId: string;
-    content: string;
+    content: string | Uint8Array<ArrayBufferLike>;
 }): Promise<string>;
 export declare function parseFingerprintSuffix(pathname: string): {
     pathname: string;

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

@@ -1 +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"}
+{"version":3,"file":"fingerprint.d.ts","sourceRoot":"","sources":["../../src/lib/fingerprint.ts"],"names":[],"mappings":"AAGA,wBAAsB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,CAAC,eAAe,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAIhG;AAED,wBAAsB,mBAAmB,CAAC,IAAI,EAAE;IAC9C,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,GAAG,UAAU,CAAC,eAAe,CAAC,CAAA;CAC9C,GAAG,OAAO,CAAC,MAAM,CAAC,CAIlB;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

@@ -1,13 +1,13 @@
 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);
+    let bytes = typeof content === 'string' ? new TextEncoder().encode(content) : Buffer.from(content);
+    let hashBuffer = await crypto.subtle.digest('SHA-256', bytes);
     return Buffer.from(hashBuffer).toString('base64url').slice(0, 6);
 }
-export async function generateFingerprint(options) {
-    return hashContent(JSON.stringify([options.content, options.buildId]));
+export async function generateFingerprint(args) {
+    let content = typeof args.content === 'string' ? args.content : Buffer.from(args.content).toString('base64');
+    return hashContent(JSON.stringify([content, args.buildId]));
 }
 export function parseFingerprintSuffix(pathname) {
     let lastSlashIndex = pathname.lastIndexOf('/');

package/dist/lib/injected-packages.d.ts

@@ -0,0 +1,11 @@
+export declare function isInjectedPackageFilePath(filePath: string): boolean;
+export declare function getInjectedPackageRouteConfigs(): {
+    fileMap: Record<string, string>;
+    rootDir: string;
+}[];
+export declare function getInjectedPackageNameForSpecifier(specifier: string): string | null;
+export declare function mayContainInjectedPackageSpecifier(sourceText: string): boolean;
+export declare function maskAuthoredInjectedPackageSpecifier(specifier: string): string | null;
+export declare function restoreAuthoredInjectedPackageSpecifier(specifier: string): string | null;
+export declare function getInjectedPackageImporterPath(): string;
+//# sourceMappingURL=injected-packages.d.ts.map

package/dist/lib/injected-packages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"injected-packages.d.ts","sourceRoot":"","sources":["../../src/lib/injected-packages.ts"],"names":[],"mappings":"AAeA,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAWnE;AAED,wBAAgB,8BAA8B,IAAI;IAChD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B,OAAO,EAAE,MAAM,CAAA;CAChB,EAAE,CAWF;AAED,wBAAgB,kCAAkC,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQnF;AAED,wBAAgB,kCAAkC,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAE9E;AAED,wBAAgB,oCAAoC,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAMrF;AAED,wBAAgB,uCAAuC,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAYxF;AAMD,wBAAgB,8BAA8B,IAAI,MAAM,CAEvD"}

package/dist/lib/injected-packages.js

@@ -0,0 +1,86 @@
+import * as fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { getFilePathDirectory, normalizeFilePath } from "./paths.js";
+const injectedPackageNames = ['@oxc-project/runtime'];
+const injectedPackagesBasePath = '/__@remix/injected';
+const resolvedInjectedPackages = new Map();
+export function isInjectedPackageFilePath(filePath) {
+    let normalizedFilePath = normalizeFilePath(filePath);
+    for (let packageName of injectedPackageNames) {
+        let packageRoot = getResolvedInjectedPackage(packageName).packageRoot;
+        if (normalizedFilePath === packageRoot || normalizedFilePath.startsWith(`${packageRoot}/`)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function getInjectedPackageRouteConfigs() {
+    return injectedPackageNames.map((packageName) => {
+        let { packageRoot } = getResolvedInjectedPackage(packageName);
+        return {
+            fileMap: {
+                [getInjectedPackageRoutePattern(packageName)]: `${packageName}/*path`,
+            },
+            rootDir: getInjectedPackageRouteRoot(packageRoot, packageName),
+        };
+    });
+}
+export function getInjectedPackageNameForSpecifier(specifier) {
+    for (let packageName of injectedPackageNames) {
+        if (specifier === packageName || specifier.startsWith(`${packageName}/`)) {
+            return packageName;
+        }
+    }
+    return null;
+}
+export function mayContainInjectedPackageSpecifier(sourceText) {
+    return injectedPackageNames.some((packageName) => sourceText.includes(packageName));
+}
+export function maskAuthoredInjectedPackageSpecifier(specifier) {
+    let packageName = getInjectedPackageNameForSpecifier(specifier);
+    if (!packageName)
+        return null;
+    let maskedPackageName = getMaskedInjectedPackageName(packageName);
+    return `${maskedPackageName}${specifier.slice(packageName.length)}`;
+}
+export function restoreAuthoredInjectedPackageSpecifier(specifier) {
+    for (let packageName of injectedPackageNames) {
+        let maskedPackageName = getMaskedInjectedPackageName(packageName);
+        if (specifier === maskedPackageName) {
+            return packageName;
+        }
+        if (specifier.startsWith(`${maskedPackageName}/`)) {
+            return `${packageName}${specifier.slice(maskedPackageName.length)}`;
+        }
+    }
+    return null;
+}
+function getMaskedInjectedPackageName(packageName) {
+    return `~${packageName.slice(1)}`;
+}
+export function getInjectedPackageImporterPath() {
+    return normalizeFilePath(fileURLToPath(import.meta.url));
+}
+function getResolvedInjectedPackage(packageName) {
+    let existing = resolvedInjectedPackages.get(packageName);
+    if (existing)
+        return existing;
+    let packageJsonUrl = import.meta.resolve(`${packageName}/package.json`);
+    let packageJsonPath = normalizeFilePath(fs.realpathSync(fileURLToPath(packageJsonUrl)));
+    let resolvedInjectedPackage = {
+        packageJsonPath,
+        packageRoot: normalizeFilePath(fs.realpathSync(getFilePathDirectory(packageJsonPath))),
+    };
+    resolvedInjectedPackages.set(packageName, resolvedInjectedPackage);
+    return resolvedInjectedPackage;
+}
+function getInjectedPackageRoutePattern(packageName) {
+    return `${injectedPackagesBasePath}/${packageName}/*path`;
+}
+function getInjectedPackageRouteRoot(packageRoot, packageName) {
+    let routeRoot = packageRoot;
+    for (let _segment of packageName.split('/')) {
+        routeRoot = getFilePathDirectory(routeRoot);
+    }
+    return routeRoot;
+}

package/dist/lib/paths.d.ts

@@ -4,5 +4,6 @@ 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 getRelativeFilePath(fromPath: string, toPath: string): string;
 export declare function getFilePathBaseName(filePath: string): string;
 //# sourceMappingURL=paths.d.ts.map

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

@@ -1 +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"}
+{"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,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CA0B5E;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE5D"}

package/dist/lib/paths.js

@@ -42,6 +42,18 @@ export function resolveFilePath(rootDir, filePath) {
 export function getFilePathDirectory(filePath) {
     return path.posix.dirname(normalizeWindowsPath(filePath));
 }
+export function getRelativeFilePath(fromPath, toPath) {
+    let normalizedFromPath = normalizeFilePath(fromPath);
+    let normalizedToPath = normalizeFilePath(toPath);
+    if (normalizedFromPath.startsWith('//') || normalizedToPath.startsWith('//')) {
+        return normalizeWindowsPath(path.win32.relative(normalizedFromPath.replace(/\//g, '\\'), normalizedToPath.replace(/\//g, '\\')));
+    }
+    if (windowsDriveLetterRE.test(normalizedFromPath) ||
+        windowsDriveLetterRE.test(normalizedToPath)) {
+        return normalizeWindowsPath(path.win32.relative(normalizedFromPath.replace(/\//g, '\\'), normalizedToPath.replace(/\//g, '\\')));
+    }
+    return path.posix.relative(normalizedFromPath, normalizedToPath);
+}
 export function getFilePathBaseName(filePath) {
     return path.posix.basename(normalizeWindowsPath(filePath));
 }

package/dist/lib/routes.d.ts

@@ -1,13 +1,11 @@
-export interface AssetRouteDefinition {
-    urlPattern: string;
-    filePattern: string;
+interface RouteConfig {
+    fileMap: Readonly<Record<string, string>>;
+    rootDir: 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;
+export declare function compileRoutes(basePath: string, routeConfigs: readonly RouteConfig[]): CompiledRoutes;
+export {};
 //# sourceMappingURL=routes.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/lib/routes.ts"],"names":[],"mappings":"AAiBA,UAAU,WAAW;IACnB,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IACzC,OAAO,EAAE,MAAM,CAAA;CAChB;AAUD,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,CAC3B,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,SAAS,WAAW,EAAE,GACnC,cAAc,CA8ChB"}

package/dist/lib/routes.js

@@ -1,28 +1,32 @@
-import * as path from 'node:path';
 import { RoutePattern } from '@remix-run/route-pattern';
-import { isAbsoluteFilePath, normalizeFilePath, normalizePathname, resolveFilePath, } from "./paths.js";
+import { createHref } from '@remix-run/route-pattern/href';
+import { createMatcher } from '@remix-run/route-pattern/match';
+import { getRelativeFilePath, 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) {
+export function compileRoutes(basePath, routeConfigs) {
+    if (routeConfigs.every((routeConfig) => Object.keys(routeConfig.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,
+    let compiledRoutes = routeConfigs.flatMap((routeConfig) => Object.entries(routeConfig.fileMap).map(([urlPattern, filePattern]) => compileRoute({
         filePattern,
-    }, { rootDir: options.rootDir }));
+        urlPattern,
+    }, {
+        basePath,
+        rootDir: routeConfig.rootDir,
+    })));
     return {
         resolveUrlPathname(pathname) {
             let normalizedPathname = normalizePathname(pathname);
             for (let route of compiledRoutes) {
-                let match = route.urlPattern.match(`http://remix.run${normalizedPathname}`);
+                let match = route.urlMatcher.match(`http://remix.run${normalizedPathname}`);
                 if (!match)
                     continue;
-                let relativeFilePath = route.filePattern.href(match.params).replace(/^\/+/, '');
+                let relativeFilePath = createHref(route.filePattern, match.params).replace(/^\/+/, '');
                 return resolveFilePath(route.rootDir, relativeFilePath);
             }
             return null;
@@ -30,65 +34,66 @@ export function compileRoutes(options) {
         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);
+                let relativeFilePath = getRelativeFilePath(route.rootDir, normalizedFilePath);
+                let match = route.fileMatcher.match(`http://remix.run/${relativeFilePath}`);
                 if (!match)
                     continue;
-                return normalizePathname(route.urlPattern.href(getPathnameParams(route.filePattern, match)));
+                return normalizePathname(createHref(route.urlPattern, match.params));
             }
             return null;
         },
     };
 }
 function compileRoute(route, options) {
-    let urlPatternSource = normalizePathname(route.urlPattern);
+    let basePath = normalizePathname(options.basePath).replace(/\/+$/, '') || '/';
+    let relativeUrlPattern = normalizePathname(route.urlPattern);
+    let urlPatternSource = normalizePathname(`${basePath.replace(/\/+$/, '')}/${relativeUrlPattern.replace(/^\/+/, '')}`);
     let filePatternSource = normalizeFilePattern(route.filePattern);
-    let urlPattern = new RoutePattern(urlPatternSource);
-    let filePattern = new RoutePattern(filePatternSource);
+    let urlPattern = RoutePattern.parse(urlPatternSource);
+    let filePattern = RoutePattern.parse(filePatternSource);
     validateNoUnnamedWildcards(urlPattern, 'URL');
     validateNoUnnamedWildcards(filePattern, 'File');
     validateRoutePatterns(urlPattern, filePattern);
     return {
         rootDir: normalizeFilePath(options.rootDir).replace(/\/+$/, ''),
         urlPattern,
+        urlMatcher: createMatcher(urlPattern),
         filePattern,
+        fileMatcher: createMatcher(stripDotSegments(filePatternSource)),
     };
 }
-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 === '*')
+function stripDotSegments(pattern) {
+    let segments = [];
+    for (let segment of pattern.split('/')) {
+        if (segment === '' || segment === '.')
             continue;
-        params[param.name] = undefined;
-    }
-    for (let param of match) {
-        if (param.name === '*')
+        if (segment === '..') {
+            segments.pop();
             continue;
-        params[param.name] = param.value;
+        }
+        segments.push(segment);
     }
-    return params;
+    return segments.join('/');
 }
 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}`);
+    let urlParams = getPathnameParams(urlPattern);
+    let fileParams = getPathnameParams(filePattern);
     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]) {
+        let urlParam = urlParams[i];
+        let fileParam = fileParams[i];
+        if (urlParam.type !== fileParam.type || urlParam.name !== fileParam.name) {
             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 === '*')) {
+    if (pattern.pathname.tokens.some((token) => token.type === '*' && token.name === '*')) {
         throw new Error(`${label} route patterns must use named wildcards for reversible mapping.\nPattern: ${pattern}`);
     }
 }
+function getPathnameParams(pattern) {
+    return pattern.pathname.tokens.filter((token) => token.type === ':' || token.type === '*');
+}