@master/css-vite 0.0.0-site.1793659883.g69c9aebcf628

package/dist/utils/build-import-resolver.d.ts

@@ -0,0 +1,29 @@
+import { MasterCSSStylesheetImportResolver } from "@master/css-compiler/stylesheet";
+import { MasterCSSVitePluginContext } from "../core.js";
+interface ImportResolverContext {
+  resolve?: (id: string, importer: string, options: {
+    skipSelf: true;
+  }) => Promise<{
+    id: string;
+    external?: boolean | string;
+  } | null>;
+  addWatchFile?: (id: string) => void;
+  load?: (options: {
+    id: string;
+  }) => Promise<{
+    meta: Record<string, unknown>;
+  }>;
+}
+declare function clearBuildStylesheetSources(context: MasterCSSVitePluginContext): void;
+/** Capture loader CSS before Master or Vite transforms replace it. */
+declare function captureBuildStylesheetSource(context: MasterCSSVitePluginContext, id: string, source: string): {
+  "master-css:stylesheet-source": string;
+} | undefined;
+/** Graph-only loads must not create another unconditional stylesheet entry. */
+declare function removeGraphOnlyStylesheetEntries(context: MasterCSSVitePluginContext, getModuleInfo: (id: string) => {
+  importers: readonly string[];
+  dynamicImporters: readonly string[];
+} | null): void;
+/** Reuse Vite/plugin resolution, including aliases and browser import conditions. */
+declare function getBuildImportResolver(context: MasterCSSVitePluginContext, plugin: ImportResolverContext): MasterCSSStylesheetImportResolver | undefined;
+export { captureBuildStylesheetSource, clearBuildStylesheetSources, getBuildImportResolver, removeGraphOnlyStylesheetEntries };

package/dist/utils/build-import-resolver.js

