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

package/dist/stylesheet/source-map-url.js

@@ -0,0 +1,11 @@
+import { pathToFileURL } from "node:url";
+import { isAbsolute } from "node:path";
+// src/stylesheet/source-map-url.ts
+/** Host maps may contain native filesystem paths as well as URL references. */
+function sourceMapURL(source, base) {
+	return isAbsolute(source) ? pathToFileURL(source) : new URL(source, base);
+}
+function sourceMapBase(owner, sourceRoot) {
+	return sourceMapURL(sourceRoot ? sourceRoot.replace(/\/?$/, "/") : "./", pathToFileURL(owner));
+}
+export { sourceMapBase, sourceMapURL };

package/dist/stylesheet/source.d.ts

@@ -0,0 +1,3 @@
+import { PreparedStylesheetSource, StylesheetPreparationOptions } from "./types.js";
+declare function prepareSassSource(id: string, source: string, extension: string, options: StylesheetPreparationOptions): Promise<PreparedStylesheetSource>;
+export { prepareSassSource };

package/dist/stylesheet/source.js

@@ -0,0 +1,52 @@
+import { createRequire } from "node:module";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { join, resolve } from "node:path";
+// src/stylesheet/source.ts
+const require = createRequire(import.meta.url);
+function defaultLoadSass(projectDir) {
+	if (projectDir) try {
+		return createRequire(join(projectDir, "package.json"))("sass");
+	} catch {}
+	return require("sass");
+}
+async function prepareSassSource(id, source, extension, options) {
+	options.signal?.throwIfAborted();
+	if (id.startsWith("\0") && !options.baseFile) throw new TypeError("Preparing a virtual stylesheet requires a physical baseFile.");
+	const baseFile = resolve(options.baseFile ?? id);
+	const dependencies = /* @__PURE__ */ new Set();
+	function addDependency(file) {
+		if (dependencies.has(file)) return;
+		dependencies.add(file);
+		options.onDependency?.(file);
+	}
+	addDependency(baseFile);
+	options.signal?.throwIfAborted();
+	if (extension !== ".scss" && extension !== ".sass") return Object.freeze({
+		id,
+		baseFile,
+		source,
+		dependencies: Object.freeze([...dependencies])
+	});
+	const result = await (options.loadSass || defaultLoadSass)(options.projectDir).compileStringAsync(source, {
+		url: pathToFileURL(baseFile),
+		style: "expanded",
+		syntax: extension === ".sass" ? "indented" : "scss",
+		sourceMap: true,
+		sourceMapIncludeSources: true
+	}).catch((error) => {
+		const url = error?.span?.url;
+		if (url?.protocol === "file:") addDependency(fileURLToPath(url));
+		throw error;
+	});
+	options.signal?.throwIfAborted();
+	for (const url of result.loadedUrls ?? []) if (url.protocol === "file:") addDependency(fileURLToPath(url));
+	options.signal?.throwIfAborted();
+	return Object.freeze({
+		id,
+		baseFile,
+		source: result.css,
+		dependencies: Object.freeze([...dependencies]),
+		...result.sourceMap ? { sourceMap: JSON.stringify(result.sourceMap) } : {}
+	});
+}
+export { prepareSassSource };

package/dist/stylesheet/types.d.ts

