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

package/dist/syntax-validation.d.ts

@@ -0,0 +1,10 @@
+import { MasterCSSSyntaxStatus } from "@master/css-binding/tooling";
+declare const CSS_SYNTAX_CHECK: Readonly<{
+  name: "@eslint/css-tree";
+  version: string;
+  phase: 'css-syntax';
+  scope: 'selectors-queries-declarations';
+}>;
+/** Token structure is independent of property grammars and browser support. */
+declare function cssSyntaxStatus(text: string): MasterCSSSyntaxStatus;
+export { CSS_SYNTAX_CHECK, cssSyntaxStatus };

package/dist/syntax-validation.js

@@ -0,0 +1,54 @@
+import { cssTreeVersion } from "./css-tree-version.js";
+import { parse, tokenTypes, tokenize } from "@eslint/css-tree";
+// src/syntax-validation.ts
+const CSS_SYNTAX_CHECK = Object.freeze({
+	name: "@eslint/css-tree",
+	version: cssTreeVersion,
+	phase: "css-syntax",
+	scope: "selectors-queries-declarations"
+});
+/** Token structure is independent of property grammars and browser support. */
+function cssSyntaxStatus(text) {
+	const stack = [];
+	let invalid = false;
+	tokenize(text, (type, start, end) => {
+		switch (type) {
+			case tokenTypes.Function:
+			case tokenTypes.LeftParenthesis:
+				stack.push(tokenTypes.RightParenthesis);
+				break;
+			case tokenTypes.LeftSquareBracket:
+				stack.push(tokenTypes.RightSquareBracket);
+				break;
+			case tokenTypes.LeftCurlyBracket:
+				stack.push(tokenTypes.RightCurlyBracket);
+				break;
+			case tokenTypes.RightParenthesis:
+			case tokenTypes.RightSquareBracket:
+			case tokenTypes.RightCurlyBracket:
+				invalid ||= stack.pop() !== type;
+				break;
+			case tokenTypes.BadString:
+			case tokenTypes.BadUrl:
+				invalid = true;
+				break;
+			case tokenTypes.Comment:
+				invalid ||= text.slice(end - 2, end) !== "*/";
+				break;
+			case tokenTypes.String: invalid ||= text[end - 1] !== text[start] || end - start < 2;
+		}
+	});
+	if (invalid || stack.length) return "invalid";
+	try {
+		let unknown = false;
+		return parse(text, {
+			parseCustomProperty: false,
+			onParseError: () => {
+				unknown = true;
+			}
+		}) && !unknown ? "valid" : "unknown";
+	} catch {
+		return "unknown";
+	}
+}
+export { CSS_SYNTAX_CHECK, cssSyntaxStatus };

package/dist/tooling-session.d.ts

