onsystem 0.0.1 → 0.5.0

package/dist/eslint-worker.d.ts

@@ -0,0 +1,36 @@
+import { a as DesignSystemModel, x as ResolvedConfig } from "./types-DJtccu3A.js";
+import { MessagePort } from "node:worker_threads";
+//#region src/eslint/worker.d.ts
+export interface LoadRequest {
+  /** ESLint's working directory: where `check` would run from. */
+  cwd: string;
+  /** The file being linted, absolute. */
+  file: string;
+  /** `settings.onsystem` in the ESLint config: `--root` and `--config`, relative to `cwd`. */
+  root?: string | undefined;
+  config?: string | undefined;
+  /** The version of each design system the plugin already holds, by project root. */
+  known: Record<string, string>;
+}
+export type LoadResponse = {
+  /** Why the file is not checked, as `check .` would leave it out. */
+  skip: string;
+} | {
+  root: string;
+  version: string;
+  /** Left out when the plugin already holds this version. */
+  data?: {
+    config: ResolvedConfig;
+    model: DesignSystemModel;
+  };
+} | {
+  error: string;
+};
+export interface Call {
+  request: LoadRequest;
+  /** Set to 1, and notified, once the response is on `port`. */
+  signal: Int32Array;
+  port: MessagePort;
+}
+export declare function load(request: LoadRequest): Promise<LoadResponse>;
+//#endregion

package/dist/eslint-worker.js

@@ -0,0 +1,88 @@
+import { B as DEFAULT_TEST_FOLDERS, i as componentFiles, it as relativePath, r as buildModel, rt as matchesGlob, z as DEFAULT_TEST_EXCLUDE } from "./design-system-CnEv5sIL.js";
+import { r as loadTarget } from "./workspace-DzWQ4L8R.js";
+import fs from "node:fs";
+import path from "node:path";
+import { parentPort } from "node:worker_threads";
+//#region src/eslint/worker.ts
+/**
+* The ESLint plugin's loader, in a worker thread. ESLint rules run synchronously, and finding a
+* project's design system does not (config files written in code, globs, the extraction
+* cache), so the plugin asks this worker and waits for the answer (see `bridge.ts`).
+*/
+/** How long a loaded design system is trusted before its files are looked at again. */
+const FRESH_MS = 2e3;
+const targets = /* @__PURE__ */ new Map();
+/** The default test and story patterns: the recommended config ignores those files itself. */
+const TEST_PATTERNS = /* @__PURE__ */ new Set([DEFAULT_TEST_EXCLUDE, DEFAULT_TEST_FOLDERS]);
+const projects = /* @__PURE__ */ new Map();
+function realPath(file) {
+	try {
+		return fs.realpathSync.native(file);
+	} catch {
+		return file;
+	}
+}
+async function targetFor({ cwd, root, config }) {
+	const key = JSON.stringify([
+		cwd,
+		root,
+		config
+	]);
+	const cached = targets.get(key);
+	if (cached && Date.now() - cached.at < FRESH_MS) return cached.target;
+	const target = loadTarget({
+		cwd,
+		root: root === void 0 ? void 0 : path.resolve(cwd, root),
+		config: config === void 0 ? void 0 : path.resolve(cwd, config)
+	});
+	targets.set(key, {
+		at: Date.now(),
+		target
+	});
+	return target;
+}
+async function load(request) {
+	const target = await targetFor(request);
+	const config = target.workspace ? (await target.workspace.projectFor(request.file)).config : target.config;
+	let project = projects.get(config.root);
+	if (!project || Date.now() - project.at >= FRESH_MS) {
+		const { model, key } = await buildModel(config, { cache: true });
+		const own = new Set((await componentFiles(config)).map(realPath));
+		project = {
+			at: Date.now(),
+			version: key ?? String(Date.now()),
+			config,
+			model,
+			own
+		};
+		projects.set(config.root, project);
+	}
+	const relative = relativePath(config.root, request.file);
+	const excluded = config.exclude.find((pattern) => !TEST_PATTERNS.has(pattern) && matchesGlob(relative, pattern));
+	if (excluded) return { skip: `excluded by "${excluded}"` };
+	if (!config.includeDesignSystem && project.own.has(realPath(request.file))) return { skip: "one of the design system’s own component files" };
+	const { version } = project;
+	return {
+		root: config.root,
+		version,
+		...request.known[config.root] === version ? {} : { data: {
+			config: project.config,
+			model: project.model
+		} }
+	};
+}
+parentPort?.on("message", ({ request, signal, port }) => {
+	const reply = (response) => {
+		port.postMessage(response);
+		Atomics.store(signal, 0, 1);
+		Atomics.notify(signal, 0);
+	};
+	load({
+		...request,
+		file: path.resolve(request.cwd, request.file)
+	}).then(reply, (error) => {
+		reply({ error: error.message });
+	});
+});
+//#endregion
+export { load };

