@remix-run/assets 0.1.0 → 0.2.0

package/dist/lib/styles/compiler.js

@@ -0,0 +1,272 @@
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { IfNoneMatch } from '@remix-run/headers';
+import { createFileMatcher } from "../file-matcher.js";
+import { formatFingerprintedPathname } from "../fingerprint.js";
+import { createModuleStore } from "../module-store.js";
+import { normalizeFilePath, resolveFilePath } from "../paths.js";
+import { emitResolvedStyle } from "./emit.js";
+import { resolveServedStyleOrThrow, resolveStyle } from "./resolve.js";
+import { transformStyle } from "./transform.js";
+const preloadConcurrency = Math.max(1, Math.min(8, os.availableParallelism() - 1));
+const styleExtension = '.css';
+export function createStyleCompiler(options) {
+    let resolvedOptions = {
+        ...options,
+        watchIgnoreMatchers: (options.watchIgnore ?? []).map((pattern) => createFileMatcher(pattern, options.rootDir)),
+    };
+    let styleStore = createModuleStore({
+        onWatchDirectoriesChange: options.onWatchDirectoriesChange,
+    });
+    let resolveInFlightByCacheKey = new Map();
+    let emitInFlightByCacheKey = new Map();
+    let resolveArgs = {
+        isAllowed: resolvedOptions.isAllowed,
+        isWatchIgnored,
+        routes: resolvedOptions.routes,
+    };
+    let transformArgs = {
+        buildId: resolvedOptions.buildId ?? null,
+        isWatchIgnored,
+        minify: resolvedOptions.minify,
+        routes: resolvedOptions.routes,
+        sourceMapSourcePaths: resolvedOptions.sourceMapSourcePaths,
+        sourceMaps: resolvedOptions.sourceMaps ?? null,
+        targets: resolvedOptions.targets ?? null,
+    };
+    return {
+        async getHref(filePath) {
+            let resolvedStyle = resolveServedStyleOrThrow(resolveInputFilePath(filePath), resolveArgs);
+            return getServedUrl(resolvedStyle.identityPath);
+        },
+        async getPreloadLayers(filePath) {
+            let resolvedEntries = [];
+            let seen = new Set();
+            for (let resolvedStyle of (Array.isArray(filePath) ? filePath : [filePath]).map((nextPath) => resolveServedStyleOrThrow(resolveInputFilePath(nextPath), resolveArgs))) {
+                if (seen.has(resolvedStyle.identityPath))
+                    continue;
+                seen.add(resolvedStyle.identityPath);
+                resolvedEntries.push(resolvedStyle.identityPath);
+            }
+            let visited = new Set(resolvedEntries);
+            let queue = [...resolvedEntries];
+            let layers = [];
+            while (queue.length > 0) {
+                let frontier = queue;
+                queue = [];
+                let resolvedStyles = await getOrCreateResolvedStyles(frontier.map((identityPath) => styleStore.get(identityPath)));
+                let layer = [];
+                for (let resolvedStyle of resolvedStyles) {
+                    layer.push(getServedUrlForResolvedStyle(resolvedStyle));
+                    for (let dep of resolvedStyle.deps) {
+                        if (visited.has(dep))
+                            continue;
+                        visited.add(dep);
+                        queue.push(dep);
+                    }
+                }
+                layers.push(layer);
+            }
+            return layers;
+        },
+        async getStyle(filePath, getOptions) {
+            let resolvedStyle = resolveServedStyleOrThrow(resolveInputFilePath(filePath), resolveArgs);
+            let record = styleStore.get(resolvedStyle.identityPath);
+            let notModified = getNotModifiedStyle(record.emitted, getOptions);
+            if (notModified)
+                return notModified;
+            let emitted = await getOrCreateEmittedStyle(record);
+            return {
+                style: toStyleCompileResult(emitted),
+                type: 'style',
+            };
+        },
+        async handleFileEvent(filePath, event) {
+            let normalizedFilePath = normalizeFilePath(filePath);
+            if (isWatchIgnored(normalizedFilePath))
+                return;
+            styleStore.invalidateForFileEvent(normalizedFilePath, event);
+        },
+    };
+    function resolveInputFilePath(filePath) {
+        if (filePath.startsWith('file://')) {
+            return normalizeFilePath(fileURLToPath(new URL(filePath)));
+        }
+        if (filePath.includes('://')) {
+            throw new TypeError(`Expected a file path or file:// URL, received "${filePath}"`);
+        }
+        return resolveFilePath(resolvedOptions.rootDir, filePath);
+    }
+    async function getOrCreateResolvedStyles(records) {
+        return mapWithConcurrency(records, preloadConcurrency, (record) => getOrCreateResolvedStyle(record));
+    }
+    async function getOrCreateResolvedStyle(record) {
+        if (record.resolved)
+            return record.resolved;
+        let cacheKey = getRecordCacheKey(record);
+        let existing = resolveInFlightByCacheKey.get(cacheKey);
+        if (existing)
+            return existing;
+        let promise = (async () => {
+            let startedVersion = record.invalidationVersion;
+            let transformedStyle = await getOrCreateTransformedStyle(record);
+            let resolvedStyleResult = await resolveStyle(record, transformedStyle, resolveArgs);
+            if (!resolvedStyleResult.ok) {
+                if (isFresh(record, startedVersion)) {
+                    styleStore.clearResolved(record.identityPath, [resolvedStyleResult.tracking]);
+                }
+                throw resolvedStyleResult.error;
+            }
+            if (isFresh(record, startedVersion)) {
+                styleStore.setResolved(record.identityPath, resolvedStyleResult.value, [
+                    resolvedStyleResult.tracking,
+                ]);
+            }
+            return resolvedStyleResult.value;
+        })();
+        resolveInFlightByCacheKey.set(cacheKey, promise);
+        try {
+            return await promise;
+        }
+        finally {
+            if (resolveInFlightByCacheKey.get(cacheKey) === promise) {
+                resolveInFlightByCacheKey.delete(cacheKey);
+            }
+        }
+    }
+    async function getOrCreateTransformedStyle(record) {
+        if (record.transformed)
+            return record.transformed;
+        let startedVersion = record.invalidationVersion;
+        let transformStyleResult = await transformStyle(record, transformArgs);
+        if (!transformStyleResult.ok) {
+            if (isFresh(record, startedVersion)) {
+                styleStore.clearTransformed(record.identityPath, [transformStyleResult.tracking]);
+            }
+            throw transformStyleResult.error;
+        }
+        if (isFresh(record, startedVersion)) {
+            styleStore.setTransformed(record.identityPath, transformStyleResult.value, [
+                transformStyleResult.tracking,
+            ]);
+        }
+        return transformStyleResult.value;
+    }
+    async function getOrCreateEmittedStyle(record) {
+        if (record.emitted)
+            return record.emitted;
+        let cacheKey = getRecordCacheKey(record);
+        let existing = emitInFlightByCacheKey.get(cacheKey);
+        if (existing)
+            return existing;
+        let promise = (async () => {
+            let startedVersion = record.invalidationVersion;
+            let resolvedStyle = await getOrCreateResolvedStyle(record);
+            let emitResolvedStyleResult = await emitResolvedStyle(resolvedStyle, {
+                getServedUrl,
+                sourceMaps: resolvedOptions.sourceMaps,
+            });
+            if (!emitResolvedStyleResult.ok) {
+                throw emitResolvedStyleResult.error;
+            }
+            if (isFresh(record, startedVersion)) {
+                styleStore.setEmitted(record.identityPath, emitResolvedStyleResult.value, null);
+            }
+            return emitResolvedStyleResult.value;
+        })();
+        emitInFlightByCacheKey.set(cacheKey, promise);
+        try {
+            return await promise;
+        }
+        finally {
+            if (emitInFlightByCacheKey.get(cacheKey) === promise) {
+                emitInFlightByCacheKey.delete(cacheKey);
+            }
+        }
+    }
+    async function getServedUrl(identityPath) {
+        return getServedUrlForResolvedStyle(await getOrCreateResolvedStyle(styleStore.get(identityPath)));
+    }
+    function getServedUrlForResolvedStyle(resolvedStyle) {
+        return formatFingerprintedPathname(resolvedStyle.stableUrlPathname, resolvedOptions.fingerprintAssets ? resolvedStyle.fingerprint : null);
+    }
+    function isWatchIgnored(filePath) {
+        return resolvedOptions.watchIgnoreMatchers.some((matcher) => matcher(filePath));
+    }
+}
+function getRecordCacheKey(record) {
+    return `${record.identityPath}\0${record.invalidationVersion}`;
+}
+function isFresh(record, version) {
+    return record.invalidationVersion === version;
+}
+function getNotModifiedStyle(emittedStyle, options) {
+    if (!emittedStyle || options.ifNoneMatch === null)
+        return null;
+    if (options.requestedFingerprint !== null &&
+        emittedStyle.fingerprint !== options.requestedFingerprint) {
+        return null;
+    }
+    let asset = getEmittedAssetForRequest(emittedStyle, options.isSourceMapRequest);
+    if (!asset)
+        return null;
+    if (!IfNoneMatch.from(options.ifNoneMatch).matches(asset.etag))
+        return null;
+    return { etag: asset.etag, type: 'not-modified' };
+}
+function getEmittedAssetForRequest(emittedStyle, isSourceMapRequest) {
+    return isSourceMapRequest ? emittedStyle.sourceMap : emittedStyle.code;
+}
+async function mapWithConcurrency(items, concurrency, mapper) {
+    if (items.length === 0)
+        return [];
+    let results = new Array(items.length);
+    let nextIndex = 0;
+    async function worker() {
+        while (nextIndex < items.length) {
+            let index = nextIndex++;
+            results[index] = await mapper(items[index], index);
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => worker()));
+    return results;
+}
+function toStyleCompileResult(emittedStyle) {
+    return {
+        code: emittedStyle.code,
+        fingerprint: emittedStyle.fingerprint,
+        sourceMap: emittedStyle.sourceMap,
+    };
+}
+export function isStyleFilePath(filePath) {
+    return path.extname(filePath).toLowerCase() === styleExtension;
+}
+export function createResponseForStyle(result, options) {
+    let body;
+    let etag;
+    let contentType;
+    if (options.isSourceMapRequest) {
+        if (!result.sourceMap) {
+            return new Response('Not found', { status: 404 });
+        }
+        body = options.method === 'HEAD' ? null : result.sourceMap.content;
+        etag = result.sourceMap.etag;
+        contentType = 'application/json; charset=utf-8';
+    }
+    else {
+        body = options.method === 'HEAD' ? null : result.code.content;
+        etag = result.code.etag;
+        contentType = 'text/css; charset=utf-8';
+    }
+    if (IfNoneMatch.from(options.ifNoneMatch).matches(etag)) {
+        return new Response(null, { status: 304, headers: { ETag: etag } });
+    }
+    return new Response(body, {
+        headers: {
+            'Cache-Control': options.cacheControl,
+            'Content-Type': contentType,
+            ETag: etag,
+        },
+    });
+}

