@rafters/veneer 0.0.0-stage → 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Sean Silvius
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/bin.d.mts

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

package/dist/bin.mjs

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { t as check } from "./check-DxTxqBre.mjs";
+//#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 {
+		for (const { message } of result.errors) process.stderr.write(`${message}\n`);
+		process.exitCode = 1;
+	}
+}
+//#endregion
+export {};

package/dist/check-DxTxqBre.mjs

@@ -0,0 +1,156 @@
+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 path from "node:path";
+import { mkdir, rename, rm, writeFile } from "node:fs/promises";
+import { lstatSync } from "node:fs";
+//#region src/docs.ts
+function propLine(prop) {
+	return {
+		name: prop.name,
+		type: prop.type,
+		optional: prop.optional,
+		...prop.default !== void 0 && { default: prop.default },
+		...prop.values !== void 0 && { values: prop.values },
+		...prop.doc !== void 0 && { doc: prop.doc },
+		file: prop.file,
+		line: prop.line,
+		column: prop.column
+	};
+}
+function componentLine(component) {
+	return {
+		kind: "component",
+		name: component.name,
+		file: component.file,
+		resolved: component.resolved,
+		...component.reason !== void 0 && { reason: component.reason },
+		...component.description !== void 0 && { description: component.description },
+		tags: component.tags,
+		props: component.props.map(propLine),
+		inherited: component.inherited,
+		inheritedDefaults: component.inheritedDefaults
+	};
+}
+function docsText(intent, components) {
+	return [{
+		kind: "project",
+		intent
+	}, ...components.map(componentLine)].map((line) => `${JSON.stringify(line)}\n`).join("");
+}
+async function writeWhole(docsPath, text) {
+	const temporary = `${docsPath}.tmp`;
+	await mkdir(path.dirname(docsPath), { recursive: true });
+	try {
+		await rm(temporary, { force: true });
+		await writeFile(temporary, text, { flag: "wx" });
+		await rename(temporary, docsPath);
+	} catch (error) {
+		await rm(temporary, { force: true });
+		throw error;
+	}
+}
+async function openOrError(root, unsaved) {
+	try {
+		return await openProject(root, { unsaved });
+	} catch (error) {
+		if (error instanceof ProjectError && error.code === "tsconfig-missing") return {
+			code: error.code,
+			message: error.message
+		};
+		throw error;
+	}
+}
+function outputSymlinkError(root) {
+	const symlink = [".rafters", ".rafters/veneer"].find((folder) => lstatSync(path.join(root, folder), { throwIfNoEntry: false })?.isSymbolicLink());
+	if (!symlink) return void 0;
+	return {
+		code: "output-symlink",
+		message: `${symlink} is a symbolic link; veneer writes only inside the project`
+	};
+}
+function sortedNotices(notices) {
+	return notices.toSorted((a, b) => compareCodePoints(a.code, b.code) || compareCodePoints(a.message, b.message));
+}
+async function writeDocsFrom(project, config) {
+	const { components, notices } = await resolveComponents(project, config.componentFolders);
+	const docsPath = path.join(project.root, ".rafters/veneer/docs.jsonl");
+	await writeWhole(docsPath, docsText(config.intent, components));
+	return {
+		docsPath,
+		notices: sortedNotices([...config.notices, ...notices])
+	};
+}
+async function writeDocs(projectRoot) {
+	const root = path.resolve(projectRoot);
+	const config = await readConfig(root);
+	if (!config.ok) return {
+		ok: false,
+		errors: config.errors
+	};
+	const symlink = outputSymlinkError(root);
+	if (symlink) return {
+		ok: false,
+		errors: [symlink]
+	};
+	const project = await openOrError(root);
+	if ("code" in project) return {
+		ok: false,
+		errors: [project]
+	};
+	try {
+		return {
+			ok: true,
+			...await writeDocsFrom(project, config)
+		};
+	} finally {
+		project.close();
+	}
+}
+//#endregion
+//#region src/check.ts
+function outsideProgram(file) {
+	return {
+		code: "outside-program",
+		message: `${file} is not in the tsconfig's files, so it was not checked`
+	};
+}
+async function check(projectRoot, options = {}) {
+	const root = path.resolve(projectRoot);
+	const config = await readConfig(root);
+	if (!config.ok) return {
+		ok: false,
+		errors: config.errors
+	};
+	const unsaved = options.unsaved ?? {};
+	const unsavedFiles = Object.keys(unsaved);
+	const isSave = options.save === true && unsavedFiles.length === 0;
+	const symlink = isSave ? outputSymlinkError(root) : void 0;
+	if (symlink) return {
+		ok: false,
+		errors: [symlink]
+	};
+	const project = await openOrError(root, unsaved);
+	if ("code" in project) return {
+		ok: false,
+		errors: [project]
+	};
+	try {
+		const roots = project.checker.getRootFileNames();
+		const outside = unsavedFiles.filter((file) => !roots.includes(path.join(root, file)));
+		const asked = options.paths ?? (unsavedFiles.length > 0 ? unsavedFiles : void 0);
+		const diagnostics = await lint(project, {
+			componentFolders: config.componentFolders,
+			files: isSave ? void 0 : asked?.filter((file) => !outside.includes(file))
+		});
+		const written = isSave ? await writeDocsFrom(project, config) : void 0;
+		return {
+			ok: true,
+			diagnostics,
+			report: report(diagnostics),
+			...written ?? { notices: sortedNotices([...config.notices, ...outside.map(outsideProgram)]) }
+		};
+	} finally {
+		project.close();
+	}
+}
+//#endregion
+export { writeDocs as n, check as t };

