@rafters/veneer 0.0.2 → 0.0.4

package/dist/bin.mjs

@@ -1,20 +1,54 @@
 #!/usr/bin/env node
-import { t as check } from "./check-DxTxqBre.mjs";
+import { i as relativeFile } from "./lint-Bqu-nKvP.mjs";
+import { t as check } from "./check-vsAQPYCD.mjs";
+import path from "node:path";
+import { existsSync, realpathSync } from "node:fs";
+import { parseArgs } from "node:util";
+import { text } from "node:stream/consumers";
 //#region src/bin.ts
-const [root, ...rest] = process.argv.slice(2);
-if (root?.startsWith("-") || rest.length > 0) {
-	process.stderr.write("usage: rafters-check [root]\n");
-	process.exitCode = 1;
-} else {
-	const result = await check(root ?? process.cwd());
-	if (result.ok) {
-		process.stdout.write(result.report);
-		for (const { message } of result.notices) process.stderr.write(`${message}\n`);
-		process.exitCode = result.diagnostics.some(({ severity }) => severity === "error") ? 1 : 0;
-	} else {
+const COULD_NOT_RUN = 2;
+function parsedArguments() {
+	try {
+		const { values, positionals } = parseArgs({
+			allowPositionals: true,
+			options: { stdin: { type: "string" } }
+		});
+		const [root, ...rest] = positionals;
+		return rest.length > 0 ? void 0 : {
+			root,
+			stdinPath: values.stdin
+		};
+	} catch {
+		return;
+	}
+}
+function resolvedLinks(file) {
+	if (existsSync(file)) return realpathSync(file);
+	const parent = path.dirname(file);
+	return parent === file ? file : path.join(resolvedLinks(parent), path.basename(file));
+}
+async function run(root, stdinPath) {
+	const file = stdinPath && relativeFile(resolvedLinks(root), resolvedLinks(path.resolve(stdinPath)));
+	const unsaved = file === void 0 ? void 0 : { [file]: await text(process.stdin) };
+	const result = await check(root, { unsaved });
+	if (!result.ok) {
 		for (const { message } of result.errors) process.stderr.write(`${message}\n`);
-		process.exitCode = 1;
+		return COULD_NOT_RUN;
 	}
+	process.stdout.write(result.report);
+	for (const { message } of result.notices) process.stderr.write(`${message}\n`);
+	return result.diagnostics.some(({ severity }) => severity === "error") ? 1 : 0;
+}
+const parsed = parsedArguments();
+if (parsed) try {
+	process.exitCode = await run(parsed.root ?? process.cwd(), parsed.stdinPath);
+} catch (error) {
+	process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+	process.exitCode = COULD_NOT_RUN;
+}
+else {
+	process.stderr.write("usage: rafters-check [root] [--stdin <path>]\n");
+	process.exitCode = COULD_NOT_RUN;
 }
 //#endregion
 export {};

package/dist/{check-DxTxqBre.mjs → check-vsAQPYCD.mjs}

@@ -1,4 +1,4 @@
-import { a as ProjectError, i as resolveComponents, n as report, o as openProject, r as compareCodePoints, s as readConfig, t as lint } from "./lint-BabXVYQJ.mjs";
+import { a as resolveComponents, c as readConfig, n as report, o as ProjectError, r as compareCodePoints, s as openProject, t as lint } from "./lint-Bqu-nKvP.mjs";
 import path from "node:path";
 import { mkdir, rename, rm, writeFile } from "node:fs/promises";
 import { lstatSync } from "node:fs";
@@ -139,6 +139,7 @@ async function check(projectRoot, options = {}) {
 		const asked = options.paths ?? (unsavedFiles.length > 0 ? unsavedFiles : void 0);
 		const diagnostics = await lint(project, {
 			componentFolders: config.componentFolders,
+			scan: config.scan,
 			files: isSave ? void 0 : asked?.filter((file) => !outside.includes(file))
 		});
 		const written = isSave ? await writeDocsFrom(project, config) : void 0;

package/dist/index.d.mts

@@ -1,6 +1,8 @@
 import { AstroCheck, Diagnostic as Diagnostic$1 } from "@astrojs/language-server";
 import * as TypeScript from "typescript";
 //#region src/config.d.ts
+declare const SCANS: readonly ["system", "format", "all"];
+type Scan = (typeof SCANS)[number];
 interface Notice {
   code: string;
   message: string;
@@ -47,6 +49,7 @@ interface LintDiagnostic extends Diagnostic {
 }
 export declare function lint(project: Project, options: {
   componentFolders: string[];
+  scan?: Scan;
   files?: string[];
 }): Promise<LintDiagnostic[]>;
 export declare function report(diagnostics: LintDiagnostic[]): string;

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { a as ProjectError, n as report, o as openProject, t as lint } from "./lint-BabXVYQJ.mjs";
-import { n as writeDocs, t as check } from "./check-DxTxqBre.mjs";
+import { n as report, o as ProjectError, s as openProject, t as lint } from "./lint-Bqu-nKvP.mjs";
+import { n as writeDocs, t as check } from "./check-vsAQPYCD.mjs";
 export { ProjectError, check, lint, openProject, report, writeDocs };

package/dist/{lint-BabXVYQJ.mjs → lint-Bqu-nKvP.mjs}

@@ -6,6 +6,12 @@ import { format } from "node:util";
 import { AstroCheck } from "@astrojs/language-server";
 //#region src/config.ts
 const CONFIG_FILE = ".rafters/config.rafters.json";
+const SCANS = [
+	"system",
+	"format",
+	"all"
+];
+const isScan = (value) => SCANS.some((scan) => scan === value);
 function isObject(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -98,7 +104,10 @@ async function readConfig(root) {
 	}
 	if (intent !== void 0 && typeof intent !== "string") errors.push(fieldError("intent", "expected a string", intent));
 	if (veneer !== void 0 && !isObject(veneer)) errors.push(fieldError("veneer", "expected an object", veneer));
-	else if (veneer?.mdxPath !== void 0 && typeof veneer.mdxPath !== "string") errors.push(fieldError("veneer.mdxPath", "expected a string", veneer.mdxPath));
+	else {
+		if (veneer?.mdxPath !== void 0 && typeof veneer.mdxPath !== "string") errors.push(fieldError("veneer.mdxPath", "expected a string", veneer.mdxPath));
+		if (veneer?.scan !== void 0 && !isScan(veneer.scan)) errors.push(fieldError("veneer.scan", `expected one of ${SCANS.join(", ")}`, veneer.scan));
+	}
 	if (errors.length > 0) return {
 		ok: false,
 		errors
@@ -107,6 +116,7 @@ async function readConfig(root) {
 		ok: true,
 		intent: typeof intent === "string" ? intent : null,
 		componentFolders,
+		scan: isObject(veneer) && isScan(veneer.scan) ? veneer.scan : "format",
 		notices
 	};
 }
@@ -669,7 +679,15 @@ function ownPropNames(reader, component, sourceFile) {
 	if (!signature) return [];
 	return propsOfSignature(reader, signature, sourceFile, /* @__PURE__ */ new Map()).props.map(({ name }) => name);
 }
-function intelligenceBlock(reader, sourceFile) {
+const INTELLIGENCE_TAGS = [
+	"cognitive-load",
+	"attention-economics",
+	"trust-building",
+	"accessibility",
+	"semantic-meaning",
+	"usage-patterns"
+];
+function placedBlocks(reader, sourceFile) {
 	const { ts } = reader;
 	const blocks = [];
 	const visit = (node) => {
@@ -684,7 +702,16 @@ function intelligenceBlock(reader, sourceFile) {
 			block,
 			at
 		}];
-	}).sort((a, b) => a.at - b.at)[0]?.block;
+	});
+}
+function intelligenceBlock(reader, sourceFile) {
+	return placedBlocks(reader, sourceFile).sort((a, b) => a.at - b.at)[0]?.block;
+}
+function holdsAllIntelligenceTags(reader, sourceFile) {
+	return placedBlocks(reader, sourceFile).some(({ block }) => {
+		const names = new Set(block.tags?.map((tag) => tag.tagName.text));
+		return INTELLIGENCE_TAGS.every((tag) => names.has(tag));
+	});
 }
 function intelligence(reader, sourceFile) {
 	const { ts } = reader;
@@ -785,6 +812,13 @@ const CLASS_ATTRIBUTES = /* @__PURE__ */ new Set([
 ]);
 const MAX_RESOLVE_STEPS = 8;
 const realPath = (file) => existsSync(file) ? realpathSync(file) : file;
+const isClassesFile = (file) => file.endsWith(".classes.ts");
+function qualifies(reader, sourceFile) {
+	const { fileName } = sourceFile;
+	const stem = fileName.replace(/\.(tsx|astro)$/, "");
+	const { sys } = reader.ts;
+	return stem !== fileName && sys.fileExists(`${stem}.behavior.ts`) && sys.fileExists(`${stem}.classes.ts`) && holdsAllIntelligenceTags(reader, sourceFile);
+}
 function offsetAt(text, line, column) {
 	const breaks = /\r\n|\r|\n/g;
 	let start = 0;
@@ -817,8 +851,8 @@ function elementUsing(ts, node) {
 	const element = tag.parent;
 	return ts.isJsxOpeningLikeElement(element) && element.tagName === tag ? element : void 0;
 }
-function resolveTag({ ts, tc }, { tagName }) {
-	let symbol = tc.getSymbolAtLocation(ts.isPropertyAccessExpression(tagName) ? tagName.name : tagName);
+function resolveSymbol({ ts, tc }, start) {
+	let symbol = start;
 	for (let step = 0; symbol && step < MAX_RESOLVE_STEPS; step += 1) {
 		const declaration = symbol.valueDeclaration;
 		if (symbol.flags & ts.SymbolFlags.Alias) symbol = tc.getAliasedSymbol(symbol);
@@ -826,6 +860,10 @@ function resolveTag({ ts, tc }, { tagName }) {
 		else return symbol;
 	}
 }
+function resolveTag(reader, { tagName }) {
+	const { ts, tc } = reader;
+	return resolveSymbol(reader, tc.getSymbolAtLocation(ts.isPropertyAccessExpression(tagName) ? tagName.name : tagName));
+}
 function deprecatedText({ ts, tc }, element, name) {
 	const parameter = tc.getResolvedSignature(element)?.parameters[0];
 	const tag = (parameter && tc.getTypeOfSymbol(parameter).getProperty(name))?.getJsDocTags(tc).find((found) => found.name === "deprecated");
@@ -842,46 +880,82 @@ function utilityOf(className) {
 	}
 	return className.slice(start);
 }
-function classLiterals(ts, node) {
-	if (ts.isStringLiteralLike(node)) return [node];
-	if (ts.isJsxExpression(node) || ts.isParenthesizedExpression(node)) return node.expression ? classLiterals(ts, node.expression) : [];
-	if (ts.isArrayLiteralExpression(node)) return node.elements.flatMap((element) => classLiterals(ts, element));
-	if (ts.isObjectLiteralExpression(node)) return node.properties.flatMap((property) => ts.isPropertyAssignment(property) && ts.isStringLiteral(property.name) ? [property.name] : []);
-	return [];
+function constInitializer(reader, identifier) {
+	const { ts, tc } = reader;
+	const declaration = resolveSymbol(reader, tc.getSymbolAtLocation(identifier))?.valueDeclaration;
+	return declaration && ts.isVariableDeclaration(declaration) && ts.getCombinedNodeFlags(declaration) & ts.NodeFlags.Const ? declaration.initializer : void 0;
+}
+function constString(reader, identifier) {
+	const initializer = constInitializer(reader, identifier);
+	return initializer && reader.ts.isStringLiteralLike(initializer) ? initializer : void 0;
+}
+function constProperty(reader, { expression, name }) {
+	const { ts } = reader;
+	let object = ts.isIdentifier(expression) ? constInitializer(reader, expression) : void 0;
+	while (object && (ts.isAsExpression(object) || ts.isSatisfiesExpression(object))) object = object.expression;
+	if (!object || !ts.isObjectLiteralExpression(object)) return void 0;
+	for (const property of object.properties) if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.name) && property.name.text === name.text) return ts.isStringLiteralLike(property.initializer) ? property.initializer : void 0;
+}
+function collectClassStrings(reader, sourceFile, isOwnSource, node, found) {
+	const { ts } = reader;
+	if (ts.isStringLiteralLike(node)) found.set(node, node);
+	else if (ts.isIdentifier(node)) {
+		const literal = constString(reader, node);
+		const declaredIn = literal?.getSourceFile();
+		if (!literal || !declaredIn) return;
+		if (declaredIn === sourceFile) found.set(literal, literal);
+		else if (isOwnSource(declaredIn.fileName)) found.set(node, literal);
+	} else {
+		const literal = ts.isPropertyAccessExpression(node) ? constProperty(reader, node) : void 0;
+		const declaredIn = literal?.getSourceFile();
+		if (literal && declaredIn && (declaredIn === sourceFile || isOwnSource(declaredIn.fileName))) {
+			found.set(node, literal);
+			return;
+		}
+		ts.forEachChild(node, (child) => {
+			collectClassStrings(reader, sourceFile, isOwnSource, child, found);
+		});
+	}
 }
-function bracketsInLiteral(reader, file, sourceFile, literal) {
-	return [...literal.getText(sourceFile).slice(1, -1).matchAll(/\S+/g)].flatMap((match) => {
+function bracketsInLiteral(reader, file, sourceFile, at, literal) {
+	return [...literal.getText(literal.getSourceFile()).slice(1, -1).matchAll(/\S+/g)].flatMap((match) => {
 		const [className] = match;
 		if (!utilityOf(className).includes("[")) return [];
-		const position = positionOf(reader, sourceFile, literal.getStart(sourceFile) + 1 + match.index);
+		const inLiteral = at === literal;
+		const position = positionOf(reader, sourceFile, at.getStart(sourceFile) + (inLiteral ? 1 + match.index : 0));
 		if (!position) return [];
 		return [{
 			file,
 			line: position.line,
 			column: position.column,
 			endLine: position.line,
-			endColumn: position.column + className.length,
+			endColumn: position.column + (inLiteral ? className.length : at.getWidth(sourceFile)),
 			severity: "error",
 			code: "rafters(arbitrary-value)",
 			message: `${className} is an arbitrary value`
 		}];
 	});
 }
-function bracketValues(reader, file, sourceFile) {
+function bracketValues(reader, file, sourceFile, isOwnSource) {
 	const { ts } = reader;
-	const found = [];
+	const strings = /* @__PURE__ */ new Map();
+	const everyLiteral = isClassesFile(sourceFile.fileName);
+	if (everyLiteral && !isOwnSource(sourceFile.fileName)) return [];
 	const visit = (node) => {
-		if (ts.isJsxAttribute(node) && node.initializer) {
+		if (everyLiteral) {
+			if (ts.isStringLiteralLike(node)) strings.set(node, node);
+		} else if (ts.isJsxAttribute(node) && node.initializer) {
 			const { name } = node;
 			const attribute = ts.isJsxNamespacedName(name) ? `${name.namespace.text}:${name.name.text}` : name.text;
-			if (CLASS_ATTRIBUTES.has(attribute)) for (const literal of classLiterals(ts, node.initializer)) found.push(...bracketsInLiteral(reader, file, sourceFile, literal));
-		}
+			if (CLASS_ATTRIBUTES.has(attribute)) collectClassStrings(reader, sourceFile, isOwnSource, node.initializer, strings);
+		} else if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "classy") for (const argument of node.arguments) collectClassStrings(reader, sourceFile, isOwnSource, argument, strings);
 		ts.forEachChild(node, visit);
 	};
 	visit(sourceFile);
-	return found;
+	return [...strings].flatMap(([at, literal]) => bracketsInLiteral(reader, file, sourceFile, at, literal));
 }
 const FILL_WORD = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+const FILL_TOKEN = /^bg-fill-[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
 const FILL_ALPHA = /^(100|[1-9]?[0-9])$/;
 const AUTHORED_FILL = "a fill the designer authors, fill=\"bg-fill-<name>\"";
 const isFillStop = (stop) => {
@@ -901,24 +975,24 @@ async function loadSurfaces(root) {
 		return { failure: error instanceof Error ? error.message : String(error) };
 	}
 }
-function fillLiteral(ts, node) {
+function valueLiteral(ts, node) {
 	const { initializer } = node;
 	if (!initializer) return void 0;
 	if (ts.isStringLiteral(initializer)) return initializer;
 	const inner = ts.isJsxExpression(initializer) ? initializer.expression : void 0;
 	return inner && ts.isStringLiteralLike(inner) ? inner : void 0;
 }
-function fillAttributes({ ts }, sourceFile) {
+function valueAttributes({ ts }, sourceFile) {
 	const found = [];
 	const visit = (node) => {
-		if (ts.isJsxAttribute(node) && ts.isIdentifier(node.name) && node.name.text === "fill") found.push(node);
+		if (ts.isJsxAttribute(node) && ts.isIdentifier(node.name) && (node.name.text === "fill" || node.name.text === "surface")) found.push(node);
 		ts.forEachChild(node, visit);
 	};
 	visit(sourceFile);
 	return found;
 }
 async function lint(project, options) {
-	const files = options.files ?? project.checker.getRootFileNames().filter((file) => file.endsWith(".tsx") || file.endsWith(".astro")).map((file) => relativeFile(project.root, file));
+	const files = options.files?.filter((file) => !file.endsWith(".ts") || isClassesFile(file)) ?? project.checker.getRootFileNames().filter((file) => file.endsWith(".tsx") || file.endsWith(".astro") || isClassesFile(file)).map((file) => relativeFile(project.root, file));
 	const perFile = [];
 	for (const file of files) perFile.push([file, await project.diagnostics(file)]);
 	const program = project.program();
@@ -933,6 +1007,17 @@ async function lint(project, options) {
 		const real = realPath(file);
 		return folders.some((folder) => real.startsWith(folder));
 	};
+	const scan = options.scan ?? "format";
+	const projectRoot = realPath(project.root);
+	const isOwnSource = (file) => {
+		const [first, ...rest] = path.relative(projectRoot, realPath(file)).split(path.sep);
+		return first !== ".." && first !== "node_modules" && !rest.includes("node_modules");
+	};
+	const isExempt = (sourceFile) => isUnderFolder(sourceFile.fileName) || qualifies(reader, sourceFile);
+	const isCheckedUse = (declaredIn) => {
+		if (scan === "system") return isUnderFolder(declaredIn.fileName);
+		return isExempt(declaredIn) || scan === "all" && isOwnSource(declaredIn.fileName);
+	};
 	const propsHelp = /* @__PURE__ */ new Map();
 	const reportedUse = (sourceFile, diagnostic) => {
 		const offset = programOffset(reader, sourceFile, diagnostic);
@@ -943,7 +1028,7 @@ async function lint(project, options) {
 		const declaration = component?.valueDeclaration ?? component?.declarations?.[0];
 		if (!element || !component || !declaration) return void 0;
 		const declaredIn = declaration.getSourceFile();
-		if (!isUnderFolder(declaredIn.fileName)) return void 0;
+		if (!isCheckedUse(declaredIn)) return void 0;
 		let help;
 		if (diagnostic.code === "ts(6385)") help = deprecatedText(reader, element, node.getText(sourceFile));
 		else {
@@ -966,15 +1051,44 @@ async function lint(project, options) {
 		if ("failure" in loaded) return `the project's tokens could not be loaded, so no replacement is named: ${loaded.failure}`;
 		return loaded.words.has(value) ? `surface="${value}"` : AUTHORED_FILL;
 	};
-	const retiredFills = async (file, sourceFile) => {
+	const fillFinding = async (value) => {
+		if (value === "" || FILL_TOKEN.test(value)) return void 0;
+		const form = retiredFillForm(value);
+		if (!form) return {
+			code: "rafters(invalid-fill)",
+			message: `fill="${value}" is not exactly one bg-fill-* token`
+		};
+		return {
+			code: "rafters(retired-fill)",
+			message: `fill="${value}" is a retired fill value`,
+			help: await replacement(value, form)
+		};
+	};
+	const surfaceFinding = async (value) => {
+		if (value === "") return void 0;
+		surfaces ??= loadSurfaces(project.root);
+		const loaded = await surfaces;
+		if ("failure" in loaded) return {
+			code: "rafters(unknown-surface)",
+			message: `surface="${value}" could not be checked`,
+			help: `the project's tokens could not be loaded, so no surface is named: ${loaded.failure}`
+		};
+		if (loaded.words.has(value)) return void 0;
+		return {
+			code: "rafters(unknown-surface)",
+			message: `surface="${value}" is not a surface in the project's tokens`
+		};
+	};
+	const badValues = async (file, sourceFile) => {
 		const flagged = [];
-		for (const attribute of fillAttributes(reader, sourceFile)) {
-			const literal = fillLiteral(ts, attribute);
-			const form = literal && retiredFillForm(literal.text);
-			if (!literal || !form) continue;
+		for (const attribute of valueAttributes(reader, sourceFile)) {
+			const literal = valueLiteral(ts, attribute);
+			if (!literal) continue;
 			const component = resolveTag(reader, attribute.parent.parent);
 			const declaration = component?.valueDeclaration ?? component?.declarations?.[0];
-			if (!declaration || !isUnderFolder(declaration.getSourceFile().fileName)) continue;
+			if (!declaration || !isCheckedUse(declaration.getSourceFile())) continue;
+			const finding = await (attribute.name.getText(sourceFile) === "fill" ? fillFinding(literal.text) : surfaceFinding(literal.text));
+			if (!finding) continue;
 			const start = positionOf(reader, sourceFile, attribute.getStart(sourceFile));
 			const end = positionOf(reader, sourceFile, attribute.end);
 			if (!start || !end) continue;
@@ -985,9 +1099,7 @@ async function lint(project, options) {
 				endLine: end.line,
 				endColumn: end.column,
 				severity: "error",
-				code: "rafters(retired-fill)",
-				message: `fill="${literal.text}" is a retired fill value`,
-				help: await replacement(literal.text, form)
+				...finding
 			});
 		}
 		return flagged;
@@ -1001,9 +1113,9 @@ async function lint(project, options) {
 			const reported = reportedUse(sourceFile, diagnostic);
 			if (reported) found.push(reported);
 		}
-		if (!isUnderFolder(absolute)) {
-			found.push(...bracketValues(reader, file, sourceFile));
-			found.push(...await retiredFills(file, sourceFile));
+		if (!isExempt(sourceFile)) {
+			found.push(...bracketValues(reader, file, sourceFile, isOwnSource));
+			found.push(...await badValues(file, sourceFile));
 		}
 	}
 	return found.sort((a, b) => compareCodePoints(a.file, b.file) || a.line - b.line || a.column - b.column);
@@ -1021,4 +1133,4 @@ function report(diagnostics) {
 	return lines.map((line) => `${line}\n`).join("");
 }
 //#endregion
-export { ProjectError as a, resolveComponents as i, report as n, openProject as o, compareCodePoints as r, readConfig as s, lint as t };
+export { resolveComponents as a, readConfig as c, relativeFile as i, report as n, ProjectError as o, compareCodePoints as r, openProject as s, lint as t };

package/dist/worker.mjs

@@ -1,4 +1,4 @@
-import { o as openProject, s as readConfig, t as lint } from "./lint-BabXVYQJ.mjs";
+import { c as readConfig, s as openProject, t as lint } from "./lint-Bqu-nKvP.mjs";
 import path from "node:path";
 import { existsSync } from "node:fs";
 import { promisify } from "node:util";
@@ -30,7 +30,7 @@ process.stdout.write(JSON.stringify(await check(${JSON.stringify(root)}, { save:
 async function serve(root) {
 	const config = await readConfig(root);
 	if (!config.ok) throw new Error(messages(config.errors));
-	const { componentFolders } = config;
+	const { componentFolders, scan } = config;
 	let project = await openProject(root);
 	const unsaved = /* @__PURE__ */ new Map();
 	const outside = /* @__PURE__ */ new Set();
@@ -57,6 +57,7 @@ async function serve(root) {
 		}
 		return lint(project, {
 			componentFolders,
+			scan,
 			files: [file]
 		});
 	};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rafters/veneer",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Docs, rafters check and the composite compile for rafters projects",
   "license": "MIT",
   "repository": {