@remix-run/assets 0.0.0 → 0.2.0

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

package/dist/lib/styles/transform.js

@@ -0,0 +1,131 @@
+import * as fs from 'node:fs/promises';
+import { transform } from 'lightningcss';
+import { createAssetServerCompilationError, isAssetServerCompilationError, } from "../compilation-error.js";
+import { generateFingerprint } from "../fingerprint.js";
+import { rewriteSourceMapSources, stringifySourceMap } from "../source-maps.js";
+export async function transformStyle(record, args) {
+    let resolvedPath = record.identityPath;
+    let trackedFiles = args.isWatchIgnored(resolvedPath) ? [] : [resolvedPath];
+    let rawBytes;
+    try {
+        rawBytes = new Uint8Array(await fs.readFile(resolvedPath));
+    }
+    catch (error) {
+        if (isNoEntityError(error)) {
+            return {
+                ok: false,
+                error: createAssetServerCompilationError(`File not found: ${resolvedPath}`, {
+                    cause: error,
+                    code: 'FILE_NOT_FOUND',
+                }),
+                tracking: {
+                    trackedFiles,
+                },
+            };
+        }
+        return {
+            ok: false,
+            error: toTransformFailedError(error, resolvedPath),
+            tracking: {
+                trackedFiles,
+            },
+        };
+    }
+    try {
+        let stableUrlPathname = args.routes.toUrlPathname(record.identityPath);
+        if (!stableUrlPathname) {
+            throw createAssetServerCompilationError(`File ${record.identityPath} is outside all configured fileMap entries.`, {
+                code: 'FILE_OUTSIDE_FILE_MAP',
+            });
+        }
+        let transformResult = runLightningTransform(resolvedPath, rawBytes, {
+            minify: args.minify,
+            sourceMap: args.sourceMaps != null,
+            targets: args.targets,
+        });
+        let sourceText = Buffer.from(rawBytes).toString('utf8');
+        let sourceMap = stringifySourceMap(transformResult.map);
+        sourceMap = sourceMap
+            ? rewriteSourceMapSources(sourceMap, resolvedPath, stableUrlPathname, args.sourceMapSourcePaths, sourceText)
+            : null;
+        let unresolvedDependencies = [];
+        for (let dependency of transformResult.dependencies ?? []) {
+            if (dependency.type === 'import') {
+                unresolvedDependencies.push({
+                    placeholder: dependency.placeholder,
+                    type: 'import',
+                    url: dependency.url,
+                });
+                continue;
+            }
+            if (dependency.type === 'url') {
+                unresolvedDependencies.push({
+                    placeholder: dependency.placeholder,
+                    type: 'url',
+                    url: dependency.url,
+                });
+            }
+        }
+        return {
+            ok: true,
+            tracking: {
+                trackedFiles,
+            },
+            value: {
+                fingerprint: args.buildId === null
+                    ? null
+                    : await generateFingerprint({
+                        buildId: args.buildId,
+                        content: sourceText,
+                    }),
+                identityPath: record.identityPath,
+                rawCode: Buffer.from(transformResult.code).toString('utf8'),
+                resolvedPath,
+                sourceMap,
+                stableUrlPathname,
+                trackedFiles,
+                unresolvedDependencies,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: toTransformFailedError(error, resolvedPath),
+            tracking: {
+                trackedFiles,
+            },
+        };
+    }
+}
+function runLightningTransform(identityPath, code, options) {
+    try {
+        return transform({
+            analyzeDependencies: {
+                preserveImports: true,
+            },
+            code,
+            filename: identityPath,
+            minify: options.minify,
+            sourceMap: options.sourceMap,
+            targets: options.targets ?? undefined,
+        });
+    }
+    catch (error) {
+        throw createAssetServerCompilationError(`Failed to transform style ${identityPath}. ${error instanceof Error ? error.message : String(error)}`, {
+            cause: error,
+            code: 'TRANSFORM_FAILED',
+        });
+    }
+}
+function toTransformFailedError(error, resolvedPath) {
+    if (isAssetServerCompilationError(error))
+        return error;
+    return createAssetServerCompilationError(`Failed to transform style ${resolvedPath}. ${error instanceof Error ? error.message : String(error)}`, {
+        cause: error,
+        code: 'TRANSFORM_FAILED',
+    });
+}
+function isNoEntityError(error) {
+    return (error instanceof Error && 'code' in error && error.code === 'ENOENT');
+}

package/dist/lib/target.d.ts

@@ -0,0 +1,21 @@
+import type { Targets as LightningCssTargets } from 'lightningcss';
+declare const browserTargetNames: readonly ["chrome", "edge", "firefox", "ie", "ios", "opera", "safari", "samsung"];
+export type AssetTargetVersion = `${number}` | `${number}.${number}` | `${number}.${number}.${number}`;
+export type BrowserTargetName = (typeof browserTargetNames)[number];
+export type ResolvedScriptTarget = string[];
+export type ResolvedStyleTarget = LightningCssTargets;
+export interface AssetTarget {
+    chrome?: AssetTargetVersion;
+    edge?: AssetTargetVersion;
+    firefox?: AssetTargetVersion;
+    ie?: AssetTargetVersion;
+    ios?: AssetTargetVersion;
+    opera?: AssetTargetVersion;
+    safari?: AssetTargetVersion;
+    samsung?: AssetTargetVersion;
+    es?: string;
+}
+export declare function resolveScriptTarget(target: AssetTarget | undefined): ResolvedScriptTarget | undefined;
+export declare function resolveStyleTarget(target: AssetTarget | undefined): ResolvedStyleTarget | undefined;
+export {};
+//# sourceMappingURL=target.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"target.d.ts","sourceRoot":"","sources":["../../src/lib/target.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAElE,QAAA,MAAM,kBAAkB,mFASd,CAAA;AAeV,MAAM,MAAM,kBAAkB,GAC1B,GAAG,MAAM,EAAE,GACX,GAAG,MAAM,IAAI,MAAM,EAAE,GACrB,GAAG,MAAM,IAAI,MAAM,IAAI,MAAM,EAAE,CAAA;AACnC,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAA;AACnE,MAAM,MAAM,oBAAoB,GAAG,MAAM,EAAE,CAAA;AAC3C,MAAM,MAAM,mBAAmB,GAAG,mBAAmB,CAAA;AAErD,MAAM,WAAW,WAAW;IAC1B,MAAM,CAAC,EAAE,kBAAkB,CAAA;IAC3B,IAAI,CAAC,EAAE,kBAAkB,CAAA;IACzB,OAAO,CAAC,EAAE,kBAAkB,CAAA;IAC5B,EAAE,CAAC,EAAE,kBAAkB,CAAA;IACvB,GAAG,CAAC,EAAE,kBAAkB,CAAA;IACxB,KAAK,CAAC,EAAE,kBAAkB,CAAA;IAC1B,MAAM,CAAC,EAAE,kBAAkB,CAAA;IAC3B,OAAO,CAAC,EAAE,kBAAkB,CAAA;IAC5B,EAAE,CAAC,EAAE,MAAM,CAAA;CACZ;AAMD,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,oBAAoB,GAAG,SAAS,CAgBlC;AAED,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,mBAAmB,GAAG,SAAS,CAajC"}

package/dist/lib/target.js

@@ -0,0 +1,127 @@
+const browserTargetNames = [
+    'chrome',
+    'edge',
+    'firefox',
+    'ie',
+    'ios',
+    'opera',
+    'safari',
+    'samsung',
+];
+const browserTargetNameSet = new Set(browserTargetNames);
+const lightningCssTargetNameByBrowserTargetName = {
+    chrome: 'chrome',
+    edge: 'edge',
+    firefox: 'firefox',
+    ie: 'ie',
+    ios: 'ios_saf',
+    opera: 'opera',
+    safari: 'safari',
+    samsung: 'samsung',
+};
+export function resolveScriptTarget(target) {
+    let resolvedTarget = normalizeScriptTargetObject(target, 'target');
+    if (!resolvedTarget)
+        return undefined;
+    let oxcTarget = [];
+    if (resolvedTarget.es) {
+        oxcTarget.push(resolvedTarget.es);
+    }
+    for (let browserTargetName of browserTargetNames) {
+        let version = resolvedTarget[browserTargetName];
+        if (version == null)
+            continue;
+        oxcTarget.push(`${browserTargetName}${version}`);
+    }
+    return oxcTarget;
+}
+export function resolveStyleTarget(target) {
+    let resolvedTarget = normalizeStyleTargetObject(target, 'target');
+    if (!resolvedTarget)
+        return undefined;
+    let lightningCssTargets = {};
+    for (let browserTargetName of browserTargetNames) {
+        let version = resolvedTarget[browserTargetName];
+        if (version == null)
+            continue;
+        lightningCssTargets[lightningCssTargetNameByBrowserTargetName[browserTargetName]] =
+            toLightningCssTargetVersion(version);
+    }
+    return lightningCssTargets;
+}
+function normalizeScriptTargetObject(target, optionPath) {
+    if (target == null)
+        return undefined;
+    if (!isPlainObject(target)) {
+        throw new TypeError(`${optionPath} must be an object`);
+    }
+    let normalizedTarget = {};
+    for (let [key, value] of Object.entries(target)) {
+        if (key === 'es') {
+            normalizedTarget.es = normalizeScriptTargetVersion(value, `${optionPath}.es`);
+            continue;
+        }
+        if (!browserTargetNameSet.has(key)) {
+            throw new TypeError(`${optionPath}.${key} is not a supported target`);
+        }
+        normalizedTarget[key] = normalizeBrowserTargetVersion(value, `${optionPath}.${key}`);
+    }
+    return Object.keys(normalizedTarget).length === 0 ? undefined : normalizedTarget;
+}
+function normalizeStyleTargetObject(target, optionPath) {
+    if (target == null)
+        return undefined;
+    if (!isPlainObject(target)) {
+        throw new TypeError(`${optionPath} must be an object`);
+    }
+    let normalizedTarget = {};
+    for (let [key, value] of Object.entries(target)) {
+        if (key === 'es') {
+            continue;
+        }
+        if (!browserTargetNameSet.has(key)) {
+            throw new TypeError(`${optionPath}.${key} is not a supported target`);
+        }
+        normalizedTarget[key] = normalizeBrowserTargetVersion(value, `${optionPath}.${key}`);
+    }
+    return Object.keys(normalizedTarget).length === 0 ? undefined : normalizedTarget;
+}
+function normalizeScriptTargetVersion(value, optionPath) {
+    if (typeof value !== 'string') {
+        throw new TypeError(`${optionPath} must be a string`);
+    }
+    let normalizedValue = value.trim();
+    if (normalizedValue.length === 0) {
+        throw new TypeError(`${optionPath} must be a non-empty string`);
+    }
+    if (!/^\d+$/.test(normalizedValue)) {
+        throw new TypeError(`${optionPath} must use a single numeric year like "2020"`);
+    }
+    if (!/^\d{4}$/.test(normalizedValue) || Number(normalizedValue) < 2015) {
+        throw new TypeError(`${optionPath} must use a four-digit year of 2015 or higher`);
+    }
+    return `es${normalizedValue}`;
+}
+function normalizeBrowserTargetVersion(value, optionPath) {
+    if (typeof value !== 'string') {
+        throw new TypeError(`${optionPath} must be a string`);
+    }
+    if (value.trim().length === 0) {
+        throw new TypeError(`${optionPath} must be a non-empty string`);
+    }
+    if (!/^\d+(\.\d+){0,2}$/.test(value)) {
+        throw new TypeError(`${optionPath} must use "X", "X.Y", or "X.Y.Z" version format`);
+    }
+    let segments = value.split('.').map(Number);
+    if (segments.some((segment) => segment > 255)) {
+        throw new TypeError(`${optionPath} must use version components between 0 and 255`);
+    }
+    return value;
+}
+function toLightningCssTargetVersion(version) {
+    let [major, minor = 0, patch = 0] = version.split('.').map(Number);
+    return major * 65536 + minor * 256 + patch;
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/lib/watch.d.ts

@@ -0,0 +1,22 @@
+import chokidar from 'chokidar';
+type AssetServerWatcherOptions = {
+    ignore?: readonly string[];
+    onChokidarWatcherCreated?: (watcher: ChokidarWatcher) => void;
+    poll?: boolean;
+    pollInterval?: number;
+    onFileEvent(filePath: string, event: AssetServerWatchEvent): Promise<void>;
+    rootDir: string;
+};
+type AssetServerWatchEvent = 'add' | 'change' | 'unlink';
+export type ChokidarWatcher = ReturnType<typeof chokidar.watch>;
+export type AssetServerWatcher = {
+    close(): Promise<void>;
+    getWatchedTargets(): readonly string[];
+    updateWatchedDirectories(delta: {
+        add: readonly string[];
+        remove: readonly string[];
+    }): void;
+};
+export declare function createAssetServerWatcher(options: AssetServerWatcherOptions): AssetServerWatcher;
+export {};
+//# sourceMappingURL=watch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../../src/lib/watch.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAA;AAI/B,KAAK,yBAAyB,GAAG;IAC/B,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAC1B,wBAAwB,CAAC,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,IAAI,CAAA;IAC7D,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAC1E,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,KAAK,qBAAqB,GAAG,KAAK,GAAG,QAAQ,GAAG,QAAQ,CAAA;AACxD,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAA;AAE/D,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACtB,iBAAiB,IAAI,SAAS,MAAM,EAAE,CAAA;IACtC,wBAAwB,CAAC,KAAK,EAAE;QAAE,GAAG,EAAE,SAAS,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;KAAE,GAAG,IAAI,CAAA;CAC7F,CAAA;AAED,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,yBAAyB,GAAG,kBAAkB,CAmD/F"}

package/dist/lib/watch.js

@@ -0,0 +1,96 @@
+import chokidar from 'chokidar';
+import { getFilePathDirectory, normalizeFilePath } from "./paths.js";
+export function createAssetServerWatcher(options) {
+    let watcher = chokidar.watch([], {
+        ignoreInitial: true,
+        ignorePermissionErrors: true,
+        ...resolveChokidarWatchOptions(options),
+    });
+    options.onChokidarWatcherCreated?.(watcher);
+    let watchedDirectories = new Set();
+    let watchedTargets = new Set();
+    for (let event of ['add', 'change', 'unlink']) {
+        watcher.on(event, (filePath) => {
+            options.onFileEvent(filePath, event);
+        });
+    }
+    watcher.on('error', (error) => {
+        console.error('Asset server file system watcher encountered an error.', error);
+    });
+    return {
+        async close() {
+            await watcher.close();
+        },
+        getWatchedTargets() {
+            return [...watchedTargets];
+        },
+        updateWatchedDirectories(delta) {
+            let nextWatchedDirectories = new Set(watchedDirectories);
+            for (let directory of delta.add) {
+                nextWatchedDirectories.add(directory);
+            }
+            for (let directory of delta.remove) {
+                nextWatchedDirectories.delete(directory);
+            }
+            let nextTargets = getWatchTargetsForDirectories(options.rootDir, [...nextWatchedDirectories]);
+            let targetsToAdd = [...nextTargets].filter((target) => !watchedTargets.has(target));
+            let targetsToRemove = [...watchedTargets].filter((target) => !nextTargets.has(target));
+            if (targetsToRemove.length > 0) {
+                watcher.unwatch(targetsToRemove);
+            }
+            if (targetsToAdd.length > 0) {
+                watcher.add(targetsToAdd);
+            }
+            watchedDirectories = nextWatchedDirectories;
+            watchedTargets = nextTargets;
+        },
+    };
+}
+function resolveChokidarWatchOptions(options) {
+    return {
+        awaitWriteFinish: {
+            pollInterval: 10,
+            stabilityThreshold: 10,
+        },
+        depth: 0,
+        ignored: ['**/.git/**', ...(options.ignore ?? [])],
+        interval: options.pollInterval ?? 100,
+        usePolling: options.poll ?? false,
+    };
+}
+function getWatchTargetsForDirectories(rootDir, directories) {
+    let normalizedRootDir = normalizeFilePath(rootDir);
+    let targets = new Set();
+    let configAncestors = new Set();
+    for (let directory of directories) {
+        let normalizedDirectory = normalizeFilePath(directory).replace(/\/+$/, '');
+        targets.add(normalizedDirectory);
+        if (!isSameOrDescendantPath(normalizedDirectory, normalizedRootDir))
+            continue;
+        for (let ancestor of getAncestorPaths(normalizedDirectory, normalizedRootDir)) {
+            configAncestors.add(ancestor);
+        }
+    }
+    for (let ancestor of configAncestors) {
+        targets.add(ancestor);
+    }
+    return targets;
+}
+function getAncestorPaths(directoryPath, rootDir) {
+    let ancestors = [];
+    let currentDirectory = directoryPath;
+    while (isSameOrDescendantPath(currentDirectory, rootDir)) {
+        ancestors.push(currentDirectory);
+        if (currentDirectory === rootDir)
+            break;
+        let parentDirectory = getFilePathDirectory(currentDirectory);
+        if (parentDirectory === currentDirectory)
+            break;
+        currentDirectory = parentDirectory;
+    }
+    return ancestors;
+}
+function isSameOrDescendantPath(filePath, directoryPath) {
+    let normalizedDirectoryPath = directoryPath.replace(/\/+$/, '');
+    return filePath === normalizedDirectoryPath || filePath.startsWith(`${normalizedDirectoryPath}/`);
+}