@@ -0,0 +1,162 @@
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+import { PreparedCSSImportGraph } from "../node-imports.js";
+import { StylesheetDeliveryOptions, StylesheetResourceAsset } from "./delivery.js";
+import { CompileCSSOptions, CompileCSSResult } from "../node-compiler.js";
+import { MasterCSSEmittedGlobals } from "@master/css-schema/emitted-globals";
+import { StylesheetDirectives, StylesheetSourceOptions } from "./directives.js";
+import { StylesheetSourceContext } from "./source-context.js";
+import { RenderCompiledManifestCSSResult } from "./render.js";
+interface SassModule {
+  compileStringAsync(source: string, options: {
+    url: URL;
+    style: 'expanded';
+    syntax: 'scss' | 'indented';
+    sourceMap?: boolean;
+    sourceMapIncludeSources?: boolean;
+  }): Promise<{
+    css: string;
+    loadedUrls?: readonly URL[];
+    sourceMap?: object;
+  }>;
+}
+interface StylesheetPreparationOptions {
+  readonly projectDir?: string;
+  readonly baseFile?: string;
+  readonly loadSass?: (projectDir?: string) => SassModule;
+  readonly onDependency?: (file: string) => void;
+  readonly signal?: AbortSignal;
+}
+interface PreparedStylesheetSource {
+  readonly id: string;
+  readonly baseFile: string;
+  readonly source: string;
+  readonly dependencies: readonly string[];
+  /** Serialized Sass source map v3, including original source contents. */
+  readonly sourceMap?: string;
+}
+interface CompileStylesheetOptions extends CompileCSSOptions, StylesheetSourceContext {
+  /** Absolute definition files supplied by a host, before authored references. */
+  readonly referenceFiles?: readonly string[];
+  /** Internal metadata retained when source collection removes import directives. */
+  references?: CompileCSSResult['references'];
+  delivery?: StylesheetDeliveryOptions;
+  readonly baseManifest: MasterCSSManifest;
+  projectDir?: string;
+  loadSass?: (projectDir?: string) => SassModule;
+}
+interface CompileRenderedStylesheetOptions extends CompileStylesheetOptions {
+  /** Globals already present outside this render; emit only additional resources. */
+  readonly emittedGlobals?: MasterCSSEmittedGlobals;
+}
+interface CompileRenderedStylesheetResult extends CompileCSSResult {
+  /** Present with delivery options; publish every returned stylesheet at its href. */
+  entry?: string;
+  stylesheets?: readonly {
+    readonly id: string;
+    readonly href: string;
+    readonly css: string;
+    readonly sourceMap: string;
+  }[];
+  resources?: readonly StylesheetResourceAsset[];
+  emittedGlobals: Required<MasterCSSEmittedGlobals>;
+  manifest: MasterCSSManifest;
+  renderedCSS: RenderCompiledManifestCSSResult;
+}
+interface TransformLocalStylesheetResult {
+  globalStylesheet?: {
+    readonly css: string;
+    readonly sourceMap?: string;
+  };
+  stylesheets?: readonly {
+    readonly id: string;
+    readonly href: string;
+    readonly css: string;
+    readonly sourceMap?: string;
+  }[];
+  resources?: readonly StylesheetResourceAsset[];
+  code: string;
+  dependencies: string[];
+  transformed: boolean;
+  result?: CompileCSSResult;
+}
+interface TransformLocalStylesheetOptions extends CompileStylesheetOptions {
+  preserveUnchangedNativeCSS?: boolean;
+  /** Keep generated root/mode resources outside a host's locally scoped CSS. */
+  generatedGlobals?: 'inline' | 'separate';
+  transformNativeStylesheets?: boolean;
+  emittedGlobals?: MasterCSSEmittedGlobals;
+}
+type RegisterStylesheetSourceOptions = CompileStylesheetOptions;
+type CreateStyleEntryEmittedGlobalsOptions = CompileStylesheetOptions;
+interface CreateStyleEntryEmittedGlobalsResult {
+  emittedGlobals: Required<MasterCSSEmittedGlobals>;
+  dependencies: string[];
+}
+interface CreateExtractedCSSOptions extends CompileStylesheetOptions {
+  scanner: ScannerState;
+  stylesheetSources?: StylesheetSources;
+  manifest?: MasterCSSManifest;
+  includeGeneratedCSS?: boolean;
+  includeNativeCSS?: boolean;
+  includeMasterBaseCSS?: boolean;
+}
+interface CreateExtractedCSSResult {
+  stylesheets?: readonly {
+    readonly id: string;
+    readonly href: string;
+    readonly css: string;
+    readonly sourceMap?: string;
+  }[];
+  resources?: readonly StylesheetResourceAsset[];
+  dependencies?: readonly string[];
+  css: string;
+  emittedGlobals: Required<MasterCSSEmittedGlobals>;
+}
+interface ScannerCSSState {
+  readonly text: string;
+  readonly manifest: MasterCSSManifest;
+}
+interface ScannerClassState extends Iterable<string> {
+  readonly size: number;
+  has(className: string): boolean;
+}
+interface ScannerState {
+  cwd: string;
+  options: StylesheetSourceOptions;
+  customOptions?: StylesheetSourceOptions & {
+    manifest?: MasterCSSManifest;
+  };
+  css: ScannerCSSState;
+  latentClasses: ScannerClassState;
+  validClasses: ScannerClassState;
+  usedNativeClasses: ScannerClassState;
+  nativeClassNames: ScannerClassState;
+  registerNativeClasses?: (owner: string, classNames: string[]) => boolean;
+  emit?: (event: 'change') => unknown;
+}
+interface StylesheetSource {
+  references?: CompileCSSResult['references'];
+  graph?: PreparedCSSImportGraph;
+  /** Derived from the registered graph's Rust extraction policies. */
+  classIndependent?: boolean;
+  source: string;
+  pruneNativeCSS: boolean;
+  masterCSS: boolean;
+  directives: StylesheetDirectives;
+  dependencies: string[];
+  sourceDependencies: string[];
+}
+type StylesheetSources = Map<string, StylesheetSource>;
+interface ResolvedStylesheetSource {
+  references?: CompileCSSResult['references'];
+  source: string;
+  dependencies: string[];
+}
+interface ResolveStylesheetImportGraphOptions {
+  expandMasterCSSPackage?: boolean;
+}
+interface CreateStylesheetHostSourceOptions {
+  masterImport?: string;
+  masterSource?: string;
+}
+export { CompileRenderedStylesheetOptions, CompileRenderedStylesheetResult, CompileStylesheetOptions, CreateExtractedCSSOptions, CreateExtractedCSSResult, CreateStyleEntryEmittedGlobalsOptions, CreateStyleEntryEmittedGlobalsResult, CreateStylesheetHostSourceOptions, PreparedStylesheetSource, RegisterStylesheetSourceOptions, ResolveStylesheetImportGraphOptions, ResolvedStylesheetSource, SassModule, ScannerCSSState, ScannerClassState, ScannerState, StylesheetPreparationOptions, StylesheetSource, StylesheetSources, TransformLocalStylesheetOptions, TransformLocalStylesheetResult };

