@master/css-tooling 0.0.0-site.1793659883.g69c9aebcf628 → 0.0.0-stage

package/dist/math-types.js

@@ -1,236 +0,0 @@
-import { clone, lexer, walk } from "@eslint/css-tree";
-// src/math-types.ts
-const unknown = { kind: "unknown" };
-const invalid = { kind: "invalid" };
-const number = () => ({
-	kind: "known",
-	powers: {}
-});
-const dimension = (name) => ({
-	kind: "known",
-	powers: { [name]: 1 }
-});
-const examples = {
-	length: "px",
-	angle: "deg",
-	time: "s",
-	frequency: "hz",
-	resolution: "dppx",
-	flex: "fr"
-};
-const units = new Map(Object.entries(lexer.units).filter(([type]) => type in examples).flatMap(([type, names]) => names.map((unit) => [unit.toLowerCase(), type])));
-const mathFunctions = /* @__PURE__ */ new Set([
-	"calc",
-	"min",
-	"max",
-	"clamp",
-	"mod",
-	"rem",
-	"sin",
-	"cos",
-	"tan",
-	"asin",
-	"acos",
-	"atan",
-	"atan2",
-	"pow",
-	"sqrt",
-	"hypot",
-	"exp",
-	"abs",
-	"sign",
-	"log",
-	"round"
-]);
-function same(a, b) {
-	return Object.keys({
-		...a.powers,
-		...b.powers
-	}).every((key) => a.powers[key] === b.powers[key]);
-}
-function combine(a, b, operator, hint) {
-	if (a.kind === "invalid" || b.kind === "invalid") return invalid;
-	if (a.kind === "unknown" || b.kind === "unknown") return unknown;
-	if (operator === "+" || operator === "-") {
-		if (same(a, b)) return a;
-		if (hint === void 0 && (a.powers.percentage || b.powers.percentage)) return unknown;
-		return invalid;
-	}
-	const powers = { ...a.powers };
-	for (const [dimension, exponent] of Object.entries(b.powers)) {
-		const key = dimension;
-		powers[key] = (powers[key] ?? 0) + exponent * (operator === "/" ? -1 : 1);
-		if (powers[key] === 0) delete powers[key];
-	}
-	return {
-		kind: "known",
-		powers
-	};
-}
-function expression(nodes, hint) {
-	let offset = 0;
-	const atom = () => {
-		const node = nodes[offset++];
-		if (!node) return invalid;
-		switch (node.type) {
-			case "Number": return number();
-			case "Dimension": return units.has(node.unit.toLowerCase()) ? dimension(units.get(node.unit.toLowerCase())) : unknown;
-			case "Percentage": return dimension(hint ?? "percentage");
-			case "Identifier": return [
-				"e",
-				"pi",
-				"infinity",
-				"-infinity",
-				"nan"
-			].includes(node.name.toLowerCase()) ? number() : unknown;
-			case "Parentheses": return expression([...node.children], hint);
-			case "Function": return inferFunction(node, hint);
-			default: return unknown;
-		}
-	};
-	const operator = () => {
-		const node = nodes[offset];
-		return node?.type === "Operator" ? node.value.trim() : "";
-	};
-	const product = () => {
-		let result = atom();
-		while (["*", "/"].includes(operator())) {
-			const op = operator();
-			offset++;
-			result = combine(result, atom(), op, hint);
-		}
-		return result;
-	};
-	let result = product();
-	let knownSum = result.kind === "known" ? result : void 0;
-	while (["+", "-"].includes(operator())) {
-		const op = operator();
-		offset++;
-		const right = product();
-		if (right.kind === "known") {
-			const sum = knownSum ? combine(knownSum, right, op, hint) : right;
-			if (sum.kind === "invalid") return invalid;
-			knownSum = sum.kind === "known" ? sum : void 0;
-		}
-		result = combine(result, right, op, hint);
-	}
-	return offset === nodes.length ? result : unknown;
-}
-function primitive(value) {
-	const entries = Object.entries(value.powers);
-	return !entries.length ? "number" : entries.length === 1 && entries[0][1] === 1 ? entries[0][0] : void 0;
-}
-function inferFunction(node, hint) {
-	const name = node.name.toLowerCase();
-	if (!mathFunctions.has(name)) return unknown;
-	const args = [[]];
-	for (const child of node.children) if (child.type === "Operator" && child.value.trim() === ",") args.push([]);
-	else args.at(-1).push(child);
-	if (name === "round" && args[0]?.length === 1 && args[0][0].type === "Identifier" && [
-		"nearest",
-		"up",
-		"down",
-		"to-zero"
-	].includes(args[0][0].name)) args.shift();
-	const values = args.map((nodes, index) => name === "clamp" && index !== 1 && nodes.length === 1 && nodes[0].type === "Identifier" && nodes[0].name === "none" ? void 0 : expression(nodes, hint)).filter((value) => value !== void 0);
-	if (values.some((value) => value.kind === "invalid")) return invalid;
-	const known = values.filter((value) => value.kind === "known");
-	const uncertain = known.length !== values.length;
-	const accepts = (types) => known.every((value) => {
-		const type = primitive(value);
-		return type !== void 0 && types.includes(type);
-	});
-	let result;
-	switch (name) {
-		case "calc": return values[0] ?? invalid;
-		case "sin":
-		case "cos":
-		case "tan":
-			result = accepts(["number", "angle"]) ? number() : invalid;
-			break;
-		case "asin":
-		case "acos":
-		case "atan":
-			result = accepts(["number"]) ? dimension("angle") : invalid;
-			break;
-		case "pow":
-		case "sqrt":
-		case "exp":
-		case "log":
-			result = accepts(["number"]) ? number() : invalid;
-			break;
-		case "sign":
-			result = known.every((value) => primitive(value) !== void 0) ? number() : invalid;
-			break;
-		case "abs":
-			result = values[0] ?? invalid;
-			break;
-		default:
-			result = known.reduce((result, value) => combine(result, value, "+", hint), known[0] ?? unknown);
-			if (name === "round" && values.length === 1 && !accepts(["number"])) result = invalid;
-			if (name === "atan2" && result.kind === "known") result = dimension("angle");
-	}
-	return result.kind === "invalid" ? invalid : uncertain ? unknown : result;
-}
-function representative(type) {
-	if (type === "number") return {
-		type: "Number",
-		value: "1"
-	};
-	if (type === "percentage") return {
-		type: "Percentage",
-		value: "1"
-	};
-	return {
-		type: "Dimension",
-		value: "1",
-		unit: examples[type]
-	};
-}
-/** Substitute only proven result types into a disposable grammar AST. Never
-* evaluate values, ranges, variable substitutions, or mutate emitted CSS.
-* A nested calc may have a compound intermediate type which its parent cancels.
-*/
-function validateMathTypes(ast, matches) {
-	const normalized = clone(ast);
-	let status = "valid";
-	let found = false;
-	walk(normalized, (node, item, list) => {
-		if (node.type !== "Function" || !mathFunctions.has(node.name.toLowerCase()) || !item || !list) return;
-		found = true;
-		const original = item.data;
-		const accepts = (type) => {
-			item.data = representative(type);
-			const result = matches(normalized);
-			item.data = original;
-			return result;
-		};
-		let hint = null;
-		let hasPercentage = false;
-		walk(node, (child) => {
-			if (child.type === "Percentage") hasPercentage = true;
-		});
-		if (hasPercentage) {
-			const bases = Object.keys(examples).filter((type) => accepts(type));
-			hint = accepts("percentage") && bases.length === 1 ? bases[0] : bases.length ? null : void 0;
-		}
-		const inferred = inferFunction(node, hint);
-		if (inferred.kind === "invalid") status = "invalid";
-		else if (inferred.kind === "unknown") {
-			if (status !== "invalid") status = "unknown";
-		} else {
-			const type = primitive(inferred);
-			if (!type) {
-				if (hasPercentage && hint === void 0) {
-					if (status !== "invalid") status = "unknown";
-				} else status = "invalid";
-			} else item.data = representative(type);
-		}
-		return walk.skip;
-	});
-	return {
-		ast: normalized,
-		status: found ? status : void 0
-	};
-}
-export { mathFunctions, validateMathTypes };