package/dist/eslint.d.ts

@@ -0,0 +1,23 @@
+import { Linter, Rule } from "eslint";
+//#region src/eslint/index.d.ts
+/** `settings.onsystem`: where the project and its config are, when finding them from ESLint's cwd is not right. */
+export interface Settings {
+  /** The project root, relative to ESLint's working directory (`check --root`). */
+  root?: string;
+  /** The config file, relative to ESLint's working directory (`check --config`). */
+  config?: string;
+}
+declare const plugin: {
+  meta: {
+    name: string;
+    version: string;
+  };
+  rules: {
+    [k: string]: Rule.RuleModule;
+  };
+  configs: {
+    recommended: Linter.Config;
+  };
+};
+//#endregion
+export { plugin as default };

package/dist/eslint.js

@@ -0,0 +1,172 @@
+import { B as DEFAULT_TEST_FOLDERS, R as DEFAULT_SEVERITY, T as RULES, _ as VERSION, g as NAME, it as relativePath, t as DesignSystem, z as DEFAULT_TEST_EXCLUDE } from "./design-system-CnEv5sIL.js";
+import path from "node:path";
+import { MessageChannel, Worker, receiveMessageOnPort } from "node:worker_threads";
+//#region src/eslint/bridge.ts
+/**
+* Calls the loader worker (`worker.ts`) synchronously: posts the request, blocks on a shared
+* flag until the worker has answered, and takes the answer off the port. The worker is
+* started on first use and does not keep ESLint's process alive.
+*/
+/** Long enough for a cold extraction of a large design system. */
+const TIMEOUT_MS = 12e4;
+let worker;
+function start() {
+	if (worker) return worker;
+	worker = new Worker(new URL("./eslint-worker.js", import.meta.url));
+	worker.unref();
+	worker.on("error", () => {
+		worker = void 0;
+	});
+	worker.on("exit", () => {
+		worker = void 0;
+	});
+	return worker;
+}
+function loadSync(request) {
+	const { port1, port2 } = new MessageChannel();
+	const signal = new Int32Array(new SharedArrayBuffer(4));
+	try {
+		const call = {
+			request,
+			signal,
+			port: port2
+		};
+		start().postMessage(call, [port2]);
+		if (Atomics.wait(signal, 0, 0, TIMEOUT_MS) === "timed-out") return { error: `the design system did not load within ${TIMEOUT_MS / 1e3} seconds` };
+		const message = receiveMessageOnPort(port1);
+		return message ? message.message : { error: "the loader sent no answer" };
+	} finally {
+		port1.close();
+	}
+}
+//#endregion
+//#region src/eslint/index.ts
+/**
+* onsystem's rules as an ESLint plugin (ESLint 9 and 10, flat config):
+*
+*   import onsystem from 'onsystem/eslint';
+*   export default [...yourConfig, onsystem.configs.recommended];
+*
+* Each file is checked as `onsystem check` checks it, against the design system of its project
+* (the nearest folder with a config, a components.json or a package.json, found from ESLint's
+* working directory), with the project's config: its `rules` and `overrides` turn rules off
+* per file, `// onsystem-disable-*` comments suppress findings, and the files `check .` leaves
+* out (the config's `exclude`, the design system's own components) are not checked. ESLint's
+* config sets each rule's severity.
+*/
+const RULES_PAGE = "https://onsystem.vercel.app/rules";
+/** Design systems by project root, at the version the loader last reported. */
+const designSystems = /* @__PURE__ */ new Map();
+/**
+* One check per file per lint pass, shared by every rule of the pass: they see the same
+* SourceCode, and a new pass (another run, a fix pass, an editor's next keystroke) gets a new
+* one, so the design system's freshness is asked about again. `reported` says that a file that
+* could not be checked has been said so in this pass.
+*/
+const passes = /* @__PURE__ */ new WeakMap();
+function passFor(context, file, settings) {
+	const { sourceCode } = context;
+	let pass = passes.get(sourceCode);
+	if (!pass) {
+		pass = {
+			outcome: run(context.cwd, file, sourceCode.text, settings),
+			reported: false
+		};
+		passes.set(sourceCode, pass);
+	}
+	return pass;
+}
+function run(cwd, file, text, settings) {
+	const response = loadSync({
+		cwd,
+		file,
+		known: Object.fromEntries([...designSystems].map(([root, { version }]) => [root, version])),
+		root: settings.root,
+		config: settings.config
+	});
+	if ("error" in response) return { error: response.error };
+	if ("skip" in response) return { skipped: true };
+	let entry = designSystems.get(response.root);
+	if (response.data) {
+		const { model, config } = response.data;
+		entry = {
+			version: response.version,
+			ds: new DesignSystem(model, config)
+		};
+		designSystems.set(response.root, entry);
+	}
+	if (!entry) return { error: `no design system loaded for ${response.root}` };
+	const result = entry.ds.check(text, relativePath(entry.ds.root, file));
+	return result.skipped ? { skipped: true } : { result };
+}
+function createRule(id, description) {
+	return {
+		meta: {
+			type: "problem",
+			docs: {
+				description,
+				url: `${RULES_PAGE}#${id}`
+			},
+			fixable: "code",
+			schema: []
+		},
+		create(context) {
+			const file = path.resolve(context.cwd, context.filename);
+			const settings = context.settings.onsystem ?? {};
+			return { "Program:exit"(node) {
+				const pass = passFor(context, file, settings);
+				const { outcome } = pass;
+				if ("skipped" in outcome) return;
+				if ("error" in outcome) {
+					if (pass.reported) return;
+					pass.reported = true;
+					context.report({
+						node,
+						message: `onsystem could not check this file: ${outcome.error}`
+					});
+					return;
+				}
+				for (const d of outcome.result.diagnostics) {
+					if (d.ruleId !== id) continue;
+					const edits = d.fix;
+					context.report({
+						loc: {
+							start: {
+								line: d.line,
+								column: d.column - 1
+							},
+							end: {
+								line: d.endLine,
+								column: d.endColumn - 1
+							}
+						},
+						message: d.message,
+						...edits?.length ? { fix: (fixer) => edits.map((e) => fixer.replaceTextRange(e.range, e.text)) } : {}
+					});
+				}
+			} };
+		}
+	};
+}
+const rules = Object.fromEntries(RULES.map((rule) => [rule.id, createRule(rule.id, rule.description)]));
+const plugin = {
+	meta: {
+		name: NAME,
+		version: VERSION
+	},
+	rules,
+	configs: {}
+};
+/**
+* Every rule at its default severity, for `.tsx` and `.jsx` files other than tests and stories,
+* which `check` also leaves out unless asked (`--include-tests`).
+*/
+plugin.configs.recommended = {
+	name: "onsystem/recommended",
+	files: ["**/*.{tsx,jsx}"],
+	ignores: [DEFAULT_TEST_EXCLUDE, DEFAULT_TEST_FOLDERS],
+	plugins: { onsystem: plugin },
+	rules: Object.fromEntries(RULES.map((rule) => [`onsystem/${rule.id}`, DEFAULT_SEVERITY[rule.id]]))
+};
+//#endregion
+export { plugin as default };