@@ -0,0 +1,66 @@
+import { LexerSession } from "./lexer/session.js";
+import { MasterCSSClassListAnalysis, MasterCSSClassListAnalysisRequest } from "./lexer/contracts.js";
+import { MasterCSSDocumentAnalysis, MasterCSSDocumentAnalysisRequest, MasterCSSFormatDirectivesRequest, MasterCSSFormatDirectivesResult, MasterCSSLanguageClassifications, MasterCSSLanguageColorCandidate, MasterCSSLanguageColorPresentation, MasterCSSLanguageColorTokens, MasterCSSLanguageCompletionIndex, MasterCSSLanguageInspection as MasterCSSLanguageInspection$1, MasterCSSLanguageTokenFamilies, MasterCSSNativeDeclarationCompletion, MasterCSSNativeDeclarationCompletionRequest } from "./language/contracts.js";
+import { LanguageSession } from "./language/session.js";
+import { CanonicalClassNameOptions } from "./lint/contracts.js";
+import { MasterCSSLintAnalysis, MasterCSSLintCanonicalClassGroupSuggestion, MasterCSSLintCanonicalClassSuggestion, MasterCSSLintClassListAnalysis, MasterCSSLintClassListOptions, MasterCSSLintDocumentAnalysis, MasterCSSLintRawValueCandidate, MasterCSSLintToken } from "./lint/analysis.js";
+import { LintSession } from "./lint/binding-session.js";
+import { SourceExtractor } from "./source/session.js";
+import { MasterCSSDecodedHTMLAttribute, MasterCSSSourceExtraction, MasterCSSSourceExtractionRequest } from "./source/contracts.js";
+import { MasterCSSClassValidationResult } from "./validator/contracts.js";
+import { ValidatorSession } from "./validator/binding-session.js";
+import { MasterCSSClassSuggestions, MasterCSSDesignSystemReport, MasterCSSDesignSystemRequest } from "@master/css-binding/tooling";
+import { MasterCSSBinding } from "@master/css-binding";
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+interface ToolingSessionParts {
+  readonly lexer: LexerSession;
+  readonly source: SourceExtractor;
+  readonly validator: ValidatorSession;
+  readonly lint: LintSession;
+  readonly language: LanguageSession;
+}
+interface MasterCSSToolingSessionOptions {
+  readonly manifest: MasterCSSManifest;
+  /** Classes the project defines in native CSS; they report no diagnostics while they generate no rules. */
+  readonly nativeClassNames?: readonly string[];
+  readonly binding?: MasterCSSBinding;
+}
+declare class MasterCSSToolingSession implements Disposable {
+  private readonly parts;
+  private disposed;
+  private constructor();
+  get binding(): 'native' | 'wasm';
+  /** Advisory declaration conversion; does not prove surrounding cascade or browser behavior. */
+  suggestClasses(declarations: string): MasterCSSClassSuggestions;
+  analyzeClassList(request: MasterCSSClassListAnalysisRequest): MasterCSSClassListAnalysis;
+  extractSource(request: MasterCSSSourceExtractionRequest): MasterCSSSourceExtraction;
+  /** Decode HTML attribute contents without delimiters, preserving UTF-16 spans. */
+  decodeHTMLAttribute(source: string): MasterCSSDecodedHTMLAttribute;
+  extractClassCandidates(content: string): readonly string[];
+  validateClassNames(classNames: readonly string[]): MasterCSSClassValidationResult;
+  lintClassNames(classNames: readonly string[]): MasterCSSLintAnalysis;
+  /** Inspect authored CSS and tool-only definition information without generating CSS. */
+  inspectDesignSystem(request: MasterCSSDesignSystemRequest): MasterCSSDesignSystemReport;
+  tokenizeClassList(classList: string, unescape?: string | false): readonly MasterCSSLintToken[];
+  analyzeLintDocument(source: string, languageId: string): MasterCSSLintDocumentAnalysis;
+  analyzeLintClassList(classList: string, classNames: readonly string[], options?: MasterCSSLintClassListOptions): MasterCSSLintClassListAnalysis;
+  canonicalClassNames(classNames: readonly string[], options?: CanonicalClassNameOptions): readonly MasterCSSLintCanonicalClassSuggestion[];
+  canonicalClassGroups(classNames: readonly string[], options?: CanonicalClassNameOptions): readonly MasterCSSLintCanonicalClassGroupSuggestion[];
+  rawValueCandidates(classNames: readonly string[]): readonly MasterCSSLintRawValueCandidate[];
+  analyzeDocument(request: MasterCSSDocumentAnalysisRequest): MasterCSSDocumentAnalysis;
+  formatDirectives(request: MasterCSSFormatDirectivesRequest): MasterCSSFormatDirectivesResult;
+  nativeDeclarationCompletion(request: MasterCSSNativeDeclarationCompletionRequest): MasterCSSNativeDeclarationCompletion | undefined;
+  classifyClassNames(classNames: readonly string[]): MasterCSSLanguageClassifications;
+  inspectClassName(className: string): MasterCSSLanguageInspection$1;
+  tokenFamilies(): MasterCSSLanguageTokenFamilies;
+  completionIndex(): MasterCSSLanguageCompletionIndex;
+  colorPresentation(colorToken: string): MasterCSSLanguageColorPresentation;
+  colorTokens(candidates: readonly MasterCSSLanguageColorCandidate[]): MasterCSSLanguageColorTokens;
+  dispose(): void;
+  [Symbol.dispose](): void;
+  private assertActive;
+}
+declare function createToolingSession(options: MasterCSSToolingSessionOptions): Promise<MasterCSSToolingSession>;
+/** @internal */
+declare function bindToolingSessionInternal(parts: ToolingSessionParts): MasterCSSToolingSession;
+export { MasterCSSToolingSession, MasterCSSToolingSessionOptions, ToolingSessionParts, bindToolingSessionInternal, createToolingSession };