package/dist/math-validation.d.ts

@@ -1,7 +0,0 @@
-import { FunctionNode } from "@eslint/css-tree";
-/** Check operator structure and arity, without inferring the result's dimension.
- * CSS Values 4 allows dimensional division. Normalize operands for grammar-only
- * checks rather than applying the lexer's numeric-divisor restriction.
- */
-declare function mathFunctionStatus(node: FunctionNode): 'valid' | 'invalid' | 'unknown' | undefined;
-export { mathFunctionStatus };

package/dist/math-validation.js

@@ -1,74 +0,0 @@
-import { mathFunctions } from "./math-types.js";
-import { List, clone, generate, lexer, walk } from "@eslint/css-tree";
-// src/math-validation.ts
-/** Check operator structure and arity, without inferring the result's dimension.
-* CSS Values 4 allows dimensional division. Normalize operands for grammar-only
-* checks rather than applying the lexer's numeric-divisor restriction.
-*/
-function mathFunctionStatus(node) {
-	const name = node.name.toLowerCase();
-	if (!mathFunctions.has(name)) return;
-	const normalized = clone(node);
-	let uncertain = false;
-	walk(normalized, (child, item, list) => {
-		if (child === normalized) return;
-		if (child.type === "Function") {
-			if (!mathFunctions.has(child.name.toLowerCase())) uncertain = true;
-			if (item && list) list.replace(item, list.createItem({
-				type: "Number",
-				value: "1"
-			}));
-			return walk.skip;
-		}
-		if ((child.type === "Dimension" || child.type === "Percentage") && item && list) list.replace(item, list.createItem({
-			type: "Number",
-			value: "1"
-		}));
-	});
-	if (uncertain) {
-		const arguments_ = [[]];
-		for (const child of node.children) if (child.type === "Operator" && child.value.trim() === ",") arguments_.push([]);
-		else arguments_.at(-1).push(child);
-		for (const argument of arguments_) {
-			const last = argument.at(-1);
-			if (last?.type === "Operator" && [
-				"+",
-				"-",
-				"*",
-				"/"
-			].includes(last.value.trim())) return "invalid";
-			let dependent = false;
-			const children = new List().fromArray(argument);
-			walk({
-				type: "Value",
-				children
-			}, (child) => {
-				if (child.type === "Function") dependent = true;
-			});
-			if (!dependent && mathFunctionStatus({
-				type: "Function",
-				name: "calc",
-				children
-			}) === "invalid") return "invalid";
-		}
-		return "unknown";
-	}
-	if (name === "log" || name === "round") {
-		const parts = [[]];
-		for (const child of normalized.children) if (child.type === "Operator" && child.value.trim() === ",") parts.push([]);
-		else parts.at(-1).push(child);
-		if (name === "round" && parts[0]?.length === 1 && parts[0][0].type === "Identifier" && [
-			"nearest",
-			"up",
-			"down",
-			"to-zero"
-		].includes(parts[0][0].name)) parts.shift();
-		if (parts.length < 1 || parts.length > 2) return "invalid";
-		return parts.some((children) => lexer.matchType("calc-sum", generate({
-			type: "Value",
-			children: new List().fromArray(children)
-		})).error) ? "invalid" : "valid";
-	}
-	return lexer.matchType(`${name}()`, generate(normalized)).error ? "invalid" : "valid";
-}
-export { mathFunctionStatus };

