@remix-run/assets 0.0.0 → 0.2.0

package/dist/lib/source-maps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-maps.d.ts","sourceRoot":"","sources":["../../src/lib/source-maps.ts"],"names":[],"mappings":"AAIA,wBAAgB,iBAAiB,CAAC,gBAAgB,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,GAAG,MAAM,CA2C9F;AAED,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,iBAAiB,EAAE,MAAM,EACzB,oBAAoB,EAAE,UAAU,GAAG,KAAK,EACxC,aAAa,CAAC,EAAE,MAAM,GACrB,MAAM,CASR;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAQ9D"}

package/dist/lib/source-maps.js

@@ -0,0 +1,62 @@
+import { SourceMapConsumer, SourceMapGenerator } from 'source-map-js';
+import { normalizeFilePath } from "./paths.js";
+export function composeSourceMaps(rewriteSourceMap, transformSourceMap) {
+    let rewriteConsumer = new SourceMapConsumer(JSON.parse(rewriteSourceMap));
+    let transformConsumer = new SourceMapConsumer(JSON.parse(transformSourceMap));
+    let generator = new SourceMapGenerator();
+    rewriteConsumer.eachMapping((mapping) => {
+        if (mapping.originalLine == null ||
+            mapping.originalColumn == null ||
+            mapping.generatedLine == null ||
+            mapping.generatedColumn == null) {
+            return;
+        }
+        let original = transformConsumer.originalPositionFor({
+            line: mapping.originalLine,
+            column: mapping.originalColumn,
+        });
+        if (original.line == null || original.column == null || original.source == null)
+            return;
+        generator.addMapping({
+            generated: {
+                line: mapping.generatedLine,
+                column: mapping.generatedColumn,
+            },
+            original: {
+                line: original.line,
+                column: original.column,
+            },
+            source: original.source,
+            name: original.name ?? mapping.name ?? undefined,
+        });
+    });
+    for (let source of transformConsumer.sources) {
+        let sourceContent = transformConsumer.sourceContentFor(source, true);
+        if (sourceContent !== null) {
+            generator.setSourceContent(source, sourceContent);
+        }
+    }
+    return JSON.stringify(generator.toJSON());
+}
+export function rewriteSourceMapSources(sourceMap, resolvedPath, stableUrlPathname, sourceMapSourcePaths, sourceContent) {
+    let json = JSON.parse(sourceMap);
+    json.sources = [
+        sourceMapSourcePaths === 'absolute' ? normalizeFilePath(resolvedPath) : stableUrlPathname,
+    ];
+    if (sourceContent !== undefined) {
+        json.sourcesContent = [sourceContent];
+    }
+    return JSON.stringify(json);
+}
+export function stringifySourceMap(map) {
+    if (!map)
+        return null;
+    if (typeof map === 'string')
+        return map;
+    if (map instanceof Uint8Array) {
+        return Buffer.from(map).toString('utf8');
+    }
+    if (typeof map === 'object' && map !== null)
+        return JSON.stringify(map);
+    return String(map);
+}

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

@@ -0,0 +1,52 @@
+import type { CompiledRoutes } from '../routes.ts';
+import type { ResolvedStyleTarget } from '../target.ts';
+import type { EmittedAsset } from './emit.ts';
+type StyleCompileResult = {
+    code: EmittedAsset;
+    fingerprint: string | null;
+    sourceMap: EmittedAsset | null;
+};
+type StyleGetResult = {
+    style: StyleCompileResult;
+    type: 'style';
+} | {
+    etag: string;
+    type: 'not-modified';
+};
+type StyleGetOptions = {
+    ifNoneMatch: string | null;
+    isSourceMapRequest: boolean;
+    requestedFingerprint: string | null;
+};
+type StyleCompilerOptions = {
+    buildId?: string;
+    fingerprintAssets: boolean;
+    isAllowed(absolutePath: string): boolean;
+    minify: boolean;
+    onWatchDirectoriesChange?: (delta: {
+        add: string[];
+        remove: string[];
+    }) => void;
+    rootDir: string;
+    routes: CompiledRoutes;
+    sourceMapSourcePaths: 'absolute' | 'url';
+    sourceMaps?: 'external' | 'inline';
+    targets?: ResolvedStyleTarget;
+    watchIgnore?: readonly string[];
+};
+type StyleCompiler = {
+    getHref(filePath: string): Promise<string>;
+    getPreloadLayers(filePath: string | readonly string[]): Promise<string[][]>;
+    getStyle(filePath: string, options: StyleGetOptions): Promise<StyleGetResult>;
+    handleFileEvent(filePath: string, event: 'add' | 'change' | 'unlink'): Promise<void>;
+};
+export declare function createStyleCompiler(options: StyleCompilerOptions): StyleCompiler;
+export declare function isStyleFilePath(filePath: string): boolean;
+export declare function createResponseForStyle(result: StyleCompileResult, options: {
+    cacheControl: string;
+    ifNoneMatch: string | null;
+    isSourceMapRequest: boolean;
+    method: string;
+}): Response;
+export {};
+//# sourceMappingURL=compiler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compiler.d.ts","sourceRoot":"","sources":["../../../src/lib/styles/compiler.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAClD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAEvD,OAAO,KAAK,EAAE,YAAY,EAAgB,MAAM,WAAW,CAAA;AAS3D,KAAK,kBAAkB,GAAG;IACxB,IAAI,EAAE,YAAY,CAAA;IAClB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,SAAS,EAAE,YAAY,GAAG,IAAI,CAAA;CAC/B,CAAA;AAED,KAAK,cAAc,GACf;IACE,KAAK,EAAE,kBAAkB,CAAA;IACzB,IAAI,EAAE,OAAO,CAAA;CACd,GACD;IACE,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,cAAc,CAAA;CACrB,CAAA;AAEL,KAAK,eAAe,GAAG;IACrB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,kBAAkB,EAAE,OAAO,CAAA;IAC3B,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAA;CACpC,CAAA;AAED,KAAK,oBAAoB,GAAG;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,iBAAiB,EAAE,OAAO,CAAA;IAC1B,SAAS,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAA;IACxC,MAAM,EAAE,OAAO,CAAA;IACf,wBAAwB,CAAC,EAAE,CAAC,KAAK,EAAE;QAAE,GAAG,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE,KAAK,IAAI,CAAA;IAC/E,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,cAAc,CAAA;IACtB,oBAAoB,EAAE,UAAU,GAAG,KAAK,CAAA;IACxC,UAAU,CAAC,EAAE,UAAU,GAAG,QAAQ,CAAA;IAClC,OAAO,CAAC,EAAE,mBAAmB,CAAA;IAC7B,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAChC,CAAA;AAED,KAAK,aAAa,GAAG;IACnB,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IAC1C,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAA;IAC3E,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CAAA;IAC7E,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACrF,CAAA;AAKD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,oBAAoB,GAAG,aAAa,CAiOhF;AAkED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,kBAAkB,EAC1B,OAAO,EAAE;IACP,YAAY,EAAE,MAAM,CAAA;IACpB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,kBAAkB,EAAE,OAAO,CAAA;IAC3B,MAAM,EAAE,MAAM,CAAA;CACf,GACA,QAAQ,CA6BV"}

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