package/dist/tooling-session.js

@@ -0,0 +1,188 @@
+import { bindLexerSession } from "./lexer/session.js";
+import { freezeToolingResult } from "./immutable.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 { createToolingBinding } from "@master/css-binding/tooling";
+// src/tooling-session.ts
+let bindToolingSession;
+var MasterCSSToolingSession = class MasterCSSToolingSession {
+	parts;
+	disposed = false;
+	constructor(parts) {
+		this.parts = parts;
+	}
+	get binding() {
+		this.assertActive();
+		return this.parts.language.binding;
+	}
+	/** Advisory declaration conversion; does not prove surrounding cascade or browser behavior. */
+	suggestClasses(declarations) {
+		this.assertActive();
+		const result = this.parts.lint.suggestClasses(declarations);
+		if (result.version !== 1) throw new Error(`Unsupported class suggestions version: ${String(result.version)}`);
+		return freezeToolingResult(result);
+	}
+	analyzeClassList(request) {
+		this.assertActive();
+		return freezeToolingResult(this.parts.lexer.analyze({
+			classLists: request.classLists?.map((input) => ({
+				source: input.source,
+				...input.unescape ? { unescape: [...input.unescape] } : {}
+			})),
+			cssSources: request.cssSources ? [...request.cssSources] : void 0,
+			escapeIdentifiers: request.escapeIdentifiers ? [...request.escapeIdentifiers] : void 0
+		}));
+	}
+	extractSource(request) {
+		this.assertActive();
+		return freezeToolingResult(this.parts.source.extract({ files: request.files.map((file) => ({ ...file })) }));
+	}
+	/** Decode HTML attribute contents without delimiters, preserving UTF-16 spans. */
+	decodeHTMLAttribute(source) {
+		this.assertActive();
+		const result = this.parts.source.extract({
+			files: [],
+			htmlAttributes: [source]
+		}).htmlAttributes?.[0];
+		if (!result) throw new Error("The loaded Master CSS source binding does not support HTML attribute mapping. Rebuild or update the binding.");
+		return freezeToolingResult(result);
+	}
+	extractClassCandidates(content) {
+		this.assertActive();
+		return Object.freeze([...this.parts.source.extractClassCandidates(content)]);
+	}
+	validateClassNames(classNames) {
+		this.assertActive();
+		return freezeToolingResult(this.parts.validator.generate(classNames));
+	}
+	lintClassNames(classNames) {
+		this.assertActive();
+		return freezeToolingResult(this.parts.lint.analyze([...classNames]));
+	}
+	/** Inspect authored CSS and tool-only definition information without generating CSS. */
+	inspectDesignSystem(request) {
+		this.assertActive();
+		return freezeToolingResult(this.parts.lint.inspectDesignSystem(request));
+	}
+	tokenizeClassList(classList, unescape) {
+		this.assertActive();
+		return freezeToolingResult(this.parts.lint.tokenizeClassList(classList, unescape));
+	}
+	analyzeLintDocument(source, languageId) {
+		this.assertActive();
+		return freezeToolingResult(this.parts.lint.analyzeDocument(source, languageId));
+	}
+	analyzeLintClassList(classList, classNames, options) {
+		this.assertActive();
+		return freezeToolingResult(this.parts.lint.analyzeClassList(classList, [...classNames], options));
+	}
+	canonicalClassNames(classNames, options) {
+		this.assertActive();
+		return freezeToolingResult(this.parts.lint.canonicalClassNames([...classNames], options));
+	}
+	canonicalClassGroups(classNames, options) {
+		this.assertActive();
+		return freezeToolingResult(this.parts.lint.canonicalClassGroups([...classNames], options));
+	}
+	rawValueCandidates(classNames) {
+		this.assertActive();
+		return freezeToolingResult(this.parts.lint.rawValueCandidates([...classNames]));
+	}
+	analyzeDocument(request) {
+		this.assertActive();
+		return freezeToolingResult(this.parts.language.analyzeDocument(request));
+	}
+	formatDirectives(request) {
+		this.assertActive();
+		return freezeToolingResult(this.parts.language.formatDirectives(request));
+	}
+	nativeDeclarationCompletion(request) {
+		this.assertActive();
+		const completion = this.parts.language.nativeDeclarationCompletion(request);
+		return completion && freezeToolingResult(completion);
+	}
+	classifyClassNames(classNames) {
+		this.assertActive();
+		return freezeToolingResult(this.parts.language.classifyClassNames(classNames));
+	}
+	inspectClassName(className) {
+		this.assertActive();
+		return freezeToolingResult(this.parts.language.inspectClassName(className));
+	}
+	tokenFamilies() {
+		this.assertActive();
+		return freezeToolingResult(this.parts.language.tokenFamilies());
+	}
+	completionIndex() {
+		this.assertActive();
+		return freezeToolingResult(this.parts.language.completionIndex());
+	}
+	colorPresentation(colorToken) {
+		this.assertActive();
+		return freezeToolingResult(this.parts.language.colorPresentation(colorToken));
+	}
+	colorTokens(candidates) {
+		this.assertActive();
+		return freezeToolingResult(this.parts.language.colorTokens(candidates));
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		const sessions = /* @__PURE__ */ new Set([
+			this.parts.lexer,
+			this.parts.source,
+			this.parts.validator,
+			this.parts.lint,
+			this.parts.language
+		]);
+		for (const session of sessions) session.dispose();
+	}
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+	assertActive() {
+		if (this.disposed) throw new TypeError("The Master CSS tooling session has been disposed.");
+	}
+	static {
+		bindToolingSession = (parts) => new MasterCSSToolingSession(parts);
+	}
+};
+async function createToolingSession(options) {
+	const binding = await createToolingBinding({ binding: options.binding });
+	const created = [];
+	try {
+		const lexerBinding = await binding.createLexerSession();
+		created.push(lexerBinding);
+		const sourceBinding = await binding.createSourceSession();
+		created.push(sourceBinding);
+		const validatorBinding = await binding.createValidatorSession(options.manifest);
+		created.push(validatorBinding);
+		const languageBinding = await binding.createLanguageSession(options.manifest);
+		created.push(languageBinding);
+		const lintBinding = await binding.createLintSession(options.manifest);
+		created.push(lintBinding);
+		const lintValidatorBinding = await binding.createValidatorSession(options.manifest);
+		created.push(lintValidatorBinding);
+		const lintLanguageBinding = await binding.createLanguageSession(options.manifest);
+		created.push(lintLanguageBinding);
+		const session = bindToolingSession({
+			lexer: bindLexerSession(binding.binding, lexerBinding),
+			source: bindSourceExtractor(binding.binding, sourceBinding),
+			validator: bindValidatorSession(binding.binding, validatorBinding, options.nativeClassNames),
+			lint: bindLintSession(lintBinding, lintValidatorBinding, lintLanguageBinding),
+			language: bindLanguageSession(binding.binding, languageBinding, options.nativeClassNames)
+		});
+		created.length = 0;
+		return session;
+	} catch (cause) {
+		for (const session of new Set(created)) session.dispose();
+		throw cause;
+	}
+}
+/** @internal */
+function bindToolingSessionInternal(parts) {
+	return bindToolingSession(parts);
+}
+export { MasterCSSToolingSession, bindToolingSessionInternal, createToolingSession };

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