package/dist/node.d.ts

@@ -1,12 +0,0 @@
-import { CSS_VALUE_CHECK, cssValueStatus, validateRuleDeclarations } from "./value-validation.js";
-import { CSS_SYNTAX_CHECK, cssSyntaxStatus } from "./syntax-validation.js";
-import { MasterCSSToolingSession } from "./tooling-session.js";
-import { MasterCSSManifest } from "@master/css-schema/manifest";
-declare function createToolingSessionSync(options: {
-  readonly manifest: MasterCSSManifest;
-  /** Classes the project defines in native CSS; they report no diagnostics while they generate no rules. */
-  readonly nativeClassNames?: readonly string[];
-}): MasterCSSToolingSession;
-/** Versions from the artifact that actually executes project semantics. */
-declare function getToolingBindingInfo(): import("@master/css-binding").MasterCSSBindingInfo;
-export { CSS_SYNTAX_CHECK, CSS_VALUE_CHECK, type MasterCSSToolingSession, createToolingSessionSync, cssSyntaxStatus, cssValueStatus, getToolingBindingInfo, validateRuleDeclarations };

package/dist/node.js

@@ -1,32 +0,0 @@
-import { bindLexerSession } from "./lexer/session.js";
-import { CSS_SYNTAX_CHECK, cssSyntaxStatus } from "./syntax-validation.js";
-import { CSS_VALUE_CHECK, cssValueStatus, validateRuleDeclarations } from "./value-validation.js";
-import { bindLanguageSession } from "./language/session.js";
-import { bindLintSession } from "./lint/binding-session.js";
-import { bindSourceExtractor } from "./source/session.js";
-import { bindValidatorSession } from "./validator/binding-session.js";
-import { bindToolingSessionInternal } from "./tooling-session.js";
-import { createToolingBindingSync } from "@master/css-binding/tooling/node";
-// src/node.ts
-function createToolingSessionSync(options) {
-	const tooling = createToolingBindingSync();
-	const lexer = tooling.createLexerSession();
-	const source = tooling.createSourceSession();
-	const validator = tooling.createValidatorSession(options.manifest);
-	const language = tooling.createLanguageSession(options.manifest);
-	const lint = tooling.createLintSession(options.manifest);
-	const lintValidator = tooling.createValidatorSession(options.manifest);
-	const lintLanguage = tooling.createLanguageSession(options.manifest);
-	return bindToolingSessionInternal({
-		lexer: bindLexerSession("native", lexer),
-		source: bindSourceExtractor("native", source),
-		validator: bindValidatorSession("native", validator, options.nativeClassNames),
-		lint: bindLintSession(lint, lintValidator, lintLanguage),
-		language: bindLanguageSession("native", language, options.nativeClassNames)
-	});
-}
-/** Versions from the artifact that actually executes project semantics. */
-function getToolingBindingInfo() {
-	return createToolingBindingSync().info;
-}
-export { CSS_SYNTAX_CHECK, CSS_VALUE_CHECK, createToolingSessionSync, cssSyntaxStatus, cssValueStatus, getToolingBindingInfo, validateRuleDeclarations };