package/dist/lib/styles/emit.d.ts

@@ -0,0 +1,25 @@
+import type { AssetServerCompilationError } from '../compilation-error.ts';
+import type { ResolvedStyle } from './resolve.ts';
+export type EmittedAsset = {
+    content: string;
+    etag: string;
+};
+export type EmittedStyle = {
+    code: EmittedAsset;
+    fingerprint: string | null;
+    importUrls: string[];
+    sourceMap: EmittedAsset | null;
+};
+type EmitResult = {
+    ok: true;
+    value: EmittedStyle;
+} | {
+    error: AssetServerCompilationError;
+    ok: false;
+};
+export declare function emitResolvedStyle(resolvedStyle: ResolvedStyle, options: {
+    getServedUrl(identityPath: string): Promise<string>;
+    sourceMaps?: 'external' | 'inline';
+}): Promise<EmitResult>;
+export {};
+//# sourceMappingURL=emit.d.ts.map

package/dist/lib/styles/emit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../../../src/lib/styles/emit.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAA;AAC1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAEjD,MAAM,MAAM,YAAY,GAAG;IACzB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,YAAY,CAAA;IAClB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,SAAS,EAAE,YAAY,GAAG,IAAI,CAAA;CAC/B,CAAA;AAED,KAAK,UAAU,GACX;IACE,EAAE,EAAE,IAAI,CAAA;IACR,KAAK,EAAE,YAAY,CAAA;CACpB,GACD;IACE,KAAK,EAAE,2BAA2B,CAAA;IAClC,EAAE,EAAE,KAAK,CAAA;CACV,CAAA;AAEL,wBAAsB,iBAAiB,CACrC,aAAa,EAAE,aAAa,EAC5B,OAAO,EAAE;IACP,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IACnD,UAAU,CAAC,EAAE,UAAU,GAAG,QAAQ,CAAA;CACnC,GACA,OAAO,CAAC,UAAU,CAAC,CAkCrB"}