@@ -0,0 +1,17 @@
+import { MasterCSSClassValidationResult } from "./contracts.js";
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+interface BindingValidatorSession {
+  nativeDeclarationCandidates(classNames: string[]): unknown;
+  generateClassRules(classNames: string[], nativeSupport?: boolean[]): unknown;
+  dispose(): void;
+}
+interface ValidatorSession {
+  readonly binding: 'native' | 'wasm';
+  generate(classNames: readonly string[]): MasterCSSClassValidationResult;
+  dispose(): void;
+}
+declare function bindValidatorSession(binding: ValidatorSession['binding'], session: BindingValidatorSession, nativeClassNames?: readonly string[]): ValidatorSession;
+declare function createValidator(manifest: MasterCSSManifest, options?: {
+  readonly binding?: 'auto' | 'native' | 'wasm';
+}): Promise<ValidatorSession>;
+export { ValidatorSession, bindValidatorSession, createValidator };

package/dist/validator/binding-session.js

@@ -0,0 +1,29 @@
+import { withCSSValueValidation } from "../value-validation.js";
+import { createToolingBinding } from "@master/css-binding/tooling";
+// src/validator/binding-session.ts
+function parse(value) {
+	return value;
+}
+function bindValidatorSession(binding, session, nativeClassNames = []) {
+	const nativeClasses = new Set(nativeClassNames);
+	return {
+		binding,
+		generate(classNames) {
+			const values = [...classNames];
+			const result = parse(session.generateClassRules(values));
+			return {
+				...result,
+				classes: result.classes.map((result) => withCSSValueValidation({
+					...result,
+					diagnostics: nativeClasses.has(result.className) && !result.rules.length ? [] : result.diagnostics ?? []
+				}))
+			};
+		},
+		dispose: () => session.dispose()
+	};
+}
+async function createValidator(manifest, options = {}) {
+	const tooling = await createToolingBinding({ binding: options.binding });
+	return bindValidatorSession(tooling.binding, await tooling.createValidatorSession(manifest));
+}
+export { bindValidatorSession, createValidator };