@@ -0,0 +1,101 @@
+import { normalizeFilePath } from "./path.js";
+import { moduleSourceID, moduleSourceOwner } from "./module-sources.js";
+import { getPreparedSassSource, getPreparedSassSourceMap, getSassSourceFile, prepareBuildSassSource, sassSourceID } from "./build-sass-source.js";
+import { isAbsolute } from "node:path";
+// src/utils/build-import-resolver.ts
+const SOURCE_META = "master-css:stylesheet-source";
+const states = /* @__PURE__ */ new WeakMap();
+function state(context) {
+	let result = states.get(context);
+	if (!result) {
+		result = {
+			sources: /* @__PURE__ */ new Map(),
+			importedModules: /* @__PURE__ */ new Set()
+		};
+		states.set(context, result);
+	}
+	return result;
+}
+function clearBuildStylesheetSources(context) {
+	states.delete(context);
+}
+/** Capture loader CSS before Master or Vite transforms replace it. */
+function captureBuildStylesheetSource(context, id, source) {
+	if (context.config?.command !== "build" || !/\.css(?:[?#].*)?$/i.test(id)) return;
+	state(context).sources.set(id, source);
+	return { [SOURCE_META]: source };
+}
+/** Graph-only loads must not create another unconditional stylesheet entry. */
+function removeGraphOnlyStylesheetEntries(context, getModuleInfo) {
+	for (const id of state(context).importedModules) {
+		const info = getModuleInfo(id);
+		if (info && !info.importers.length && !info.dynamicImporters.length) context.stylesheets?.delete(id);
+	}
+}
+/** Reuse Vite/plugin resolution, including aliases and browser import conditions. */
+function getBuildImportResolver(context, plugin) {
+	if (!plugin.resolve) return;
+	return async (specifier, importer) => {
+		if (/^(?:https?:|data:|\/\/|#)/i.test(specifier)) return null;
+		const scoped = moduleSourceOwner(importer);
+		const owner = scoped?.owner ?? getSassSourceFile(importer);
+		const result = await plugin.resolve(specifier, scoped?.file ?? owner ?? importer, { skipSelf: true });
+		if (!result) return;
+		if (result.external) return specifier === "@master/css" || specifier === "@master/css-preset" ? void 0 : null;
+		const sassFile = getSassSourceFile(result.id);
+		const original = sassFile ?? result.id.replace(/[?#].*$/, "");
+		const originalFile = isAbsolute(original) ? normalizeFilePath(original) : original;
+		const preparedOwner = owner && getPreparedSassSource(context, owner);
+		const scopedSource = preparedOwner && (await preparedOwner.prepared).moduleSources?.get(originalFile);
+		if (typeof scopedSource === "string") {
+			plugin.addWatchFile?.(originalFile);
+			const id = moduleSourceID(owner, originalFile);
+			return {
+				id,
+				source: scopedSource,
+				baseFile: originalFile,
+				sourceMap: await getPreparedSassSourceMap(context, id)
+			};
+		}
+		if (sassFile) {
+			plugin.addWatchFile?.(sassFile);
+			const prepared = await prepareBuildSassSource(context, sassFile, (file) => plugin.addWatchFile?.(file));
+			for (const dependency of prepared.deps ?? []) plugin.addWatchFile?.(dependency);
+			return {
+				id: sassSourceID(sassFile),
+				source: prepared.code,
+				baseFile: sassFile,
+				sourceMap: await getPreparedSassSourceMap(context, sassFile)
+			};
+		}
+		const file = result.id.replace(/(\.(?:css|scss|sass))(?:[?#].*)$/i, "$1");
+		if (isAbsolute(file) && /\.(?:scss|sass)$/i.test(file)) {
+			plugin.addWatchFile?.(file);
+			const prepared = await prepareBuildSassSource(context, file, (file) => plugin.addWatchFile?.(file));
+			for (const dependency of prepared.deps ?? []) plugin.addWatchFile?.(dependency);
+			return {
+				id: file,
+				source: prepared.code,
+				baseFile: file,
+				sourceMap: await getPreparedSassSourceMap(context, file)
+			};
+		}
+		if (isAbsolute(file) && /\.css$/i.test(file)) return file;
+		if (result.id.startsWith("\0") && /\.css(?:[?#].*)?$/i.test(result.id) && plugin.load) {
+			const loaded = state(context);
+			loaded.importedModules.add(result.id);
+			if (!loaded.sources.has(result.id)) {
+				const cachedSource = (await plugin.load({ id: result.id })).meta[SOURCE_META];
+				if (!loaded.sources.has(result.id) && typeof cachedSource === "string") loaded.sources.set(result.id, cachedSource);
+			}
+			const source = loaded.sources.get(result.id);
+			if (source === void 0) throw new Error(`CSS loader did not provide source: ${result.id}`);
+			return {
+				id: result.id,
+				source,
+				baseFile: getSassSourceFile(result.id)
+			};
+		}
+	};
+}
+export { captureBuildStylesheetSource, clearBuildStylesheetSources, getBuildImportResolver, removeGraphOnlyStylesheetEntries };

package/dist/utils/build-sass-source.d.ts

@@ -0,0 +1,38 @@
+import { preprocessCSS } from "vite";
+import { MasterCSSVitePluginContext } from "../core.js";
+import { ModuleSourceDiagnostic } from "./module-sources.js";
+type PreparedSource = Awaited<ReturnType<typeof preprocessCSS>> & {
+  moduleSources?: Map<string, string>;
+  moduleDiagnostics?: Map<string, ModuleSourceDiagnostic>;
+};
+declare function getSassSourceFile(id: string): string | undefined;
+declare function sassSourceID(file: string): string;
+declare function sassModuleID(file: string): string;
+declare function isSassModuleID(id: string): boolean;
+declare function isRawStyleRequest(id: string): boolean;
+declare function clearBuildSassSources(context: MasterCSSVitePluginContext): void;
+/** Invalidate every prepared owner of an edited source or composed dependency. */
+declare function invalidatePreparedSassSources(context: MasterCSSVitePluginContext, file: string): string[];
+declare function getPreparedSassSource(context: MasterCSSVitePluginContext, id: string): {
+  source: string;
+  dependencies: Set<string>;
+  file: string;
+  prepared: Promise<PreparedSource>;
+} | undefined;
+/** Diagnostics for a projected child use its own source and generated map. */
+declare function getPreparedSassDiagnosticSource(context: MasterCSSVitePluginContext, id: string): Promise<{
+  file: string;
+  source: string;
+  generatedID: string;
+  prepared: PreparedSource;
+} | {
+  file: string;
+  source: string;
+  generatedID: string;
+  prepared: ModuleSourceDiagnostic;
+} | undefined>;
+/** Carry the host's map alongside CSS so reference lookup can retain partial origins. */
+declare function getPreparedSassSourceMap(context: MasterCSSVitePluginContext, id: string): Promise<string | undefined>;
+/** Use Vite's preprocessors/Modules and URL rebasing, leaving imports for Rust. */
+declare function prepareBuildSassSource(context: MasterCSSVitePluginContext, file: string, onDependency?: (file: string) => void): Promise<PreparedSource>;
+export { clearBuildSassSources, getPreparedSassDiagnosticSource, getPreparedSassSource, getPreparedSassSourceMap, getSassSourceFile, invalidatePreparedSassSources, isRawStyleRequest, isSassModuleID, prepareBuildSassSource, sassModuleID, sassSourceID };

package/dist/utils/build-sass-source.js

@@ -0,0 +1,225 @@
+import { normalizeFilePath } from "./path.js";
+import { createSassSourceMarkers } from "./sass-source-markers.js";
+import { createModuleSourceProjection, moduleSourceOwner } from "./module-sources.js";
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+import { preprocessCSS } from "vite";
+import { mkdir, mkdtemp, realpath, rm, writeFile } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+// src/utils/build-sass-source.ts
+const CSS_SUFFIX = ".master-css-sass.css";
+const MODULE_PREFIX = "\0master-css:sass-module:";
+const caches = /* @__PURE__ */ new WeakMap();
+function getSassSourceFile(id) {
+	id = id.replace(/[?#].*$/, "");
+	if (id.startsWith(MODULE_PREFIX)) return decodeURIComponent(id.slice(24, -3));
+	if (id.endsWith(CSS_SUFFIX)) return id.slice(0, -20);
+}
+function sassSourceID(file) {
+	return `${file}${CSS_SUFFIX}`;
+}
+function sassModuleID(file) {
+	return MODULE_PREFIX + encodeURIComponent(file) + ".js";
+}
+function isSassModuleID(id) {
+	return id.startsWith(MODULE_PREFIX);
+}
+function isRawStyleRequest(id) {
+	return /[?&](?:raw|url)(?:[=&]|$)/.test(id);
+}
+function clearBuildSassSources(context) {
+	caches.delete(context);
+}
+/** Invalidate every prepared owner of an edited source or composed dependency. */
+function invalidatePreparedSassSources(context, file) {
+	file = normalizeFilePath(file);
+	const cache = caches.get(context);
+	const affected = [];
+	for (const [owner, entry] of cache ?? []) {
+		if (owner !== file && !entry.dependencies.has(file)) continue;
+		entry.prepared = void 0;
+		affected.push(owner);
+	}
+	return affected;
+}
+function getPreparedSassSource(context, id) {
+	const file = normalizeFilePath(getSassSourceFile(id) ?? id.replace(/[?#].*$/, ""));
+	const cached = caches.get(context)?.get(file);
+	return cached?.prepared ? {
+		file,
+		...cached,
+		prepared: cached.prepared
+	} : void 0;
+}
+/** Diagnostics for a projected child use its own source and generated map. */
+async function getPreparedSassDiagnosticSource(context, id) {
+	const scoped = moduleSourceOwner(id);
+	const cached = getPreparedSassSource(context, scoped?.owner ?? id);
+	if (!cached) return;
+	const prepared = await cached.prepared;
+	if (!scoped) return {
+		file: cached.file,
+		source: cached.source,
+		generatedID: id,
+		prepared
+	};
+	const child = prepared.moduleDiagnostics?.get(scoped.file);
+	if (child) return {
+		file: scoped.file,
+		source: child.source,
+		generatedID: sassSourceID(scoped.file),
+		prepared: child
+	};
+}
+/** Carry the host's map alongside CSS so reference lookup can retain partial origins. */
+async function getPreparedSassSourceMap(context, id) {
+	const map = (await getPreparedSassDiagnosticSource(context, id))?.prepared.map;
+	return map ? typeof map === "string" ? map : JSON.stringify(map) : void 0;
+}
+/** Use Vite's preprocessors/Modules and URL rebasing, leaving imports for Rust. */
+function prepareBuildSassSource(context, file, onDependency) {
+	if (!context.config) throw new Error("Sass preparation requires resolved Vite configuration.");
+	file = normalizeFilePath(file);
+	let cache = caches.get(context);
+	if (!cache) {
+		cache = /* @__PURE__ */ new Map();
+		caches.set(context, cache);
+	}
+	let cached = cache.get(file);
+	if (!cached?.prepared) {
+		const sourceMarkers = createSassSourceMarkers();
+		const preserveImports = {
+			postcssPlugin: "master-css:preserve-preprocessor-imports",
+			prepare({ root }) {
+				const imports = [];
+				root.walkAtRules((rule) => {
+					if (rule.name.toLowerCase() !== "import") return;
+					imports.push({
+						rule,
+						name: rule.name
+					});
+					rule.name = "--master-css-preserved-import";
+				});
+				return { OnceExit() {
+					for (const { rule, name } of imports) rule.name = name;
+					if (!projection) root.walkComments((comment) => {
+						if (sourceMarkers.markers.has(comment.text.trim())) comment.remove();
+					});
+				} };
+			}
+		};
+		const config = context.config;
+		const source = readFileSync(file, "utf8");
+		const projection = /\.module\.(?:css|scss|sass)$/.test(file) && config.css.modules !== false ? createModuleSourceProjection(file) : void 0;
+		const dependencies = new Set(cached?.dependencies);
+		const discovered = /* @__PURE__ */ new Set();
+		let importDirectory;
+		const importedSources = /* @__PURE__ */ new Map();
+		const originalFile = (id) => projection?.sourceFiles.get(normalizeFilePath(id)) ?? normalizeFilePath(id);
+		const preprocessorConfig = {
+			...config,
+			createResolver(options) {
+				const resolve = config.createResolver(options);
+				const cssImport = options?.extensions?.length === 1 && options.extensions[0] === ".css";
+				return async (...args) => {
+					if (args[1]) args[1] = originalFile(args[1]);
+					const resolved = await resolve(...args);
+					if (resolved && isAbsolute(resolved)) {
+						dependencies.add(originalFile(resolved));
+						discovered.add(originalFile(resolved));
+					}
+					if (resolved && projection && cssImport && /\.(?:scss|sass)$/.test(resolved)) {
+						let prepared = importedSources.get(resolved);
+						if (!prepared) {
+							prepared = prepareImportedSource(resolved);
+							importedSources.set(resolved, prepared);
+						}
+						return prepared;
+					}
+					return resolved;
+				};
+			},
+			css: {
+				...config.css,
+				devSourcemap: true,
+				preprocessorOptions: {
+					...config.css.preprocessorOptions,
+					scss: {
+						...config.css.preprocessorOptions?.scss,
+						sourceMapIncludeSources: true,
+						additionalData: (projection ?? sourceMarkers).additionalData(config.css.preprocessorOptions?.scss?.additionalData)
+					},
+					sass: {
+						...config.css.preprocessorOptions?.sass,
+						sourceMapIncludeSources: true,
+						additionalData: (projection ?? sourceMarkers).additionalData(config.css.preprocessorOptions?.sass?.additionalData)
+					}
+				},
+				transformer: "postcss",
+				postcss: { plugins: [projection?.plugin ?? preserveImports] }
+			}
+		};
+		async function prepareImportedSource(id) {
+			const result = await preprocessCSS(readFileSync(id, "utf8"), id, {
+				...preprocessorConfig,
+				css: {
+					...preprocessorConfig.css,
+					modules: false,
+					postcss: { plugins: [preserveImports] }
+				}
+			});
+			for (const dependency of result.deps ?? []) {
+				discovered.add(originalFile(dependency));
+				dependencies.add(originalFile(dependency));
+			}
+			importDirectory ??= mkdir(config.cacheDir, { recursive: true }).then(() => mkdtemp(join(config.cacheDir, "master-css-sass-import-"))).then((directory) => realpath(directory));
+			const path = normalizeFilePath(join(await importDirectory, `${createHash("sha256").update(id).digest("hex")}.css`));
+			projection.sourceFiles.set(path, id);
+			const raw = typeof result.map === "string" ? JSON.parse(result.map) : result.map;
+			const root = raw && "sourceRoot" in raw && raw.sourceRoot ? raw.sourceRoot.replace(/\/?$/, "/") : "./";
+			const base = isAbsolute(root) ? pathToFileURL(root) : new URL(root, pathToFileURL(id));
+			const map = raw && "sources" in raw && raw.sources ? JSON.stringify({
+				...raw,
+				sourceRoot: "",
+				sources: raw.sources.map((source) => source ? (isAbsolute(source) ? pathToFileURL(source) : new URL(source, base)).href : source)
+			}) : void 0;
+			const annotation = map ? `\n/*# sourceMappingURL=data:application/json;base64,${Buffer.from(map).toString("base64")} */` : "";
+			await writeFile(path, result.code + annotation);
+			return path;
+		}
+		cached = {
+			source,
+			prepared: preprocessCSS(source, file, preprocessorConfig).then((result) => {
+				for (const dependency of result.deps ?? []) discovered.add(originalFile(dependency));
+				if (projection) for (const dependency of result.deps ?? []) {
+					const file = originalFile(dependency);
+					if (/\.css$/i.test(file) && !projection.sources.has(file)) projection.copyDuplicate(file, readFileSync(file, "utf8"));
+				}
+				dependencies.clear();
+				for (const dependency of discovered) dependencies.add(dependency);
+				return {
+					...result,
+					deps: dependencies,
+					...projection ? {
+						moduleSources: projection.sources,
+						moduleDiagnostics: projection.diagnostics
+					} : {}
+				};
+			}).finally(async () => {
+				await Promise.allSettled(importedSources.values());
+				if (importDirectory) await rm(await importDirectory, {
+					recursive: true,
+					force: true
+				});
+			}),
+			dependencies
+		};
+		cache.set(file, cached);
+	}
+	const entry = cached, prepared = entry.prepared;
+	return onDependency ? prepared.finally(() => {
+		for (const dependency of entry.dependencies) onDependency(dependency);
+	}) : prepared;
+}
+export { clearBuildSassSources, getPreparedSassDiagnosticSource, getPreparedSassSource, getPreparedSassSourceMap, getSassSourceFile, invalidatePreparedSassSources, isRawStyleRequest, isSassModuleID, prepareBuildSassSource, sassModuleID, sassSourceID };

package/dist/utils/build-stylesheet-delivery.d.ts

@@ -0,0 +1,12 @@
+import { MasterCSSStylesheetComposition, MasterCSSStylesheetDeliveryOptions } from "@master/css-compiler/stylesheet";
+import { MasterCSSVitePluginContext } from "../core.js";
+import { MasterCSSCompiler } from "@master/css-compiler";
+import { LocalStylesheet } from "./local-stylesheet.js";
+/** These temporary graph URLs are replaced after the full CSS content is known. */
+declare function getBuildStylesheetDelivery(context: MasterCSSVitePluginContext): MasterCSSStylesheetDeliveryOptions | undefined;
+declare function prepareBuildStylesheet(compiler: MasterCSSCompiler, source: string, slotCSSRule: string, extracted: MasterCSSStylesheetComposition, locals?: readonly LocalStylesheet[]): {
+  resources: readonly import("@master/css-compiler/stylesheet").MasterCSSStylesheetResourceAsset[] | undefined;
+  source: string;
+  assets: readonly import("@master/css-binding/protocol").MasterCSSStylesheetAsset[];
+} | undefined;
+export { getBuildStylesheetDelivery, prepareBuildStylesheet };

package/dist/utils/build-stylesheet-delivery.js

@@ -0,0 +1,130 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { extname } from "node:path";
+// src/utils/build-stylesheet-delivery.ts
+function digest(source) {
+	return createHash("sha256").update(source).digest("hex").slice(0, 20);
+}
+/** These temporary graph URLs are replaced after the full CSS content is known. */
+function getBuildStylesheetDelivery(context) {
+	if (context.config?.command !== "build") return;
+	return {
+		entryURL: "./master-css-entry.css",
+		stylesheetURL: (file, variant) => `./master-css-source-${digest(variant ?? file)}.css`,
+		resourceURL: (file) => `./master-css-resource-${digest(readFileSync(file))}${extname(file)}`,
+		relativeResourceURLs: true,
+		resolveNodePackageImports: true
+	};
+}
+function prepareBuildStylesheet(compiler, source, slotCSSRule, extracted, locals = []) {
+	if (locals.length) return prepareLocalBuildStylesheets(compiler, source, slotCSSRule, extracted, locals);
+	const managed = {
+		entry: "master-css-managed",
+		stylesheets: [{
+			id: "master-css-managed",
+			href: "./master-css-entry.css",
+			css: extracted.css
+		}, ...extracted.stylesheets ?? []]
+	};
+	const bundle = compiler.prepareStylesheetBundle({
+		source,
+		from: "master-css-bundle",
+		slotCSSRule,
+		managed
+	});
+	if (!bundle.slots) return;
+	return {
+		...renderBuildStylesheetBundle(compiler, bundle),
+		resources: extracted.resources
+	};
+}
+/**
+* Name fragments after their rendered bytes. Graph node IDs and temporary
+* delivery URLs derive from host file paths, so hashing the prepared bundle
+* would vary with the checkout location.
+*/
+function renderBuildStylesheetBundle(compiler, bundle) {
+	const render = (url) => {
+		const urls = Object.fromEntries(bundle.graph.stylesheets.map((node, index) => [node.id, url(index)]));
+		return {
+			urls,
+			assets: compiler.renderStylesheetBundle({
+				bundle,
+				urls,
+				preserveResourceBase: true
+			})
+		};
+	};
+	const hash = digest(JSON.stringify(render((index) => `./master-css-${index}.css`).assets.map((asset) => asset.css)));
+	const { urls, assets } = render((index) => `./master-css-${hash}-${index}.css`);
+	return {
+		source: `@import "${urls[bundle.graph.entry]}";`,
+		assets
+	};
+}
+/** Compose each local entry at its own position before final content-based naming. */
+function prepareLocalBuildStylesheets(compiler, source, slotCSSRule, extracted, locals) {
+	const entry = "./master-css-host.css";
+	const graph = /* @__PURE__ */ new Map([[entry, {
+		id: entry,
+		href: entry,
+		css: source
+	}]]);
+	const resources = /* @__PURE__ */ new Map();
+	const replacements = [{
+		slot: slotCSSRule,
+		css: extracted.css,
+		stylesheets: extracted.stylesheets,
+		resources: extracted.resources
+	}, ...[...locals].sort((a, b) => a.slot < b.slot ? -1 : a.slot > b.slot ? 1 : 0).map(({ slot, result }) => ({
+		slot,
+		css: result.code,
+		stylesheets: result.stylesheets,
+		resources: result.resources
+	}))];
+	let replaced = false;
+	for (const [replacementIndex, replacement] of replacements.entries()) for (const [assetIndex, asset] of [...graph.values()].entries()) {
+		const bundle = compiler.prepareStylesheetBundle({
+			source: asset.css,
+			from: asset.id,
+			slotCSSRule: replacement.slot,
+			managed: {
+				entry: "managed",
+				stylesheets: [{
+					id: "managed",
+					href: "./master-css-entry.css",
+					css: replacement.css
+				}, ...replacement.stylesheets ?? []]
+			}
+		});
+		if (!bundle.slots) continue;
+		replaced = true;
+		const urls = Object.fromEntries(bundle.graph.stylesheets.map((node, index) => [node.id, node.id === bundle.graph.entry ? asset.href : `./master-css-intermediate-${replacementIndex}-${assetIndex}-${index}.css`]));
+		const assets = compiler.renderStylesheetBundle({
+			bundle,
+			urls,
+			preserveResourceBase: true
+		});
+		for (const next of assets) graph.set(next.href, {
+			id: next.href,
+			href: next.href,
+			css: next.css
+		});
+		for (const resource of replacement.resources ?? []) resources.set(resource.href, resource);
+	}
+	if (!replaced) return;
+	const slot = "#master-css-complete-local-graph{--slot:0}";
+	return {
+		...renderBuildStylesheetBundle(compiler, compiler.prepareStylesheetBundle({
+			source: slot,
+			from: "master-css-output",
+			slotCSSRule: slot,
+			managed: {
+				entry,
+				stylesheets: [...graph.values()]
+			}
+		})),
+		resources: [...resources.values()]
+	};
+}
+export { getBuildStylesheetDelivery, prepareBuildStylesheet };

package/dist/utils/build-watch-recovery.d.ts

@@ -0,0 +1,10 @@
+import { ResolvedConfig } from "vite";
+import { MasterCSSVitePluginContext } from "../core.js";
+import { DependencyHost } from "./failed-stylesheet-dependencies.js";
+type BuildWatch = ResolvedConfig['build']['watch'];
+/** Allocate during config resolution; retain every started owner. */
+declare function prepareBuildStylesheetRecovery(context: MasterCSSVitePluginContext, root: string, cacheDir: string, watch: BuildWatch, environment?: object): void;
+/** An existing owned cache file lets the build host invalidate failed modules. */
+declare function trackBuildStylesheetRecovery(context: MasterCSSVitePluginContext, host: DependencyHost, key: string, id: string, versions: Map<string, string>): void;
+declare function closeBuildStylesheetRecovery(context: MasterCSSVitePluginContext, environment: object): void;
+export { closeBuildStylesheetRecovery, prepareBuildStylesheetRecovery, trackBuildStylesheetRecovery };

package/dist/utils/build-watch-recovery.js

@@ -0,0 +1,119 @@
+import { clearFailedDependencyReconciliation, trackFailedDependencyReconciliation } from "./failed-dependency-reconciliation.js";
+import { mkdirSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { createFilter } from "vite";
+// src/utils/build-watch-recovery.ts
+const recoveries = /* @__PURE__ */ new WeakMap();
+const held = /* @__PURE__ */ new Set();
+function retain(state, environment) {
+	state.owners.add(environment);
+	held.add(state.directory);
+}
+function running(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code === "EPERM";
+	}
+}
+/**
+* Configuration has to allocate before the host can say whether the build will
+* start, and the host runs no hook after a failure during configuration or
+* environment creation, so material from such a run outlives it. Reclaim it
+* here instead: the owning process id is in the directory name, so a directory
+* is stale when no owner in this process holds it and the process that
+* allocated it is gone or is this one.
+*/
+function sweepStaleRecoveries(base, prefix) {
+	let entries;
+	try {
+		entries = readdirSync(base);
+	} catch {
+		return;
+	}
+	for (const entry of entries) {
+		if (!entry.startsWith(prefix)) continue;
+		const directory = join(base, entry);
+		if (held.has(directory)) continue;
+		const pid = Number.parseInt(entry.slice(prefix.length), 10);
+		if (pid !== process.pid && Number.isInteger(pid) && running(pid)) continue;
+		rmSync(directory, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+/**
+* The build host applies `build.watch` include and exclude to every watched
+* file, plugin-added ones included, so a project filter can silently drop the
+* file recovery depends on. Take the first location the project's own filter
+* accepts rather than overriding what it asked for.
+*/
+function resolveRecoveryLocation(root, cacheDir, watch) {
+	const accepts = createFilter(watch?.include, watch?.exclude, { resolve: false });
+	return [
+		{
+			base: cacheDir,
+			prefix: "master-css-watch-",
+			name: "invalidate"
+		},
+		{
+			base: cacheDir,
+			prefix: "master-css-watch-",
+			name: "invalidate.css"
+		},
+		{
+			base: root,
+			prefix: ".master-css-watch-",
+			name: "invalidate.css"
+		}
+	].find(({ base, prefix, name }) => accepts(join(base, `${prefix}probe`, name)));
+}
+/** Allocate during config resolution; retain every started owner. */
+function prepareBuildStylesheetRecovery(context, root, cacheDir, watch, environment) {
+	const existing = recoveries.get(context);
+	if (existing) {
+		if (environment) retain(existing, environment);
+		return;
+	}
+	const location = resolveRecoveryLocation(root, cacheDir, watch);
+	if (!location) return;
+	mkdirSync(location.base, { recursive: true });
+	sweepStaleRecoveries(location.base, location.prefix);
+	const directory = mkdtempSync(join(location.base, `${location.prefix}${process.pid}-`)), file = join(directory, location.name);
+	writeFileSync(file, "pending");
+	const state = {
+		directory,
+		file,
+		owners: /* @__PURE__ */ new Set()
+	};
+	recoveries.set(context, state);
+	if (environment) retain(state, environment);
+}
+/** An existing owned cache file lets the build host invalidate failed modules. */
+function trackBuildStylesheetRecovery(context, host, key, id, versions) {
+	const state = recoveries.get(context);
+	if (!versions.size || !host.addWatchFile || !state) return;
+	const environment = host.environment ?? context;
+	retain(state, environment);
+	host.addWatchFile(state.file);
+	trackFailedDependencyReconciliation(context, environment, key, id, versions, async (_environment, _id, _changed, active) => {
+		if (active()) writeFileSync(state.file, String(process.hrtime.bigint()));
+	});
+}
+function closeBuildStylesheetRecovery(context, environment) {
+	clearFailedDependencyReconciliation(context, environment);
+	const state = recoveries.get(context);
+	if (!state) return;
+	state.owners.delete(environment);
+	if (!state.owners.size) {
+		rmSync(state.directory, {
+			recursive: true,
+			force: true
+		});
+		held.delete(state.directory);
+		recoveries.delete(context);
+	}
+}
+export { closeBuildStylesheetRecovery, prepareBuildStylesheetRecovery, trackBuildStylesheetRecovery };

package/dist/utils/coalesced-task.d.ts

@@ -0,0 +1,3 @@
+/** Keep one active operation and collapse pending events into its latest follow-up. */
+declare function createCoalescedTask(work: () => Promise<void>, onError: (error: unknown) => void): () => Promise<void>;
+export { createCoalescedTask };