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

package/dist/node-compiler.js

@@ -0,0 +1,417 @@
+import { pureCSSCache } from "./pure-css-cache.js";
+import { noticeDiagnostics } from "./notices.js";
+import { isExpandableImportSource, prepareCSSImportGraph, resolveMasterCSSPackageEntryFile, resolveNodePackageCSS, resolveRelativeCSSFile, stylesheetResourceOwner } from "./node-imports.js";
+import { compilePreparedGraph } from "./prepared-graph-cache.js";
+import { emptyExtractionPolicy } from "./contracts.js";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { extname, isAbsolute, resolve } from "node:path";
+import { MASTER_CSS_DIAGNOSTIC_VERSION, MasterCSSError } from "@master/css-schema";
+import { realpathSync } from "node:fs";
+import { createCompilerBindingSessionSync } from "@master/css-binding/compiler/node";
+// src/node-compiler.ts
+/** @internal Node-only compiler and import-graph implementation. */
+const MASTER_CSS_PACKAGE_ID = "@master/css";
+function throwCompilerBindingError(error) {
+	if (error instanceof MasterCSSError) throw error;
+	throw new MasterCSSError({
+		code: "CSS_COMPILER_ERROR",
+		domain: "compiler",
+		message: error instanceof Error ? error.message : String(error)
+	}, { cause: error });
+}
+function callCompilerBinding(call) {
+	try {
+		return call();
+	} catch (error) {
+		throwCompilerBindingError(error);
+	}
+}
+function nativeCompiler() {
+	return createCompilerBindingSessionSync();
+}
+function inspectCSS(source) {
+	return callCompilerBinding(() => nativeCompiler().inspectCSS(source));
+}
+function resolveCSSImportGraph(file, options = {}) {
+	return resolveCSSImportGraphSource(file, void 0, options);
+}
+function resolveCSSImportGraphSource(file, source, options = {}) {
+	const entry = resolve(file);
+	const graph = prepareCSSImportGraph(file, source, options, analyzeCSSDependencies);
+	for (const [inputFile, inputSource] of Object.entries(graph.files)) options.onSource?.(inputFile, inputSource);
+	const result = callCompilerBinding(() => nativeCompiler().resolveCSSImportGraph(graph));
+	for (const reference of result.references || []) options.onReference?.(reference, reference.file || entry);
+	return result;
+}
+function analyzeCSSDependencies(source) {
+	return pureCSSCache.run("dependencies", source, () => callCompilerBinding(() => nativeCompiler().analyzeCSSDependencies(source)));
+}
+function resolveMasterCSSPackageImportGraph(projectDir) {
+	const entry = resolveMasterCSSPackageEntryFile(MASTER_CSS_PACKAGE_ID, projectDir || process.cwd(), projectDir);
+	if (!entry) throw new Error(`Cannot resolve ${MASTER_CSS_PACKAGE_ID} CSS entry.`);
+	return resolveCSSImportGraph(entry, { projectDir });
+}
+function stripRequestSuffix(id) {
+	const searchStart = id.startsWith("//?/") || id.startsWith("\\\\?\\") ? 4 : 0;
+	const suffixIndex = id.slice(searchStart).search(/[?#]/);
+	return suffixIndex === -1 ? id : id.slice(0, searchStart + suffixIndex);
+}
+function stripWindowsExtendedPathPrefix(file) {
+	const match = /^[/\\]{2}\?[/\\](?:(UNC)[/\\])?/i.exec(file);
+	if (!match) return file;
+	const path = file.slice(match[0].length);
+	return match[1] ? `\\\\${path}` : path;
+}
+function stripRequest(id) {
+	return stripRequestSuffix(id);
+}
+function resolveComparablePath(file) {
+	const filename = resolve(file);
+	try {
+		return realpathSync(filename);
+	} catch {
+		return filename;
+	}
+}
+function isMasterCSSPackageStyleFile(id, projectDir) {
+	const filename = resolveComparablePath(stripRequest(id));
+	if (extname(filename) !== ".css") return false;
+	try {
+		return resolveMasterCSSPackageImportGraph(projectDir).dependencies.some((dependency) => {
+			return resolveComparablePath(dependency) === filename;
+		});
+	} catch {
+		return false;
+	}
+}
+function compileCSS(source, options = {}) {
+	const from = options.from || "master.css";
+	const bindingOptions = {
+		from,
+		resourceOwner: stylesheetResourceOwner(from),
+		preserveNativeCSS: options.preserveNativeCSS !== false,
+		pruneNativeCSS: options.pruneNativeCSS === true,
+		...options.preserveNativeSource === void 0 ? {} : { preserveNativeSource: options.preserveNativeSource },
+		...options.classes ? { classes: options.classes } : {}
+	};
+	const result = reviveBindingCompileResult(pureCSSCache.run("directives", [source, bindingOptions], () => callCompilerBinding(() => nativeCompiler().compileCSSDirectives(source, bindingOptions))));
+	for (const warning of result.warnings) options.onDiagnostic?.(compilerWarningDiagnostic(warning));
+	return result;
+}
+function reviveBindingCompileResult(result) {
+	result.extractionPolicy.blocklist = result.extractionPolicy.blocklist.map((entry) => {
+		if (entry && typeof entry === "object" && "source" in entry && typeof entry.source === "string") return new RegExp(entry.source, "flags" in entry && typeof entry.flags === "string" ? entry.flags : "");
+		return entry;
+	});
+	return result;
+}
+function compilerWarningDiagnostic(message) {
+	return Object.freeze({
+		version: MASTER_CSS_DIAGNOSTIC_VERSION,
+		code: "COMPILER_WARNING",
+		domain: "compiler",
+		severity: "warning",
+		message
+	});
+}
+function toWireExtractionPolicy(policy) {
+	return {
+		...emptyExtractionPolicy(),
+		...policy,
+		include: [...policy?.include || []],
+		exclude: [...policy?.exclude || []],
+		safelist: [...policy?.safelist || []],
+		blocklist: toWireBlocklist(policy?.blocklist)
+	};
+}
+function toWireBlocklist(blocklist) {
+	return [...blocklist || []].map((entry) => entry instanceof RegExp ? {
+		source: entry.source,
+		flags: entry.flags
+	} : entry);
+}
+function filterCSSExtractionCandidates(candidates, blocklist = []) {
+	return [...nativeCompiler().filterCSSExtractionCandidates(candidates, toWireBlocklist(blocklist))];
+}
+function reviveExtractionPolicy(policy) {
+	policy.blocklist = policy.blocklist.map((entry) => {
+		if (entry && typeof entry === "object" && "source" in entry && typeof entry.source === "string") return new RegExp(entry.source, "flags" in entry && typeof entry.flags === "string" ? entry.flags : "");
+		return entry;
+	});
+	return policy;
+}
+function mergeCSSDirectiveExtractionPolicy(...policies) {
+	return reviveExtractionPolicy(callCompilerBinding(() => nativeCompiler().mergeCSSExtractionPolicies(policies.map(toWireExtractionPolicy))));
+}
+function createCSSDirectiveExtractionPolicy() {
+	return mergeCSSDirectiveExtractionPolicy();
+}
+function analyzeStandaloneDirectives(source) {
+	const result = callCompilerBinding(() => nativeCompiler().analyzeStandaloneDirectives(source));
+	result.extractionPolicy = reviveExtractionPolicy(result.extractionPolicy);
+	return result;
+}
+function findStandaloneCSSDirectiveStatements(source) {
+	return analyzeStandaloneDirectives(source).statements;
+}
+function collectStandaloneCSSDirectiveExtractionPolicy(source) {
+	return analyzeStandaloneDirectives(source).extractionPolicy;
+}
+function removeStandaloneCSSDirectives(source) {
+	return analyzeStandaloneDirectives(source).code;
+}
+function compileManifestInputWithBinding(input, baseManifest) {
+	return callCompilerBinding(() => nativeCompiler().compileManifestInput(input, baseManifest ? { baseManifest } : void 0)).manifest;
+}
+function lowerCSSDirectivesWithBinding(result, options) {
+	const lowered = callCompilerBinding(() => nativeCompiler().lowerCSSDirectives({
+		manifestInput: result.manifestInput,
+		definitionSources: result.definitionSources || [],
+		nativeOutput: result.nativeOutput,
+		styleDefinitions: result.styleDefinitions || [],
+		warnings: result.warnings
+	}, {
+		...options.baseManifest ? { baseManifest: options.baseManifest } : {},
+		...options.resolutionManifest ? { resolutionManifest: options.resolutionManifest } : {}
+	}, options.sourceText));
+	for (const warning of lowered.warnings) options.onDiagnostic?.(compilerWarningDiagnostic(warning));
+	noticeDiagnostics(lowered.notices, options.onDiagnostic);
+	return lowered;
+}
+function addUnique(target, values) {
+	if (!values) return;
+	for (const value of values) if (!target.includes(value)) target.push(value);
+}
+function resolveCSSReferenceFile(reference, options = {}) {
+	if (reference.resolvedFile) return reference.resolvedFile;
+	const fromFile = reference.file ? isAbsolute(reference.file) ? reference.file : resolve(options.root || "", reference.file) : resolve(options.root || process.cwd(), "master.css");
+	const packageFile = resolveMasterCSSPackageEntryFile(reference.source, fromFile, options.root);
+	if (packageFile) return packageFile;
+	const exportedCSS = resolveNodePackageCSS(reference.source, fromFile);
+	if (exportedCSS) return exportedCSS;
+	if (isExpandableImportSource(reference.source, fromFile)) return resolveRelativeCSSFile(reference.source, fromFile);
+	throw new Error(`@reference only supports relative CSS files or exported package CSS entries: ${reference.source}`);
+}
+function normalizeReferenceStack(stack) {
+	return (stack || []).map((file) => resolveComparablePath(file));
+}
+function resolveCSSReferenceContext(references, options = {}) {
+	const dependencies = [];
+	const warnings = [];
+	let manifest = options.baseManifest;
+	let hasReferences = false;
+	const definitionSources = [];
+	for (const reference of references || []) {
+		const referenceFile = resolveCSSReferenceFile(reference, options);
+		options.onDependency?.(referenceFile);
+		const comparableReferenceFile = resolveComparablePath(referenceFile);
+		if (normalizeReferenceStack(options.referenceStack).includes(comparableReferenceFile)) throw new Error(`Circular CSS reference: ${[...options.referenceStack || [], referenceFile].join(" -> ")}`);
+		const result = compileCSSManifestFileInternal(referenceFile, {
+			...options,
+			baseManifest: manifest,
+			preserveNativeCSS: false,
+			definitionsOnly: true,
+			referenceResources: options.resolveReferenceResources,
+			referenceStack: options.referenceStack
+		});
+		definitionSources.push(...result.definitionSources || []);
+		hasReferences = true;
+		manifest = result.manifest;
+		addUnique(dependencies, result.dependencies);
+		addUnique(warnings, result.warnings);
+	}
+	return {
+		dependencies,
+		warnings,
+		definitionSources,
+		...hasReferences ? { manifest } : {}
+	};
+}
+function toCompileCSSManifestResult(result, options = {}) {
+	const { manifestInput: _directiveManifestInput, ...directiveData } = result;
+	const referenceContext = resolveCSSReferenceContext(result.references, options);
+	const definitionSources = [...referenceContext.definitionSources, ...result.definitionSources || []];
+	const lowerResult = lowerCSSDirectivesWithBinding({
+		...result,
+		definitionSources
+	}, {
+		baseManifest: options.baseManifest,
+		resolutionManifest: referenceContext.manifest,
+		onDiagnostic: options.onDiagnostic,
+		sourceText: options.sourceText
+	});
+	const dependencies = [];
+	const warnings = [];
+	addUnique(dependencies, result.dependencies);
+	addUnique(dependencies, referenceContext.dependencies);
+	addUnique(warnings, referenceContext.warnings);
+	addUnique(warnings, lowerResult.warnings);
+	const generatedCSS = lowerResult.generatedCSS || "";
+	const css = lowerResult.css ?? [result.nativeCSS, generatedCSS].filter(Boolean).join("\n");
+	return {
+		...directiveData,
+		definitionSources: lowerResult.definitionSources,
+		notices: lowerResult.notices,
+		...lowerResult.css === void 0 ? {} : { outputMappings: lowerResult.outputMappings ?? [] },
+		dependencies,
+		manifest: lowerResult.manifest,
+		resolutionManifest: lowerResult.resolutionManifest,
+		warnings,
+		generatedCSS,
+		generatedMappings: lowerResult.generatedMappings,
+		css,
+		directives: result
+	};
+}
+/** Compile original files independently before merging their manifest and native output. */
+function compileCSSManifestGraph(graph, options = {}) {
+	const references = Object.entries(graph.files).flatMap(([file, source]) => {
+		const references = compileCSS(source, {
+			from: file,
+			preserveNativeCSS: false
+		}).references || [];
+		return options.mapReferences?.(file, source, references) ?? references;
+	});
+	const referenceContext = resolveCSSReferenceContext(references, options);
+	const resourceDependencies = [];
+	const resourceURLs = options.referenceResources ? Object.fromEntries(Object.entries(graph.files).map(([file, source]) => [file, Object.fromEntries(analyzeCSSDependencies(source).resources.flatMap(({ url }) => {
+		if (url.startsWith("/") || url.startsWith("#") || /^[a-z][a-z\d+.-]*:/i.test(url)) return [];
+		const resource = new URL(url, pathToFileURL(file));
+		const owner = fileURLToPath(resource);
+		resourceDependencies.push(owner);
+		options.onDependency?.(owner);
+		return [[url, resource.href]];
+	}))])) : void 0;
+	const compiled = callCompilerBinding(() => compilePreparedGraph(nativeCompiler(), {
+		graph,
+		...options.definitionsOnly ? { nativeStylesheets: [] } : {},
+		urls: Object.fromEntries(Object.keys(graph.files).map((file) => [file, pathToFileURL(file).href])),
+		baseManifest: options.baseManifest,
+		resolutionManifest: referenceContext.manifest,
+		definitionSources: referenceContext.definitionSources,
+		resourceURLs,
+		options: {
+			from: graph.entry,
+			preserveNativeCSS: options.preserveNativeCSS !== false,
+			pruneNativeCSS: options.pruneNativeCSS === true,
+			...options.preserveNativeSource === void 0 ? {} : { preserveNativeSource: options.preserveNativeSource },
+			...options.classes ? { classes: options.classes } : {}
+		},
+		inlineImports: true
+	}));
+	const directives = reviveBindingCompileResult(compiled.directives);
+	directives.references = references.length ? references : void 0;
+	const dependencies = [.../* @__PURE__ */ new Set([
+		...directives.dependencies,
+		...referenceContext.dependencies,
+		...resourceDependencies
+	])];
+	const warnings = [.../* @__PURE__ */ new Set([...directives.warnings, ...referenceContext.warnings])];
+	for (const warning of warnings) options.onDiagnostic?.(compilerWarningDiagnostic(warning));
+	noticeDiagnostics(directives.notices, options.onDiagnostic);
+	const entry = compiled.stylesheets.find((sheet) => sheet.id === compiled.entry);
+	return {
+		...directives,
+		dependencies,
+		warnings,
+		css: entry.css,
+		outputMappings: entry.outputMappings,
+		sourceTexts: graph.files,
+		manifest: compiled.manifest,
+		resolutionManifest: compiled.resolutionManifest,
+		directives,
+		stylesheets: compiled.stylesheets
+	};
+}
+function createManifestFromCSSResult(result, options = {}) {
+	return toCompileCSSManifestResult(result, options);
+}
+function compileCSSManifest(source, options = {}) {
+	const from = options.from ? stripRequest(options.from) : void 0;
+	const fromFile = from ? isAbsolute(from) ? from : resolve(options.root || "", from) : void 0;
+	return toCompileCSSManifestResult(compileCSS(source, {
+		...options,
+		...fromFile ? { from: fromFile } : {}
+	}), {
+		...options,
+		sourceText: source,
+		...fromFile ? {
+			from: fromFile,
+			referenceStack: [...options.referenceStack || [], fromFile]
+		} : {}
+	});
+}
+function compileCSSManifestFileInternal(file, options = {}) {
+	const absoluteFile = isAbsolute(file) ? file : resolve(options.root || "", file);
+	return compileCSSManifestGraph(prepareCSSImportGraph(absoluteFile, void 0, {
+		projectDir: options.root,
+		onDependency: options.onDependency
+	}, analyzeCSSDependencies), {
+		...options,
+		preserveNativeCSS: options.preserveNativeCSS ?? true,
+		from: absoluteFile,
+		referenceStack: [...options.referenceStack || [], absoluteFile]
+	});
+}
+function compileCSSManifestFile(file, options = {}) {
+	return compileCSSManifestFileInternal(file, options);
+}
+function compileProjectManifest(entries, options = {}) {
+	const dependencies = [];
+	let extractionPolicy = createCSSDirectiveExtractionPolicy();
+	const classNames = [];
+	const nativeClassNames = [];
+	const nativeCSS = [];
+	const css = [];
+	const generatedCSS = [];
+	const warnings = [];
+	let directives = {
+		manifestInput: {},
+		extractionPolicy: createCSSDirectiveExtractionPolicy(),
+		classNames: [],
+		nativeClassNames: [],
+		nativeCSS: "",
+		css: "",
+		generatedCSS: "",
+		warnings: [],
+		dependencies: []
+	};
+	let manifest = options.baseManifest;
+	for (const entry of entries) {
+		const manifestResult = compileCSSManifestFile(entry, {
+			...options,
+			baseManifest: manifest,
+			preserveNativeCSS: options.preserveNativeCSS ?? true
+		});
+		const result = manifestResult.directives;
+		directives = result;
+		extractionPolicy = mergeCSSDirectiveExtractionPolicy(extractionPolicy, result.extractionPolicy);
+		addUnique(dependencies, result.dependencies);
+		addUnique(classNames, result.classNames);
+		addUnique(nativeClassNames, result.nativeClassNames);
+		addUnique(warnings, result.warnings);
+		manifest = manifestResult.manifest;
+		addUnique(dependencies, manifestResult.dependencies);
+		addUnique(warnings, manifestResult.warnings);
+		const entryGeneratedCSS = manifestResult.generatedCSS || "";
+		if (result.nativeCSS) nativeCSS.push(result.nativeCSS);
+		if (entryGeneratedCSS) generatedCSS.push(entryGeneratedCSS);
+		if (manifestResult.css) css.push(manifestResult.css);
+	}
+	const resolvedManifest = manifest || compileManifestInputWithBinding({}, void 0);
+	return {
+		entries,
+		manifest: resolvedManifest,
+		resolutionManifest: resolvedManifest,
+		dependencies,
+		extractionPolicy,
+		classNames,
+		nativeClassNames,
+		nativeCSS: nativeCSS.join("\n"),
+		css: css.join("\n"),
+		generatedCSS: generatedCSS.join("\n"),
+		warnings,
+		directives
+	};
+}
+export { analyzeCSSDependencies, collectStandaloneCSSDirectiveExtractionPolicy, compileCSS, compileCSSManifest, compileCSSManifestFile, compileCSSManifestGraph, compileProjectManifest, createCSSDirectiveExtractionPolicy, createManifestFromCSSResult, filterCSSExtractionCandidates, findStandaloneCSSDirectiveStatements, inspectCSS, isMasterCSSPackageStyleFile, mergeCSSDirectiveExtractionPolicy, removeStandaloneCSSDirectives, resolveCSSImportGraph, resolveCSSImportGraphSource, resolveCSSReferenceFile, resolveMasterCSSPackageEntryFile, resolveMasterCSSPackageImportGraph, stripRequestSuffix, stripWindowsExtendedPathPrefix };

package/dist/node-imports.d.ts

@@ -0,0 +1,54 @@
+interface PrepareCSSImportGraphOptions {
+  projectDir?: string;
+  expandPackageImports?: boolean;
+  onDependency?: (file: string) => void;
+  resolveNodePackageImports?: boolean;
+  signal?: AbortSignal;
+  baseFile?: string;
+  sourceMap?: string;
+}
+type AnalyzeDependencies = (source: string) => {
+  imports: {
+    source: string;
+  }[];
+};
+/** Source supplied by a host loader; virtual IDs retain their null prefix. */
+interface CSSImportSource {
+  readonly id: string;
+  readonly source: string;
+  /** Real source owner for relative imports, references, resource URLs and source patterns, if any. */
+  readonly baseFile?: string;
+  /** Serialized source map v3 for original reference origins in prepared CSS. */
+  readonly sourceMap?: string;
+}
+/** undefined uses Node fallback; null preserves an external import verbatim. */
+type CSSImportFileResolver = (specifier: string, importer: string) => string | CSSImportSource | null | undefined | Promise<string | CSSImportSource | null | undefined>;
+declare function normalizeStylesheetGraphID(id: string): string;
+declare function isExpandableImportSource(source: string, fromFile: string): boolean;
+declare function resolveRelativeCSSFile(source: string, fromFile: string): string;
+/**
+ * Package file identity survives checkout, installation and publication paths:
+ * the nearest named package plus the package-relative path. Keyframe IDs hash
+ * this owner into delivered CSS, so absolute paths remain only without a name.
+ */
+declare function stylesheetResourceOwner(file: string): string;
+declare function resolveMasterCSSPackageEntryFile(importSource: string, fromFile?: string, projectDir?: string): string | undefined;
+interface PreparedCSSImportGraph {
+  resourceOwners?: Record<string, string>;
+  entry: string;
+  files: Record<string, string>;
+  edges: {
+    from: string;
+    specifier: string;
+    resolved: string;
+  }[];
+  /** Node package CSS keeps its native rules when a surrounding project is pruned. */
+  packageFiles?: string[];
+  baseFiles?: Record<string, string>;
+  sourceMaps?: Record<string, string>;
+}
+declare function resolveNodePackageCSS(importSource: string, fromFile: string): string | undefined;
+declare function prepareCSSImportGraph(file: string, source: string | undefined, options: PrepareCSSImportGraphOptions, analyzeDependencies: AnalyzeDependencies): PreparedCSSImportGraph;
+/** Async build-host file resolution, sharing Node fallback and Rust dependency analysis. */
+declare function prepareCSSImportGraphWithResolver(file: string, source: string, options: PrepareCSSImportGraphOptions, analyzeDependencies: AnalyzeDependencies, resolveImport: CSSImportFileResolver): Promise<PreparedCSSImportGraph>;
+export { CSSImportFileResolver, CSSImportSource, PrepareCSSImportGraphOptions, PreparedCSSImportGraph, isExpandableImportSource, normalizeStylesheetGraphID, prepareCSSImportGraph, prepareCSSImportGraphWithResolver, resolveMasterCSSPackageEntryFile, resolveNodePackageCSS, resolveRelativeCSSFile, stylesheetResourceOwner };