package/dist/validator/contracts.d.ts

@@ -0,0 +1,24 @@
+import { DeclarationValidation } from "../value-validation.js";
+import { MasterCSSValidatorBatch } from "@master/css-binding/tooling";
+import { MasterCSSHydrationRule } from "@master/css-schema/hydration-manifest";
+interface MasterCSSClassValidation {
+  readonly className: string;
+  readonly matchStatus: MasterCSSValidatorBatch['classes'][number]['matchStatus'];
+  readonly declarations: readonly DeclarationValidation[];
+  readonly checks: readonly {
+    readonly name: string;
+    readonly version: string;
+    readonly scope: string;
+    readonly phase: import('@master/css-binding/tooling').MasterCSSDiagnostic['phase'];
+  }[];
+  readonly cssSyntaxStatus: MasterCSSValidatorBatch['classes'][number]['cssSyntaxStatus'];
+  readonly cssValueStatus: MasterCSSValidatorBatch['classes'][number]['cssValueStatus'];
+  readonly browserSupport: MasterCSSValidatorBatch['classes'][number]['browserSupport'];
+  readonly rules: readonly MasterCSSHydrationRule[];
+  readonly diagnostics?: readonly import('@master/css-binding/tooling').MasterCSSDiagnostic[];
+}
+interface MasterCSSClassValidationResult {
+  readonly version: 4;
+  readonly classes: readonly MasterCSSClassValidation[];
+}
+export { MasterCSSClassValidation, MasterCSSClassValidationResult };

package/dist/validator/contracts.js

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

package/dist/validator/index.d.ts

@@ -0,0 +1,10 @@
+import { CSS_VALUE_CHECK, DeclarationValidation, cssValueStatus, validateRuleDeclarations } from "../value-validation.js";
+import { CSS_SYNTAX_CHECK, cssSyntaxStatus } from "../syntax-validation.js";
+import { MasterCSSClassValidation, MasterCSSClassValidationResult } from "./contracts.js";
+import { MasterCSSBinding } from "@master/css-binding";
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+declare function validateClassNames(classNames: readonly string[], options: {
+  readonly manifest: MasterCSSManifest;
+  readonly binding?: MasterCSSBinding;
+}): Promise<MasterCSSClassValidationResult>;
+export { CSS_SYNTAX_CHECK, CSS_VALUE_CHECK, type DeclarationValidation, type MasterCSSClassValidation, type MasterCSSClassValidationResult, cssSyntaxStatus, cssValueStatus, validateClassNames, validateRuleDeclarations };

package/dist/validator/index.js

