@master/css-binding-wasm-tooling 0.0.0-stage → 2.0.0

package/dist/index.js

@@ -0,0 +1,126 @@
+import { MasterCSSError } from "@master/css-schema";
+// src/index.ts
+let modulePromise;
+const initializedInputs = /* @__PURE__ */ new WeakMap();
+const defaultWasmURL = new URL("../artifacts/mastercss_binding_wasm_tooling_bg.wasm", import.meta.url);
+function sameInput(left, right) {
+	return left === right || String(left) === String(right);
+}
+async function initializeModule(module, input) {
+	const initializedInput = initializedInputs.get(module);
+	if (initializedInput !== void 0) {
+		if (!sameInput(initializedInput, input)) throw new MasterCSSError({
+			code: "WASM_INPUT_CONFLICT",
+			domain: "binding",
+			message: "A Master CSS tooling Wasm module cannot be initialized with two different inputs."
+		});
+		return module;
+	}
+	await module.default({ module_or_path: input });
+	initializedInputs.set(module, input);
+	return module;
+}
+async function importGeneratedModule() {
+	return await import("./artifacts/mastercss_binding_wasm_tooling.js");
+}
+async function initToolingWasm(options = {}) {
+	try {
+		if (options.module) {
+			const module = options.module;
+			return await initializeModule(module, options.input || defaultWasmURL);
+		}
+		if (options.input !== void 0) return await initializeModule(await importGeneratedModule(), options.input);
+		modulePromise ??= importGeneratedModule().then((module) => initializeModule(module, defaultWasmURL)).catch((cause) => {
+			modulePromise = void 0;
+			throw cause;
+		});
+		return await modulePromise;
+	} catch (cause) {
+		if (cause instanceof MasterCSSError) throw cause;
+		throw new MasterCSSError({
+			code: "WASM_LOAD_FAILED",
+			domain: "binding",
+			message: cause instanceof Error ? cause.message : "Cannot load the Master CSS tooling Wasm artifact."
+		}, { cause });
+	}
+}
+async function createToolingScannerSession(manifestJSON, options = {}) {
+	const session = new (await (initToolingWasm(options))).ToolingScannerSession(manifestJSON);
+	return {
+		scan: (source, content) => session.scan(source, content),
+		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: (classNames) => session.ensureClasses(classNames),
+		registerNativeClasses: (owner, classNames) => session.registerNativeClasses(owner, classNames),
+		reset: () => session.reset(),
+		state: () => session.state(),
+		dispose() {
+			session.dispose();
+			session.free();
+		}
+	};
+}
+async function createToolingValidatorSession(manifestJSON, options = {}) {
+	const session = new (await (initToolingWasm(options))).ToolingValidatorSession(manifestJSON);
+	return {
+		nativeDeclarationCandidates: (classNames) => session.nativeDeclarationCandidates(classNames),
+		generateClasses: (classNames, nativeSupport) => session.generateClasses(classNames, nativeSupport),
+		dispose() {
+			session.dispose();
+			session.free();
+		}
+	};
+}
+async function createToolingInspectionReport(input, options = {}) {
+	return (await initToolingWasm(options)).createInspectionReport(input);
+}
+async function createToolingLanguageSession(manifestJSON, options = {}) {
+	const session = new (await (initToolingWasm(options))).ToolingLanguageSession(manifestJSON);
+	return {
+		prepareDocument: (request) => session.prepareDocument(request),
+		finishDocument: (id, support) => session.finishDocument(id, support),
+		cancelDocument: (id) => session.cancelDocument(id),
+		analyzeDocument: (request) => session.analyzeDocument(request),
+		formatDirectives: (request) => session.formatDirectives(request),
+		nativeDeclarationCompletion: (request) => session.nativeDeclarationCompletion(request),
+		nativeDeclarationCandidates: (classNames) => session.nativeDeclarationCandidates(classNames),
+		classifyClassNames: (classNames, nativeSupport) => session.classifyClassNames(classNames, nativeSupport || []),
+		inspectClassName: (className, nativeSupport, mode) => session.inspectClassName(className, nativeSupport || [], mode),
+		tokenFamilies: () => session.tokenFamilies(),
+		completionIndex: () => session.completionIndex(),
+		colorPresentation: (colorToken) => session.colorPresentation(colorToken),
+		colorTokens: (candidates) => session.colorTokens(candidates),
+		dispose() {
+			session.dispose();
+			session.free();
+		}
+	};
+}
+async function createToolingLintSession(manifestJSON, options = {}) {
+	const session = new (await (initToolingWasm(options))).ToolingLintSession(manifestJSON);
+	return {
+		inspectDesignSystem: (request) => session.inspectDesignSystem(JSON.stringify(request)),
+		suggestClasses: (declarations) => {
+			if (typeof session.suggestClasses !== "function") throw new Error("The Wasm binding does not support suggestClasses. Rebuild or update the Master CSS binding to match the tooling package.");
+			return session.suggestClasses(declarations);
+		},
+		nativeDeclarationCandidates: (classNames) => session.nativeDeclarationCandidates(classNames),
+		resolveValidation: (batch, ruleErrors) => session.resolveValidation(batch, ruleErrors),
+		canonicalClassNames: (classNames, nativeSupport, options) => session.canonicalClassNames(classNames, nativeSupport, options),
+		canonicalClassGroups: (classNames, nativeSupport, options) => session.canonicalClassGroups(classNames, nativeSupport, options),
+		rawValueCandidates: (classNames, nativeSupport, invalidGeneratedClasses) => session.rawValueCandidates(classNames, nativeSupport, invalidGeneratedClasses),
+		analyze: (classNames, nativeSupport, invalidGeneratedClasses) => session.analyze(classNames, nativeSupport, invalidGeneratedClasses),
+		analyzeClassList: (classList, classNames, nativeSupport, invalidGeneratedClasses) => session.analyzeClassList(classList, classNames, nativeSupport, invalidGeneratedClasses),
+		analyzeClassListPolicy: (requestJSON) => session.analyzeClassListPolicy(requestJSON),
+		dispose() {
+			session.dispose();
+			session.free();
+		}
+	};
+}
+export { createToolingInspectionReport, createToolingLanguageSession, createToolingLintSession, createToolingScannerSession, createToolingValidatorSession, initToolingWasm };

