@menapo/vicss 0.0.0-stage → 1.0.0

package/dist/worker.d.ts

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

package/dist/worker.js

@@ -0,0 +1,113 @@
+import { y as resolveSystem } from "./print-Ds6fkgio.js";
+import { a as toErrorData, b as setParser, o as compile, r as configShape, s as createParseCache } from "./pool-BGXMhLfL.js";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { parentPort } from "node:worker_threads";
+//#region src/vite/worker.ts
+/**
+* A pre-scan worker thread (PLAN D17; see pool.ts). It compiles files the
+* main thread sends, and asks the main thread how each import resolves, so
+* Vite's plugins (aliases, tsconfig paths) decide that in one place. It
+* avoids loading Vite: Rolldown's parser, which Vite re-exports, is all the
+* compiler needs, and Vite takes longer to import than a hundred compiles.
+*/
+const port = parentPort;
+const send = (message) => port.postMessage(message);
+/** Resolutions by importer directory and request, like the main thread's memo. */
+const resolved = /* @__PURE__ */ new Map();
+const waiting = /* @__PURE__ */ new Map();
+let requests = 0;
+const resolve = async (source, importer) => {
+	const key = `${path.dirname(importer)}\0${source}`;
+	let file = resolved.get(key);
+	if (!file) {
+		file = new Promise((done) => {
+			const request = requests++;
+			waiting.set(request, done);
+			send({
+				type: "resolve",
+				request,
+				source,
+				importer
+			});
+		});
+		resolved.set(key, file);
+	}
+	const id = await file;
+	return id ? { id } : null;
+};
+let configure;
+const configured = new Promise((resolve) => configure = resolve);
+const parser = rolldownParser().then((parse) => parse && setParser(parse));
+const context = (async () => {
+	const setup = await configured;
+	await parser;
+	let system;
+	if ("data" in setup.config) system = resolveSystem(setup.config.data);
+	else {
+		const { loadSystem } = await import("./config-loader-pLzP9par.js");
+		system = (await loadSystem(setup.root, setup.config.file, () => {}, void 0, { native: true })).system;
+		if (configShape(system.config) === setup.config.shape) system = {
+			...system,
+			hash: setup.hash
+		};
+	}
+	if (system.hash !== setup.hash) throw new Error("the config resolves to another design system in a worker thread");
+	return {
+		system,
+		importSources: system.config.importSources ?? [],
+		parsed: createParseCache(),
+		sourceMap: setup.sourceMap,
+		root: setup.root,
+		package: setup.package,
+		dev: setup.dev,
+		placeholders: setup.placeholders,
+		frameworks: setup.frameworks
+	};
+})();
+context.then(() => send({ type: "ready" }), (error) => send({
+	type: "unavailable",
+	message: error instanceof Error ? error.message : String(error)
+}));
+port.on("message", (message) => {
+	if (message.type === "setup") {
+		configure(message.setup);
+		return;
+	}
+	if (message.type === "resolved") {
+		waiting.get(message.request)?.(message.file);
+		waiting.delete(message.request);
+		return;
+	}
+	const { job, id, code, script } = message;
+	context.then((ctx) => compile(ctx, id, code, resolve, script)).then((result) => send({
+		type: "done",
+		job,
+		result
+	}), (error) => send({
+		type: "failed",
+		job,
+		error: toErrorData(error)
+	}));
+});
+/**
+* Rolldown's `parseSync`, the function Vite re-exports: from Vite+'s bundled
+* Rolldown, or from the Rolldown that Vite depends on. Undefined when neither
+* is found; the compiler then loads Vite for it.
+*/
+async function rolldownParser() {
+	const loaders = [() => import(
+		/* @vite-ignore */
+		"vite/rolldown/utils"
+), () => {
+		const vite = createRequire(import.meta.resolve("vite"));
+		return import(pathToFileURL(vite.resolve("rolldown/utils")).href);
+	}];
+	for (const load of loaders) try {
+		const utils = await load();
+		if (typeof utils.parseSync === "function") return utils.parseSync;
+	} catch {}
+}
+//#endregion
+export {};

package/package.json

@@ -1,6 +1,69 @@
 {
   "name": "@menapo/vicss",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0",
+  "description": "Typed, design-system-first atomic CSS for Vite: style objects compiled to short hashed class names, recipes with slots and responsive variants, one order-proof stylesheet",
+  "keywords": [
+    "atomic-css",
+    "css",
+    "css-in-js",
+    "design-system",
+    "design-tokens",
+    "eslint-plugin",
+    "oxlint-plugin",
+    "vite",
+    "vite-plugin",
+    "zero-runtime"
+  ],
+  "homepage": "https://github.com/menapo/vite-plugins/blob/main/packages/vicss/README.md",
+  "bugs": {
+    "url": "https://github.com/menapo/vite-plugins/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/menapo/vite-plugins.git",
+    "directory": "packages/vicss"
+  },
+  "bin": {
+    "vicss": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": "./dist/index.js",
+    "./config": "./dist/config.js",
+    "./lint": "./dist/lint.js",
+    "./vite": "./dist/vite.js",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "typescript": "^7.0.2",
+    "vite": "npm:@voidzero-dev/vite-plus-core@1.3.0",
+    "vite-plus": "1.3.0"
+  },
+  "peerDependencies": {
+    "vite": "^8.3.0"
+  },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=22.18.0"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "check": "vp check",
+    "test": "vp test run",
+    "smoke:pack": "node scripts/smoke-pack.ts"
+  }
 }