@@ -0,0 +1,13 @@
+import { CSS_SYNTAX_CHECK, cssSyntaxStatus } from "../syntax-validation.js";
+import { CSS_VALUE_CHECK, cssValueStatus, validateRuleDeclarations } from "../value-validation.js";
+import { createToolingSession } from "../tooling-session.js";
+// src/validator/index.ts
+async function validateClassNames(classNames, options) {
+	const session = await createToolingSession(options);
+	try {
+		return session.validateClassNames(classNames);
+	} finally {
+		session.dispose();
+	}
+}
+export { CSS_SYNTAX_CHECK, CSS_VALUE_CHECK, cssSyntaxStatus, cssValueStatus, validateClassNames, validateRuleDeclarations };

package/dist/validator/node.d.ts

@@ -0,0 +1,6 @@
+import { MasterCSSClassValidationResult } from "./contracts.js";
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+declare function validateClassNamesSync(classNames: readonly string[], options: {
+  readonly manifest: MasterCSSManifest;
+}): MasterCSSClassValidationResult;
+export { validateClassNamesSync };

package/dist/validator/node.js

@@ -0,0 +1,11 @@
+import { createToolingSessionSync } from "../node.js";
+// src/validator/node.ts
+function validateClassNamesSync(classNames, options) {
+	const session = createToolingSessionSync(options);
+	try {
+		return session.validateClassNames(classNames);
+	} finally {
+		session.dispose();
+	}
+}
+export { validateClassNamesSync };

package/dist/validator/types/syntax-error.d.ts

@@ -0,0 +1,22 @@
+interface SyntaxError {
+  class?: string;
+  name?: string;
+  message?: string;
+  stack?: string;
+  rawMessage?: string;
+  syntax?: string;
+  css?: string;
+  mismatchOffset?: number;
+  mismatchLength?: number;
+  offset?: number;
+  line?: number;
+  column?: number;
+  loc?: {
+    source?: string;
+    start: any;
+    end: any;
+  };
+  property?: string;
+  details?: string;
+}
+export { SyntaxError };

package/dist/validator/types/syntax-error.js

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

package/dist/value-validation.d.ts

@@ -0,0 +1,46 @@
+import { MasterCSSDiagnostic, MasterCSSValueStatus } from "@master/css-binding/tooling";
+interface DeclarationValidation {
+  readonly property: string;
+  readonly value: string;
+  readonly atRule?: string;
+  readonly status: MasterCSSValueStatus;
+  readonly range?: {
+    readonly start: number;
+    readonly end: number;
+  };
+}
+declare const CSS_VALUE_CHECK: Readonly<{
+  name: "@eslint/css-tree";
+  version: string;
+  phase: 'css-value';
+  scope: 'expanded-declarations-and-known-math-grammar-and-static-types-v1';
+}>;
+/** Grammar knowledge is a report, never permission to generate a declaration. */
+declare function cssValueStatus(property: string, value: string): MasterCSSValueStatus;
+declare function validateRuleDeclarations(text: string): DeclarationValidation[];
+declare function withCSSValueValidation<T extends {
+  readonly cssSyntaxStatus?: import('@master/css-binding/tooling').MasterCSSSyntaxStatus;
+  readonly className: string;
+  readonly rules: readonly {
+    readonly text: string;
+  }[];
+  readonly diagnostics?: readonly MasterCSSDiagnostic[];
+}>(result: T): T & {
+  cssSyntaxStatus: import("@master/css-binding/protocol").MasterCSSSyntaxStatus;
+  cssValueStatus: MasterCSSValueStatus;
+  browserSupport: 'not-checked';
+  checks: (Readonly<{
+    name: "@eslint/css-tree";
+    version: string;
+    phase: 'css-syntax';
+    scope: 'selectors-queries-declarations';
+  }> | Readonly<{
+    name: "@eslint/css-tree";
+    version: string;
+    phase: 'css-value';
+    scope: 'expanded-declarations-and-known-math-grammar-and-static-types-v1';
+  }>)[];
+  declarations: DeclarationValidation[];
+  diagnostics: MasterCSSDiagnostic[];
+};
+export { CSS_VALUE_CHECK, DeclarationValidation, cssValueStatus, validateRuleDeclarations, withCSSValueValidation };