package/dist/scanner/binding-session.d.ts

@@ -1,29 +0,0 @@
-import { MasterCSSBindingLoadOptions, MasterCSSScannerSourceInput, MasterCSSScannerSourceOptions, MasterCSSScannerState, MasterCSSScannerUpdate } from "@master/css-binding/tooling";
-import { MasterCSSManifest } from "@master/css-schema/manifest";
-type BindingScannerUpdate = MasterCSSScannerUpdate;
-type BindingScannerState = MasterCSSScannerState;
-type ScannerSourceOptions = MasterCSSScannerSourceOptions;
-type ScannerSourceInput = MasterCSSScannerSourceInput;
-type BindingScannerBlocklist = string | Readonly<{
-  source: string;
-  flags: string;
-}>;
-interface BindingScannerSession {
-  readonly binding: 'native' | 'wasm';
-  extractCandidates(source: string, content: string, options?: ScannerSourceOptions): string[];
-  collectCandidates(candidates: string[]): string[];
-  filterCandidates(candidates: string[], blocklist: BindingScannerBlocklist[]): string[];
-  scanCandidates(source: string, content: string, candidates: string[], blocklist: BindingScannerBlocklist[], options?: ScannerSourceOptions): BindingScannerUpdate;
-  removeSource(source: string, options?: ScannerSourceOptions): BindingScannerUpdate;
-  reconcileSources(owner: string, inputs: readonly ScannerSourceInput[]): BindingScannerUpdate;
-  removeOwner(owner: string): BindingScannerUpdate;
-  ensureClasses(classNames: string[]): void;
-  registerNativeClasses(owner: string, classNames: string[]): boolean;
-  reset(): void;
-  state(): BindingScannerState;
-  dispose(): void;
-}
-declare function serializeScannerBlocklist(blocklist?: Iterable<string | RegExp>): BindingScannerBlocklist[];
-declare function createNativeScannerSession(manifest: MasterCSSManifest): BindingScannerSession;
-declare function createScannerSession(manifest: MasterCSSManifest, options?: MasterCSSBindingLoadOptions): Promise<BindingScannerSession>;
-export { BindingScannerBlocklist, BindingScannerSession, BindingScannerState, BindingScannerUpdate, ScannerSourceInput, ScannerSourceOptions, createNativeScannerSession, createScannerSession, serializeScannerBlocklist };

