@remix-run/assets 0.0.0 → 0.2.0

package/dist/lib/module-store.js

@@ -0,0 +1,230 @@
+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(),
+                trackedDirectories: new Set(),
+            };
+            recordsByIdentityPath.set(identityPath, record);
+            return record;
+        },
+        clearTransformed(identityPath, tracking) {
+            let record = getOrCreateMutableRecord(identityPath);
+            record.transformed = undefined;
+            record.resolved = undefined;
+            record.emitted = undefined;
+            record.emittedSnapshot = undefined;
+            record.staleEmitted = undefined;
+            record.staleEmittedSnapshot = undefined;
+            setTracking(record, tracking);
+        },
+        setTransformed(identityPath, transformed, tracking) {
+            let record = getOrCreateMutableRecord(identityPath);
+            record.transformed = transformed;
+            record.resolved = undefined;
+            record.emitted = undefined;
+            record.emittedSnapshot = undefined;
+            record.staleEmitted = undefined;
+            record.staleEmittedSnapshot = undefined;
+            setTracking(record, tracking);
+        },
+        setResolved(identityPath, resolved, tracking) {
+            let record = getOrCreateMutableRecord(identityPath);
+            record.resolved = resolved;
+            record.emitted = undefined;
+            record.emittedSnapshot = undefined;
+            record.staleEmitted = undefined;
+            record.staleEmittedSnapshot = undefined;
+            setTracking(record, tracking);
+        },
+        clearResolved(identityPath, tracking) {
+            let record = getOrCreateMutableRecord(identityPath);
+            record.resolved = undefined;
+            record.emitted = undefined;
+            record.emittedSnapshot = undefined;
+            record.staleEmitted = undefined;
+            record.staleEmittedSnapshot = undefined;
+            setTracking(record, tracking);
+        },
+        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 (matchesTrackedDirectory(record.trackedDirectories, 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(),
+            trackedDirectories: new Set(),
+        };
+        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);
+        let normalizedTracking = mergeTracking(tracking);
+        record.trackedFiles = normalizedTracking.trackedFiles;
+        record.trackedDirectories = normalizedTracking.trackedDirectories;
+        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, []);
+    }
+    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 matchesTrackedDirectory(trackedDirectories, filePath) {
+    for (let trackedDirectory of trackedDirectories) {
+        if (filePath === trackedDirectory || filePath.startsWith(`${trackedDirectory}/`))
+            return true;
+    }
+    return false;
+}
+function normalizeTrackedDirectory(trackedDirectory) {
+    return trackedDirectory.replace(/\/+$/, '') || '/';
+}
+function mergeTracking(tracking) {
+    let trackedFiles = new Set();
+    let trackedDirectories = new Set();
+    for (let fragment of tracking) {
+        for (let trackedFile of fragment.trackedFiles) {
+            trackedFiles.add(trackedFile);
+        }
+        for (let trackedDirectory of fragment.trackedDirectories ?? []) {
+            trackedDirectories.add(normalizeTrackedDirectory(trackedDirectory));
+        }
+    }
+    return {
+        trackedFiles,
+        trackedDirectories,
+    };
+}
+function getWatchedDirectories(record) {
+    let watchedDirectories = new Set();
+    for (let trackedFile of record.trackedFiles) {
+        watchedDirectories.add(getFilePathDirectory(trackedFile));
+    }
+    for (let trackedDirectory of record.trackedDirectories) {
+        watchedDirectories.add(trackedDirectory);
+    }
+    return watchedDirectories;
+}

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"}