package/dist/stylesheet/types.js

@@ -0,0 +1 @@
+export {};

package/dist/value-validation.d.ts

@@ -0,0 +1,19 @@
+import { MasterCSSDiagnostic } from "@master/css-schema";
+import { MasterCSSCompileOptions } from "./index.js";
+import { CSSOutputMapping } from "@master/css-schema/css-directives";
+type OffsetRange = {
+  readonly start: number;
+  readonly end: number;
+};
+type Origin = Pick<MasterCSSDiagnostic, 'source' | 'range'>;
+interface ValidationSource {
+  readonly css: string;
+  readonly source?: string;
+  readonly mappings?: readonly CSSOutputMapping[];
+  readonly sources?: Readonly<Record<string, string>>;
+  readonly locate?: (range: OffsetRange) => Origin | undefined;
+}
+declare function assertValidationOptions(options: object): void;
+/** Validate the complete emission before a host can publish any of its assets. */
+declare function validateCompiledCSS(sources: readonly ValidationSource[], options?: Pick<MasterCSSCompileOptions, 'validation' | 'onDiagnostic'>): readonly MasterCSSDiagnostic[];
+export { ValidationSource, assertValidationOptions, validateCompiledCSS };

package/dist/value-validation.js

@@ -0,0 +1,96 @@
+import { CSS_SYNTAX_CHECK, CSS_VALUE_CHECK, cssSyntaxStatus, validateRuleDeclarations } from "@master/css-tooling/validator";
+import { MASTER_CSS_DIAGNOSTIC_VERSION, MasterCSSError } from "@master/css-schema";
+// src/value-validation.ts
+function position(text, offset) {
+	const lines = text.slice(0, offset).split(/\r\n?|\n/);
+	return {
+		line: lines.length - 1,
+		character: lines[lines.length - 1].length
+	};
+}
+function origin(input, range) {
+	if (input.locate) return input.locate(range);
+	const mapping = input.mappings?.findLast((item) => item.generatedStart <= range.start && (item.generatedEnd === void 0 || range.start < item.generatedEnd));
+	if (!mapping) return;
+	const source = mapping.source.file ?? input.source;
+	const text = source ? input.sources?.[source] : void 0;
+	const reference = mapping.source;
+	if (text !== void 0) {
+		const unchanged = mapping.generatedEnd !== void 0 && text.slice(reference.range.start, reference.range.end) === input.css.slice(mapping.generatedStart, mapping.generatedEnd);
+		const start = unchanged ? reference.range.start + range.start - mapping.generatedStart : reference.range.start;
+		const end = unchanged ? Math.min(reference.range.end, reference.range.start + range.end - mapping.generatedStart) : reference.range.end;
+		return {
+			source,
+			range: {
+				start: position(text, start),
+				end: position(text, end)
+			}
+		};
+	}
+	return {
+		source,
+		...reference.loc ? { range: {
+			start: {
+				line: reference.loc.start.line - 1,
+				character: reference.loc.start.column - 1
+			},
+			end: {
+				line: reference.loc.end.line - 1,
+				character: reference.loc.end.column - 1
+			}
+		} } : {}
+	};
+}
+function assertValidationOptions(options) {
+	if ("validation" in options && options.validation !== void 0 && options.validation !== "report" && options.validation !== "error") throw new MasterCSSError({
+		code: "INVALID_INPUT",
+		domain: "compiler",
+		message: "validation must be 'report' or 'error'."
+	});
+}
+/** Validate the complete emission before a host can publish any of its assets. */
+function validateCompiledCSS(sources, options = {}) {
+	assertValidationOptions(options);
+	const diagnostics = [];
+	for (const input of sources) {
+		const { css, source } = input;
+		if (cssSyntaxStatus(css) === "invalid") {
+			const diagnostic = Object.freeze({
+				version: MASTER_CSS_DIAGNOSTIC_VERSION,
+				code: "CSS_PARSE_ERROR",
+				domain: "compiler",
+				phase: "css-syntax",
+				severity: "error",
+				message: "Invalid CSS token structure in compiled output",
+				source: source ? `${source}#generated` : "<generated-css>",
+				notes: [`Checked with ${CSS_SYNTAX_CHECK.name} ${CSS_SYNTAX_CHECK.version}; no authored source offset is available.`]
+			});
+			diagnostics.push(diagnostic);
+			options.onDiagnostic?.(diagnostic);
+		}
+		for (const declaration of validateRuleDeclarations(css)) {
+			if (declaration.status !== "invalid" && declaration.status !== "unknown") continue;
+			const authored = declaration.range ? origin(input, declaration.range) : void 0;
+			const diagnostic = Object.freeze({
+				version: MASTER_CSS_DIAGNOSTIC_VERSION,
+				code: declaration.status === "invalid" ? "CSS_VALUE_INVALID" : "CSS_VALUE_UNKNOWN",
+				domain: "compiler",
+				phase: "css-value",
+				severity: declaration.status === "invalid" ? "error" : "information",
+				message: `${declaration.status === "invalid" ? "Invalid" : "Unverified"} CSS value: ${declaration.property}:${declaration.value}`,
+				...authored ?? { source: source ? `${source}#generated` : "<generated-css>" },
+				notes: [`Checked generated CSS with ${CSS_VALUE_CHECK.name} ${CSS_VALUE_CHECK.version}; browser support and computed values were not checked.`]
+			});
+			diagnostics.push(diagnostic);
+			options.onDiagnostic?.(diagnostic);
+		}
+	}
+	if (options.validation === "error" && diagnostics.some((diagnostic) => diagnostic.severity === "error")) throw new MasterCSSError({
+		code: "CSS_VALUE_INVALID",
+		domain: "compiler",
+		message: "Strict CSS validation failed. No compilation result was published.",
+		diagnostics
+	});
+	return Object.freeze(diagnostics);
+}
+export { assertValidationOptions, validateCompiledCSS };