package/dist/lib/styles/emit.js

@@ -0,0 +1,78 @@
+import MagicString from 'magic-string';
+import { createAssetServerCompilationError, isAssetServerCompilationError, } from "../compilation-error.js";
+import { hashContent } from "../fingerprint.js";
+import { composeSourceMaps } from "../source-maps.js";
+export async function emitResolvedStyle(resolvedStyle, options) {
+    try {
+        let importUrls = await Promise.all(resolvedStyle.deps.map((depPath) => options.getServedUrl(depPath)));
+        let rewriteResult = await rewriteDependencies(resolvedStyle, options);
+        let finalCode = rewriteResult.code;
+        if (rewriteResult.sourceMap) {
+            if (options.sourceMaps === 'inline') {
+                let encoded = Buffer.from(rewriteResult.sourceMap).toString('base64');
+                finalCode += `\n/*# sourceMappingURL=data:application/json;base64,${encoded} */`;
+            }
+            else if (options.sourceMaps === 'external') {
+                finalCode += `\n/*# sourceMappingURL=${await options.getServedUrl(resolvedStyle.identityPath)}.map */`;
+            }
+        }
+        return {
+            ok: true,
+            value: {
+                code: await createEmittedAsset(finalCode),
+                fingerprint: resolvedStyle.fingerprint,
+                importUrls,
+                sourceMap: rewriteResult.sourceMap
+                    ? await createEmittedAsset(rewriteResult.sourceMap)
+                    : null,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            error: toEmitError(error, resolvedStyle.identityPath),
+            ok: false,
+        };
+    }
+}
+async function rewriteDependencies(resolvedStyle, options) {
+    if (resolvedStyle.dependencies.length === 0) {
+        return {
+            code: resolvedStyle.rawCode,
+            sourceMap: resolvedStyle.sourceMap,
+        };
+    }
+    let rewrittenSource = new MagicString(resolvedStyle.rawCode);
+    for (let dependency of resolvedStyle.dependencies) {
+        let replacement = dependency.kind === 'external'
+            ? dependency.replacement
+            : `${await options.getServedUrl(dependency.depPath)}${dependency.suffix}`;
+        let start = resolvedStyle.rawCode.indexOf(dependency.placeholder);
+        if (start < 0) {
+            throw createAssetServerCompilationError(`Missing dependency placeholder "${dependency.placeholder}" while emitting style ${resolvedStyle.identityPath}.`, {
+                code: 'EMIT_FAILED',
+            });
+        }
+        rewrittenSource.overwrite(start, start + dependency.placeholder.length, replacement);
+    }
+    return {
+        code: rewrittenSource.toString(),
+        sourceMap: resolvedStyle.sourceMap
+            ? composeSourceMaps(rewrittenSource.generateMap({ hires: true }).toString(), resolvedStyle.sourceMap)
+            : null,
+    };
+}
+async function createEmittedAsset(content) {
+    return {
+        content,
+        etag: `W/"${await hashContent(content)}"`,
+    };
+}
+function toEmitError(error, identityPath) {
+    if (isAssetServerCompilationError(error))
+        return error;
+    return createAssetServerCompilationError(`Failed to emit style ${identityPath}. ${error instanceof Error ? error.message : String(error)}`, {
+        cause: error,
+        code: 'EMIT_FAILED',
+    });
+}

package/dist/lib/styles/resolve.d.ts

@@ -0,0 +1,48 @@
+import type { AssetServerCompilationError } from '../compilation-error.ts';
+import type { ModuleRecord, ModuleTracking } from '../module-store.ts';
+import type { CompiledRoutes } from '../routes.ts';
+import type { EmittedStyle } from './emit.ts';
+import type { TransformedStyle } from './transform.ts';
+type StyleRecord = ModuleRecord<TransformedStyle, ResolvedStyle, EmittedStyle>;
+type ResolvedDependency = {
+    kind: 'external';
+    placeholder: string;
+    replacement: string;
+} | {
+    depPath: string;
+    kind: 'local';
+    placeholder: string;
+    suffix: string;
+};
+export type ResolvedStyle = {
+    dependencies: ResolvedDependency[];
+    deps: string[];
+    fingerprint: string | null;
+    identityPath: string;
+    rawCode: string;
+    resolvedPath: string;
+    sourceMap: string | null;
+    stableUrlPathname: string;
+    trackedFiles: string[];
+};
+export type ResolveArgs = {
+    isAllowed(absolutePath: string): boolean;
+    isWatchIgnored(filePath: string): boolean;
+    routes: CompiledRoutes;
+};
+type ResolveResult = {
+    tracking: ModuleTracking;
+} & ({
+    ok: true;
+    value: ResolvedStyle;
+} | {
+    error: AssetServerCompilationError;
+    ok: false;
+});
+export declare function resolveStyle(record: StyleRecord, transformed: TransformedStyle, args: ResolveArgs): Promise<ResolveResult>;
+export declare function resolveServedStyleOrThrow(filePath: string, args: ResolveArgs): {
+    identityPath: string;
+    stableUrlPathname: string;
+};
+export {};
+//# sourceMappingURL=resolve.d.ts.map

package/dist/lib/styles/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../../src/lib/styles/resolve.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAA;AAC1E,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACtE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AAC7C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAEtD,KAAK,WAAW,GAAG,YAAY,CAAC,gBAAgB,EAAE,aAAa,EAAE,YAAY,CAAC,CAAA;AAE9E,KAAK,kBAAkB,GACnB;IACE,IAAI,EAAE,UAAU,CAAA;IAChB,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,EAAE,MAAM,CAAA;CACpB,GACD;IACE,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,OAAO,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAEL,MAAM,MAAM,aAAa,GAAG;IAC1B,YAAY,EAAE,kBAAkB,EAAE,CAAA;IAClC,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,YAAY,EAAE,MAAM,CAAA;IACpB,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;CACvB,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,SAAS,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAA;IACxC,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAA;IACzC,MAAM,EAAE,cAAc,CAAA;CACvB,CAAA;AAED,KAAK,aAAa,GAAG;IACnB,QAAQ,EAAE,cAAc,CAAA;CACzB,GAAG,CACA;IACE,EAAE,EAAE,IAAI,CAAA;IACR,KAAK,EAAE,aAAa,CAAA;CACrB,GACD;IACE,KAAK,EAAE,2BAA2B,CAAA;IAClC,EAAE,EAAE,KAAK,CAAA;CACV,CACJ,CAAA;AAED,wBAAsB,YAAY,CAChC,MAAM,EAAE,WAAW,EACnB,WAAW,EAAE,gBAAgB,EAC7B,IAAI,EAAE,WAAW,GAChB,OAAO,CAAC,aAAa,CAAC,CAuDxB;AAED,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,WAAW,GAChB;IACD,YAAY,EAAE,MAAM,CAAA;IACpB,iBAAiB,EAAE,MAAM,CAAA;CAC1B,CA+BA"}

package/dist/lib/styles/resolve.js

@@ -0,0 +1,188 @@
+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 async function resolveStyle(record, transformed, args) {
+    let trackedFiles = new Set(transformed.trackedFiles);
+    let dependencies = [];
+    let deps = new Set();
+    for (let unresolved of transformed.unresolvedDependencies) {
+        let trackedFile = unresolved.type === 'import'
+            ? getTrackedImportFilePath(unresolved.url, transformed.resolvedPath)
+            : null;
+        if (trackedFile && !args.isWatchIgnored(trackedFile)) {
+            trackedFiles.add(trackedFile);
+        }
+        try {
+            let resolved = unresolved.type === 'import'
+                ? resolveImportDependency(unresolved.url, transformed.resolvedPath, unresolved.placeholder, args)
+                : resolveUrlDependency(unresolved.url, unresolved.placeholder);
+            dependencies.push(resolved);
+            if (resolved.kind === 'local') {
+                if (!args.isWatchIgnored(resolved.depPath)) {
+                    trackedFiles.add(resolved.depPath);
+                }
+                deps.add(resolved.depPath);
+            }
+        }
+        catch (error) {
+            return failResolve(error, trackedFiles, transformed.resolvedPath);
+        }
+    }
+    return {
+        ok: true,
+        tracking: {
+            trackedFiles: [...trackedFiles],
+        },
+        value: {
+            dependencies,
+            deps: [...deps],
+            fingerprint: transformed.fingerprint,
+            identityPath: record.identityPath,
+            rawCode: transformed.rawCode,
+            resolvedPath: transformed.resolvedPath,
+            sourceMap: transformed.sourceMap,
+            stableUrlPathname: transformed.stableUrlPathname,
+            trackedFiles: [...trackedFiles],
+        },
+    };
+}
+export function resolveServedStyleOrThrow(filePath, args) {
+    let identityPath = resolveExistingFilePath(filePath);
+    if (!identityPath) {
+        throw createAssetServerCompilationError(`File not found: ${filePath}`, {
+            code: 'FILE_NOT_FOUND',
+        });
+    }
+    if (!isStyleFilePath(identityPath)) {
+        throw createAssetServerCompilationError(`File not found: ${identityPath}`, {
+            code: 'FILE_NOT_FOUND',
+        });
+    }
+    if (!args.isAllowed(identityPath)) {
+        throw createAssetServerCompilationError(`File is not allowed: ${identityPath}`, {
+            code: 'FILE_NOT_ALLOWED',
+        });
+    }
+    let stableUrlPathname = args.routes.toUrlPathname(identityPath);
+    if (!stableUrlPathname) {
+        throw createAssetServerCompilationError(`File ${identityPath} is outside all configured fileMap entries.`, {
+            code: 'FILE_OUTSIDE_FILE_MAP',
+        });
+    }
+    return { identityPath, stableUrlPathname };
+}
+function resolveImportDependency(url, importerPath, placeholder, args) {
+    if (isExternalUrl(url)) {
+        return {
+            kind: 'external',
+            placeholder,
+            replacement: url,
+        };
+    }
+    let { pathname, suffix } = splitUrlSuffix(url);
+    if (pathname.length === 0 || pathname === '#') {
+        return {
+            kind: 'external',
+            placeholder,
+            replacement: url,
+        };
+    }
+    if (pathname.startsWith('/')) {
+        return {
+            kind: 'external',
+            placeholder,
+            replacement: url,
+        };
+    }
+    let resolvedFilePath = normalizeFilePath(path.resolve(path.dirname(importerPath), pathname));
+    let identityPath = resolveExistingFilePath(resolvedFilePath);
+    if (!identityPath || !isStyleFilePath(identityPath)) {
+        throw createAssetServerCompilationError(`Failed to resolve import "${url}" in ${importerPath}.`, {
+            code: 'IMPORT_RESOLUTION_FAILED',
+        });
+    }
+    if (!args.isAllowed(identityPath)) {
+        throw createAssetServerCompilationError(`Import "${url}" in ${importerPath}, resolved to "${identityPath}", is not allowed by the asset server allow/deny configuration. ` +
+            `Add a matching allow rule for this file path, remove a conflicting deny rule for this file path, or mark this import as external.`, {
+            code: 'IMPORT_NOT_ALLOWED',
+        });
+    }
+    if (!args.routes.toUrlPathname(identityPath)) {
+        throw createAssetServerCompilationError(`Import "${url}" in ${importerPath}, resolved to "${identityPath}", is outside all configured fileMap entries. ` +
+            `Add a matching fileMap entry for this file path, or mark this import as external.`, {
+            code: 'IMPORT_OUTSIDE_FILE_MAP',
+        });
+    }
+    return {
+        depPath: identityPath,
+        kind: 'local',
+        placeholder,
+        suffix,
+    };
+}
+function resolveUrlDependency(url, placeholder) {
+    return {
+        kind: 'external',
+        placeholder,
+        replacement: url,
+    };
+}
+function resolveExistingFilePath(filePath) {
+    try {
+        return normalizeFilePath(fs.realpathSync(filePath));
+    }
+    catch (error) {
+        if (isNoEntityError(error))
+            return null;
+        throw error;
+    }
+}
+function splitUrlSuffix(url) {
+    let queryIndex = url.indexOf('?');
+    let hashIndex = url.indexOf('#');
+    let endIndex = [queryIndex, hashIndex].filter((index) => index >= 0).sort((a, b) => a - b)[0];
+    if (endIndex == null) {
+        return {
+            pathname: url,
+            suffix: '',
+        };
+    }
+    return {
+        pathname: url.slice(0, endIndex),
+        suffix: url.slice(endIndex),
+    };
+}
+function getTrackedImportFilePath(specifier, importerPath) {
+    let { pathname } = splitUrlSuffix(specifier);
+    if (pathname.startsWith('./') || pathname.startsWith('../')) {
+        return normalizeFilePath(path.resolve(path.dirname(importerPath), pathname));
+    }
+    return null;
+}
+function isStyleFilePath(filePath) {
+    return path.extname(filePath).toLowerCase() === '.css';
+}
+function isExternalUrl(url) {
+    return url.startsWith('#') || url.startsWith('//') || /^[A-Za-z][A-Za-z\d+.-]*:/.test(url);
+}
+function isNoEntityError(error) {
+    return (error instanceof Error && 'code' in error && error.code === 'ENOENT');
+}
+function toResolveError(error, importerPath) {
+    if (isAssetServerCompilationError(error))
+        return error;
+    return createAssetServerCompilationError(`Failed to resolve imports in ${importerPath}. ${error instanceof Error ? error.message : String(error)}`, {
+        cause: error,
+        code: 'IMPORT_RESOLUTION_FAILED',
+    });
+}
+function failResolve(error, trackedFiles, importerPath) {
+    return {
+        ok: false,
+        error: toResolveError(error, importerPath),
+        tracking: {
+            trackedFiles: [...trackedFiles],
+        },
+    };
+}

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

@@ -0,0 +1,47 @@
+import type { ModuleTracking } from '../module-store.ts';
+import type { AssetServerCompilationError } from '../compilation-error.ts';
+import type { CompiledRoutes } from '../routes.ts';
+import type { ResolvedStyleTarget } from '../target.ts';
+type TransformedStyleDependency = {
+    placeholder: string;
+    type: 'import';
+    url: string;
+} | {
+    placeholder: string;
+    type: 'url';
+    url: string;
+};
+export type TransformedStyle = {
+    fingerprint: string | null;
+    identityPath: string;
+    rawCode: string;
+    resolvedPath: string;
+    sourceMap: string | null;
+    stableUrlPathname: string;
+    trackedFiles: string[];
+    unresolvedDependencies: TransformedStyleDependency[];
+};
+type TransformResult = {
+    tracking: ModuleTracking;
+} & ({
+    ok: true;
+    value: TransformedStyle;
+} | {
+    error: AssetServerCompilationError;
+    ok: false;
+});
+export type TransformArgs = {
+    buildId: string | null;
+    isWatchIgnored(filePath: string): boolean;
+    minify: boolean;
+    routes: CompiledRoutes;
+    sourceMaps: 'external' | 'inline' | null;
+    sourceMapSourcePaths: 'absolute' | 'url';
+    targets: ResolvedStyleTarget | null;
+};
+type TransformRecord = {
+    identityPath: string;
+};
+export declare function transformStyle(record: TransformRecord, args: TransformArgs): Promise<TransformResult>;
+export {};
+//# sourceMappingURL=transform.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../src/lib/styles/transform.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAExD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAA;AAC1E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAClD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAEvD,KAAK,0BAA0B,GAC3B;IACE,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,QAAQ,CAAA;IACd,GAAG,EAAE,MAAM,CAAA;CACZ,GACD;IACE,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,KAAK,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAEL,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,YAAY,EAAE,MAAM,CAAA;IACpB,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,sBAAsB,EAAE,0BAA0B,EAAE,CAAA;CACrD,CAAA;AAED,KAAK,eAAe,GAAG;IACrB,QAAQ,EAAE,cAAc,CAAA;CACzB,GAAG,CACA;IACE,EAAE,EAAE,IAAI,CAAA;IACR,KAAK,EAAE,gBAAgB,CAAA;CACxB,GACD;IACE,KAAK,EAAE,2BAA2B,CAAA;IAClC,EAAE,EAAE,KAAK,CAAA;CACV,CACJ,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAA;IACzC,MAAM,EAAE,OAAO,CAAA;IACf,MAAM,EAAE,cAAc,CAAA;IACtB,UAAU,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAAA;IACxC,oBAAoB,EAAE,UAAU,GAAG,KAAK,CAAA;IACxC,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAAA;CACpC,CAAA;AAED,KAAK,eAAe,GAAG;IACrB,YAAY,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,wBAAsB,cAAc,CAClC,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,eAAe,CAAC,CA6G1B"}