package/dist/index.d.mts

@@ -0,0 +1,82 @@
+import { AstroCheck, Diagnostic as Diagnostic$1 } from "@astrojs/language-server";
+import * as TypeScript from "typescript";
+//#region src/config.d.ts
+interface Notice {
+  code: string;
+  message: string;
+}
+interface VeneerError {
+  code: string;
+  message: string;
+  field?: string;
+  value?: unknown;
+}
+//#endregion
+//#region src/read.d.ts
+export declare class ProjectError extends Error {
+  readonly code: "already-open" | "tsconfig-missing" | "bad-path" | "not-root-file" | "closed";
+  constructor(code: ProjectError["code"], message: string);
+}
+interface Diagnostic {
+  file: string;
+  line: number;
+  column: number;
+  endLine: number;
+  endColumn: number;
+  severity: "error" | "warning" | "info" | "hint";
+  code: string;
+  message: Diagnostic$1["message"];
+}
+interface Project {
+  readonly ts: typeof TypeScript;
+  readonly checker: AstroCheck["linter"];
+  readonly root: string;
+  program(): TypeScript.Program;
+  diagnostics(file: string): Promise<Diagnostic[]>;
+  setUnsaved(file: string, text: string): void;
+  clearUnsaved(file: string): void;
+  close(): void;
+}
+export declare function openProject(projectRoot: string, options?: {
+  unsaved?: Record<string, string>;
+}): Promise<Project>;
+//#endregion
+//#region src/lint.d.ts
+interface LintDiagnostic extends Diagnostic {
+  help?: string;
+}
+export declare function lint(project: Project, options: {
+  componentFolders: string[];
+  files?: string[];
+}): Promise<LintDiagnostic[]>;
+export declare function report(diagnostics: LintDiagnostic[]): string;
+//#endregion
+//#region src/check.d.ts
+type CheckResult = {
+  ok: true;
+  diagnostics: LintDiagnostic[];
+  report: string;
+  notices: Notice[];
+  docsPath?: string;
+} | {
+  ok: false;
+  errors: VeneerError[];
+};
+export declare function check(projectRoot: string, options?: {
+  save?: boolean;
+  paths?: string[];
+  unsaved?: Record<string, string>;
+}): Promise<CheckResult>;
+//#endregion
+//#region src/docs.d.ts
+type DocsResult = {
+  ok: true;
+  docsPath: string;
+  notices: Notice[];
+} | {
+  ok: false;
+  errors: VeneerError[];
+};
+export declare function writeDocs(projectRoot: string): Promise<DocsResult>;
+//#endregion
+export type { CheckResult, Diagnostic, DocsResult, LintDiagnostic, Notice, Project, VeneerError };

package/dist/index.mjs

@@ -0,0 +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";
+export { ProjectError, check, lint, openProject, report, writeDocs };