package/package.json

@@ -0,0 +1,79 @@
+{
+    "name": "@master/css-compiler",
+    "type": "module",
+    "engines": {
+        "node": "^24"
+    },
+    "license": "MIT",
+    "description": "Compile Master CSS stylesheet directives",
+    "author": "Aoyue Design LLC.",
+    "homepage": "https://css.master.co",
+    "bugs": {
+        "url": "https://github.com/master-co/css/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/master-co/css.git",
+        "directory": "packages/compiler"
+    },
+    "keywords": [
+        "compiler",
+        "directives",
+        "css",
+        "mastercss"
+    ],
+    "sideEffects": false,
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js",
+            "default": "./dist/index.js"
+        },
+        "./node": {
+            "types": "./dist/node.d.ts",
+            "import": "./dist/node.js",
+            "default": "./dist/node.js"
+        },
+        "./project": {
+            "types": "./dist/project/manifest.d.ts",
+            "import": "./dist/project/manifest.js",
+            "default": "./dist/project/manifest.js"
+        },
+        "./project/sync": {
+            "types": "./dist/project/manifest-sync.d.ts",
+            "import": "./dist/project/manifest-sync.js",
+            "default": "./dist/project/manifest-sync.js"
+        },
+        "./stylesheet": {
+            "types": "./dist/stylesheet/index-public.d.ts",
+            "import": "./dist/stylesheet/index-public.js",
+            "default": "./dist/stylesheet/index-public.js"
+        },
+        "./stylesheet/browser": {
+            "types": "./dist/stylesheet/browser.d.ts",
+            "import": "./dist/stylesheet/browser.js",
+            "default": "./dist/stylesheet/browser.js"
+        },
+        "./diagnostics": {
+            "types": "./dist/diagnostics/index.d.ts",
+            "import": "./dist/diagnostics/index.js",
+            "default": "./dist/diagnostics/index.js"
+        }
+    },
+    "files": [
+        "dist"
+    ],
+    "publishConfig": {
+        "access": "public",
+        "provenance": true
+    },
+    "dependencies": {
+        "@master/css-binding": "0.0.0-site.1793659883.g69c9aebcf628",
+        "@master/css-schema": "0.0.0-site.1793659883.g69c9aebcf628",
+        "@master/css-tooling": "0.0.0-site.1793659883.g69c9aebcf628",
+        "fast-glob": "^3.3.3"
+    },
+    "version": "0.0.0-site.1793659883.g69c9aebcf628",
+    "gitHead": "69c9aebcf628eb529001b9fa1b3536306f1b139e"
+}