package/dist/provider-node.d.ts

@@ -0,0 +1,3 @@
+import { MasterCSSWasmToolingLoadOptions, MasterCSSWasmToolingLoadOptions as MasterCSSWasmToolingLoadOptions$1 } from "./provider.js";
+declare function createMasterCSSToolingWasmProvider(options?: MasterCSSWasmToolingLoadOptions$1): Promise<object>;
+export { type MasterCSSWasmToolingLoadOptions, createMasterCSSToolingWasmProvider };

package/dist/provider-node.js

@@ -0,0 +1,21 @@
+import { createMasterCSSToolingWasmProvider as createMasterCSSToolingWasmProvider$1 } from "./provider.js";
+import { readFile } from "node:fs/promises";
+// src/provider-node.ts
+const defaultWasmURL = new URL("../artifacts/mastercss_binding_wasm_tooling_bg.wasm", import.meta.url);
+function resolveFileURL(input) {
+	if (input instanceof URL) return input.protocol === "file:" ? input : void 0;
+	if (typeof input !== "string" || !input.startsWith("file:")) return;
+	return new URL(input);
+}
+async function withNodeWasmInput(options) {
+	const fileURL = options.input === void 0 ? defaultWasmURL : resolveFileURL(options.input);
+	if (!fileURL) return options;
+	return {
+		...options,
+		input: new Uint8Array(await readFile(fileURL))
+	};
+}
+async function createMasterCSSToolingWasmProvider(options = {}) {
+	return await createMasterCSSToolingWasmProvider$1(await withNodeWasmInput(options));
+}
+export { createMasterCSSToolingWasmProvider };

package/dist/provider.d.ts