package/dist/scanner/binding-session.js

@@ -1,37 +0,0 @@
-import { createToolingBindingSync } from "@master/css-binding/tooling/node";
-import { createToolingBinding } from "@master/css-binding/tooling";
-// src/scanner/binding-session.ts
-function serializeScannerBlocklist(blocklist = []) {
-	return [...blocklist].map((entry) => typeof entry === "string" ? entry : {
-		source: entry.source,
-		flags: entry.flags
-	});
-}
-function bindScannerSession(binding, session) {
-	return {
-		binding,
-		extractCandidates: (source, content, options) => [...session.extractCandidates(source, content, options)],
-		collectCandidates: (candidates) => [...session.collectCandidates(candidates)],
-		filterCandidates: (candidates, blocklist) => [...session.filterCandidates(candidates, blocklist)],
-		scanCandidates: (source, content, candidates, blocklist, options) => session.scanCandidates(source, content, candidates, blocklist, options),
-		removeSource: (source, options) => session.removeSource(source, options),
-		reconcileSources: (owner, inputs) => session.reconcileSources(owner, inputs),
-		removeOwner: (owner) => session.removeOwner(owner),
-		ensureClasses: (classes) => {
-			session.ensureClassRules(classes);
-		},
-		registerNativeClasses: (owner, classes) => session.registerNativeClassNames(owner, classes),
-		reset: () => session.reset(),
-		state: () => session.snapshot(),
-		dispose: () => session.dispose()
-	};
-}
-function createNativeScannerSession(manifest) {
-	const tooling = createToolingBindingSync();
-	return bindScannerSession(tooling.binding, tooling.createScannerSession(manifest));
-}
-async function createScannerSession(manifest, options = {}) {
-	const tooling = await createToolingBinding(options);
-	return bindScannerSession(tooling.binding, await tooling.createScannerSession(manifest));
-}
-export { createNativeScannerSession, createScannerSession, serializeScannerBlocklist };

package/dist/scanner/core.d.ts