@@ -0,0 +1,7 @@
+type MasterCSSWasmToolingInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+interface MasterCSSWasmToolingLoadOptions {
+  readonly module?: object;
+  readonly input?: MasterCSSWasmToolingInput;
+}
+declare function createMasterCSSToolingWasmProvider(options?: MasterCSSWasmToolingLoadOptions): Promise<object>;
+export { MasterCSSWasmToolingInput, MasterCSSWasmToolingLoadOptions, createMasterCSSToolingWasmProvider };

package/dist/provider.js

@@ -0,0 +1,44 @@
+import { createToolingInspectionReport, createToolingLanguageSession, createToolingLintSession, createToolingScannerSession, createToolingValidatorSession, initToolingWasm } from "./index.js";
+// src/provider.ts
+async function createMasterCSSToolingWasmProvider(options = {}) {
+	const module = await initToolingWasm(options);
+	return Object.freeze({
+		info: module.bindingInfo(),
+		async createLexerSession() {
+			const session = new module.ToolingLexerSession();
+			let disposed = false;
+			return Object.freeze({
+				analyze: (request) => session.analyze(request),
+				dispose() {
+					if (disposed) return;
+					disposed = true;
+					session.dispose();
+					session.free();
+				}
+			});
+		},
+		async createSourceSession() {
+			const session = new module.ToolingSourceSession();
+			let disposed = false;
+			return Object.freeze({
+				extract: (request) => session.extract(request),
+				dispose() {
+					if (disposed) return;
+					disposed = true;
+					session.dispose();
+					session.free();
+				}
+			});
+		},
+		createScannerSession: (manifestJSON) => createToolingScannerSession(manifestJSON, options),
+		createValidatorSession: (manifestJSON) => createToolingValidatorSession(manifestJSON, options),
+		createLanguageSession: (manifestJSON) => createToolingLanguageSession(manifestJSON, options),
+		createLintSession: (manifestJSON) => createToolingLintSession(manifestJSON, options),
+		createInspectionReport: (input) => createToolingInspectionReport(input, options),
+		extractClassCandidates: (content) => module.extractClassCandidates(content),
+		extractOxcClasses: (source, content) => module.extractOxcClasses(source, content),
+		extractHTMLClasses: (source, content) => module.extractHTMLClasses(source, content),
+		extractAstroClasses: (source, content) => module.extractAstroClasses(source, content)
+	});
+}
+export { createMasterCSSToolingWasmProvider };

package/package.json

@@ -1,6 +1,47 @@
 {
-  "name": "@master/css-binding-wasm-tooling",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+    "name": "@master/css-binding-wasm-tooling",
+    "type": "module",
+    "engines": {
+        "node": "^24"
+    },
+    "scripts": {
+        "build": "bun --bun tsdown --config ../../shared/tsdown-package.config.ts",
+        "build:artifacts": "cargo xtask build-wasm tooling",
+        "dev": "bun --bun tsdown --config ../../shared/tsdown-package.config.ts --watch",
+        "test": "bun --bun vitest run",
+        "type-check": "bun --bun tsc -b tsconfig.typecheck.json",
+        "lint": "bun --bun eslint"
+    },
+    "license": "MIT",
+    "description": "Internal Master CSS tooling Wasm binding provider.",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/master-co/css.git",
+        "directory": "packages/binding-wasm-tooling"
+    },
+    "sideEffects": false,
+    "types": "./dist/provider.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/provider.d.ts",
+            "browser": "./dist/provider.js",
+            "node": "./dist/provider-node.js",
+            "import": "./dist/provider.js",
+            "default": "./dist/provider.js"
+        },
+        "./wasm": "./artifacts/mastercss_binding_wasm_tooling_bg.wasm"
+    },
+    "files": [
+        "dist",
+        "artifacts"
+    ],
+    "publishConfig": {
+        "access": "public",
+        "provenance": true
+    },
+    "dependencies": {
+        "@master/css-schema": "2.0.0"
+    },
+    "version": "2.0.0",
+    "gitHead": "6bf9adc4432b67e62613caea59d3b554711b4d54"
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.