@@ -1,130 +0,0 @@
-import { ScannerSourceInput, ScannerSourceOptions } from "./binding-session.js";
-import { MasterCSSScannerOptions } from "./options/index.js";
-import { EventEmitter } from "node:events";
-import { MasterCSSManifest } from "@master/css-schema/manifest";
-interface ScannerResetOptions {
-  emit?: boolean;
-}
-interface MasterCSSScannerSourceResult {
-  readonly changed: boolean;
-  readonly sourceChanged: boolean;
-  /** All candidates extracted from this input, including previously scanned classes. */
-  readonly candidates: readonly string[];
-}
-declare class ScannerCSSView {
-  readonly scanner: MasterCSSScanner;
-  constructor(scanner: MasterCSSScanner);
-  get manifest(): MasterCSSManifest;
-  get text(): string;
-  get utilitiesLayer(): {
-    rules: {
-      className: string;
-      key: string;
-      layer: import("@master/css-schema/manifest").MasterCSSManifestUtilityLayerName;
-      type: import("~/packages/schema/src/utility-type").UtilityType;
-      sortTier: number;
-      priority: import("~/packages/schema/src/hydration-manifest").MasterCSSRulePriority;
-      text: string;
-      nodes?: readonly import("~/packages/schema/src/hydration-manifest").MasterCSSHydrationRuleNode[];
-      selectorText?: string;
-      variableNames?: readonly string[];
-      keyframeNames?: readonly string[];
-      retainAllKeyframes?: boolean;
-      name: string;
-    }[];
-  };
-}
-declare class ScannerStateSetView {
-  private readonly readValues;
-  readonly [Symbol.toStringTag] = "ScannerStateSetView";
-  constructor(readValues: () => readonly string[]);
-  get size(): number;
-  has(value: string): boolean;
-  entries(): SetIterator<[string, string]>;
-  keys(): SetIterator<string>;
-  valuesIterator(): SetIterator<string>;
-  values(): SetIterator<string>;
-  forEach(callbackfn: (value: string, value2: string, set: ScannerStateSetView) => void, thisArg?: unknown): void;
-  [Symbol.iterator](): SetIterator<string>;
-}
-declare class MasterCSSScanner extends EventEmitter implements AsyncDisposable {
-  customOptions: MasterCSSScannerOptions;
-  cwd: string;
-  readonly latentClasses: ScannerStateSetView;
-  readonly validClasses: ScannerStateSetView;
-  readonly invalidClasses: ScannerStateSetView;
-  readonly nativeClassNames: ScannerStateSetView;
-  readonly usedNativeClasses: ScannerStateSetView;
-  /** Current successful source snapshot, including empty and virtual inputs. */
-  get sources(): {
-    source: string;
-    owner: string;
-    parentSource: string | null;
-    kind: import("@master/css-binding/protocol").MasterCSSSourceExtractorKind;
-    extractor: string;
-    candidates: string[];
-  }[];
-  initialized: boolean;
-  initializing?: Promise<this>;
-  resetDependencies: string[];
-  readonly css: ScannerCSSView;
-  private bindingSession?;
-  private bindingState?;
-  private currentManifest;
-  private lifecycleGeneration;
-  private sourcePolicy?;
-  private sourceRevisions;
-  private ownerRevisions;
-  private ownerSnapshots;
-  private sourceParents;
-  private committedSources;
-  private extractionCache;
-  /** Precompiled minimatch patterns for per-module allow/exclude checks. */
-  private sourceMatchers?;
-  private sourceMatcherOptions?;
-  constructor(customOptions: MasterCSSScannerOptions, cwd?: string);
-  init(customOptions?: MasterCSSScannerOptions): Promise<this>;
-  private initInternal;
-  reset(customOptions?: MasterCSSScannerOptions, resetOptions?: ScannerResetOptions): Promise<this>;
-  dispose(): Promise<this>;
-  [Symbol.asyncDispose](): Promise<void>;
-  private insertSafelist;
-  /**
-   * @description Extract source content candidates.
-   * @param source
-   * @param content
-   * @returns Promise<string[]> Latent classes
-   */
-  collectCandidates(source: string, content: string, options?: ScannerSourceOptions): Promise<string[]>;
-  private extractCandidates;
-  scan(source: string, content: string): Promise<boolean>;
-  scanSource(source: string, content: string, options?: ScannerSourceOptions): Promise<MasterCSSScannerSourceResult>;
-  removeSource(source: string, options?: ScannerSourceOptions): MasterCSSScannerSourceResult;
-  private sourceAncestors;
-  reconcileSources(owner: string, inputs: readonly ScannerSourceInput[]): Promise<MasterCSSScannerSourceResult>;
-  private reconcileOwner;
-  removeOwner(owner: string): MasterCSSScannerSourceResult;
-  private applyUpdate;
-  scanModule(source: string, content: string): Promise<boolean>;
-  private resolveSourceAdapter;
-  private getSourceMatchers;
-  isModuleAllowed(source: string): boolean;
-  isSourceAllowed(source: string, options?: {
-    explicit?: boolean;
-  }): boolean;
-  get sourcePolicyDependencies(): string[];
-  registerNativeClasses(owner: string, classNames: string[]): boolean;
-  private getBindingSession;
-  private syncBindingState;
-  get state(): import("@master/css-binding/protocol").MasterCSSScannerState;
-  /**
-   * computed from `options.manifest`
-   */
-  get manifest(): MasterCSSManifest;
-  readonly slotCSSRule = "#master-css-slot{--slot:0}";
-}
-declare function createScanner(options: MasterCSSScannerOptions, cwd?: string): Promise<MasterCSSScanner>;
-interface MasterCSSScanner {
-  options: MasterCSSScannerOptions;
-}
-export { MasterCSSScanner, MasterCSSScannerSourceResult, ScannerCSSView, type ScannerSourceInput, type ScannerSourceOptions, ScannerStateSetView, createScanner };