@mochi-css/tsuki 1.1.0

package/README.md

@@ -0,0 +1,10 @@
+# 🧁 Mochi-CSS/tsuki
+
+This package is part of the [Mochi-CSS project](https://github.com/Niikelion/mochi-css).
+It provides installer for Mochi-CSS that adds it to your project.
+
+You can run it with:
+
+```bash
+npx @mochi-css/tsuki
+```

package/dist/index.js

@@ -0,0 +1,584 @@
+#!/usr/bin/env node
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let commander = require("commander");
+commander = __toESM(commander);
+let __clack_prompts = require("@clack/prompts");
+__clack_prompts = __toESM(__clack_prompts);
+let picocolors = require("picocolors");
+picocolors = __toESM(picocolors);
+let node_readline = require("node:readline");
+node_readline = __toESM(node_readline);
+let node_stream = require("node:stream");
+node_stream = __toESM(node_stream);
+let package_manager_detector = require("package-manager-detector");
+package_manager_detector = __toESM(package_manager_detector);
+let cross_spawn = require("cross-spawn");
+cross_spawn = __toESM(cross_spawn);
+let fs_extra = require("fs-extra");
+fs_extra = __toESM(fs_extra);
+let fs_promises = require("fs/promises");
+fs_promises = __toESM(fs_promises);
+let path = require("path");
+path = __toESM(path);
+let magicast = require("magicast");
+magicast = __toESM(magicast);
+
+//#region src/install.ts
+function onceEvent(emitter, event) {
+	return new Promise((resolve) => {
+		emitter.once(event, (...args) => {
+			resolve(args);
+		});
+	});
+}
+function spawnProcess(command, args, options) {
+	return new Promise((resolve, reject) => {
+		const child = (0, cross_spawn.default)(command, args, options);
+		const onSpawn = () => {
+			child.off("error", onError);
+			resolve(child);
+		};
+		const onError = (err) => {
+			child.off("spawn", onSpawn);
+			reject(err);
+		};
+		child.once("spawn", onSpawn);
+		child.once("error", onError);
+	});
+}
+async function runInstall(title, command, args, packages) {
+	const log = __clack_prompts.taskLog({ title });
+	log.message(`${command} ${args.join(" ")}`);
+	try {
+		const child = await spawnProcess(command, args, { stdio: [
+			"inherit",
+			"pipe",
+			"pipe"
+		] });
+		const merged = new node_stream.PassThrough();
+		let openStreams = 0;
+		for (const stream of [child.stdout, child.stderr]) {
+			if (!stream) continue;
+			openStreams++;
+			stream.pipe(merged, { end: false });
+			stream.on("end", () => {
+				if (--openStreams === 0) merged.end();
+			});
+		}
+		const rl = (0, node_readline.createInterface)({
+			input: merged,
+			crlfDelay: Infinity
+		});
+		const drain = (async () => {
+			for await (const line of rl) log.message(line);
+		})();
+		const [code] = await onceEvent(child, "close");
+		await drain;
+		if (code !== 0) throw new Error(`Failed to install packages: ${packages.join(", ")}`);
+		log.success(`${packages.join(", ")} has been installed installed!`);
+	} catch (err) {
+		log.error(err instanceof Error ? err.message : String(err));
+		throw err;
+	}
+}
+async function installPackages(packages) {
+	if (packages.length === 0) return;
+	const packageManager = await (0, package_manager_detector.detect)({ strategies: [
+		"packageManager-field",
+		"devEngines-field",
+		"lockfile",
+		"install-metadata"
+	] });
+	if (packageManager === null) throw new Error("Could not determine package manager of the project");
+	const agent = packageManager.agent;
+	const devFlag = agent === "deno" ? "--dev" : "-D";
+	const devPackages = packages.filter((pkg) => pkg.dev !== false).map((pkg) => pkg.name);
+	const prodPackages = packages.filter((pkg) => pkg.dev === false).map((pkg) => pkg.name);
+	const packageList = [...devPackages.map((name) => `${name} (dev)`), ...prodPackages.map((name) => name)].join(", ");
+	const confirmed = await __clack_prompts.confirm({ message: `Install the following packages: ${packageList}?` });
+	if (__clack_prompts.isCancel(confirmed) || !confirmed) {
+		__clack_prompts.log.info("Skipping package installation");
+		return;
+	}
+	if (devPackages.length > 0) {
+		const cmd = (0, package_manager_detector.resolveCommand)(agent, "add", [devFlag, ...devPackages]);
+		if (cmd === null) throw new Error("Could not prepare install command");
+		await runInstall(`Installing dev dependencies: ${devPackages.join(", ")}`, cmd.command, cmd.args, devPackages);
+	}
+	if (prodPackages.length > 0) {
+		const cmd = (0, package_manager_detector.resolveCommand)(agent, "add", prodPackages);
+		if (cmd === null) throw new Error("Could not prepare install command");
+		await runInstall(`Installing dependencies: ${prodPackages.join(", ")}`, cmd.command, cmd.args, prodPackages);
+	}
+}
+
+//#endregion
+//#region src/runner.ts
+var ModuleRunner = class {
+	packages = [];
+	modules = [];
+	register(module$1) {
+		this.modules.push(module$1);
+		return this;
+	}
+	async run() {
+		const ctx = {
+			requirePackage: (name, dev = true) => {
+				this.packages.push({
+					name,
+					dev
+				});
+			},
+			requirePackages: (packages) => {
+				for (const pkg of packages) this.packages.push({
+					name: pkg.name,
+					dev: pkg.dev ?? true
+				});
+			}
+		};
+		for (const module$1 of this.modules) await module$1.run(ctx);
+		if (this.packages.length > 0) await installPackages(this.packages);
+	}
+};
+
+//#endregion
+//#region src/modules/ast.ts
+function getPropKeyName(prop) {
+	const key = prop["key"];
+	if (typeof key["name"] === "string") return key["name"];
+	if (typeof key["value"] === "string") return key["value"];
+}
+function optionsToAstProperties(options) {
+	return Object.entries(options).map(([key, value]) => ({
+		type: "ObjectProperty",
+		key: {
+			type: "Identifier",
+			name: key
+		},
+		value: typeof value === "string" ? {
+			type: "StringLiteral",
+			value
+		} : typeof value === "number" ? {
+			type: "NumericLiteral",
+			value
+		} : {
+			type: "BooleanLiteral",
+			value
+		},
+		computed: false,
+		shorthand: false
+	}));
+}
+
+//#endregion
+//#region src/modules/postcss.ts
+const postcssConfigNames = [
+	"postcss.config.mts",
+	"postcss.config.ts",
+	"postcss.config.mjs",
+	"postcss.config.js",
+	"postcss.config.cjs",
+	".postcssrc.mts",
+	".postcssrc.ts",
+	".postcssrc.mjs",
+	".postcssrc.js",
+	".postcssrc.cjs",
+	".postcssrc.json",
+	".postcssrc.yml",
+	".postcssrc.yaml",
+	".postcssrc"
+];
+function findPostcssConfig() {
+	return postcssConfigNames.find((name) => fs_extra.default.existsSync(name));
+}
+function defaultPostcssConfig(pluginOptions = {}) {
+	const entries = Object.entries(pluginOptions);
+	return `export default {\n    plugins: {\n        "@mochi-css/postcss": ${entries.length === 0 ? "{}" : `{\n${entries.map(([k, v]) => `            ${k}: ${JSON.stringify(v)}`).join(",\n")}\n        }`}\n    }\n}\n`;
+}
+async function askForPath() {
+	const defaultConfig = findPostcssConfig() ?? "postcss.config.js";
+	const configPath = await __clack_prompts.text({
+		message: "Path to PostCSS config",
+		placeholder: defaultConfig,
+		defaultValue: defaultConfig
+	});
+	if (__clack_prompts.isCancel(configPath)) return false;
+	return configPath;
+}
+function isProxy(v) {
+	return v !== null && typeof v === "object" && typeof v["$ast"] === "object";
+}
+function isObject(v) {
+	return v !== null && typeof v === "object";
+}
+function addPluginToNamedVar(mod, varName, pluginName, pluginOptions, configPath) {
+	const body = mod.$ast.body;
+	for (const stmt of body) {
+		if (stmt.type !== "VariableDeclaration") continue;
+		for (const decl of stmt.declarations) {
+			if (decl.id.type !== "Identifier" || decl.id.name !== varName) continue;
+			const init = decl.init;
+			if (!init) throw new Error(`Failed to add postcss plugin to ${configPath}`);
+			const pluginsProp = init.properties.find((prop) => getPropKeyName(prop) === "plugins");
+			if (!pluginsProp) throw new Error(`Failed to find plugins object in ${configPath}`);
+			pluginsProp.value.properties.push({
+				type: "ObjectProperty",
+				key: {
+					type: "StringLiteral",
+					value: pluginName
+				},
+				value: {
+					type: "ObjectExpression",
+					properties: optionsToAstProperties(pluginOptions)
+				},
+				computed: false,
+				shorthand: false
+			});
+			return;
+		}
+	}
+	throw new Error(`Failed to add postcss plugin to ${configPath}`);
+}
+async function addPostcssPlugin(configPath, pluginName, pluginOptions = {}) {
+	const mod = (0, magicast.parseModule)(await fs_promises.default.readFile(configPath, "utf-8"));
+	const defaultExport = mod.exports["default"];
+	if (isProxy(defaultExport) && defaultExport.$type === "identifier") {
+		addPluginToNamedVar(mod, defaultExport.$name, pluginName, pluginOptions, configPath);
+		const { code: code$1 } = (0, magicast.generateCode)(mod);
+		await fs_promises.default.writeFile(configPath, code$1);
+		return;
+	}
+	const config = isProxy(defaultExport) && defaultExport.$type === "function-call" ? defaultExport.$args[0] : defaultExport;
+	if (!isProxy(config) || config.$type !== "object" || !isObject(config)) throw new Error(`Failed to add postcss plugin to ${configPath}`);
+	if ("plugins" in config && config["plugins"] !== void 0 && !isObject(config["plugins"])) throw new Error(`Unrecognized plugins config type in ${configPath}`);
+	config["plugins"] ??= {};
+	config["plugins"][pluginName] = pluginOptions;
+	const { code } = (0, magicast.generateCode)(mod);
+	await fs_promises.default.writeFile(configPath, code);
+}
+async function addToConfig(configPath, pluginOptions = {}) {
+	if (!fs_extra.default.existsSync(configPath)) {
+		await fs_extra.default.writeFile("postcss.config.mts", defaultPostcssConfig(pluginOptions));
+		return;
+	}
+	const ext = configPath.split(".").pop();
+	if (ext === "json" || path.default.basename(configPath) === ".postcssrc") {
+		const config = await fs_extra.default.readJson(configPath);
+		if (!isObject(config)) throw new Error("Unrecognized config type in ${configPath}`)");
+		config["plugins"] ??= {};
+		if (!isObject(config["plugins"])) throw new Error("Unrecognized config type in ${configPath}`)");
+		config["plugins"]["@mochi-css/postcss"] = pluginOptions;
+		await fs_extra.default.writeJson(configPath, config, { spaces: 2 });
+		return;
+	}
+	if (ext === "yml" || ext === "yaml") throw new Error("YAML PostCSS config is not supported yet");
+	await addPostcssPlugin(configPath, "@mochi-css/postcss", pluginOptions);
+}
+function createPostcssModule(options = {}) {
+	const pluginOptions = {};
+	if (options.outDir !== void 0) pluginOptions["outDir"] = options.outDir;
+	return {
+		id: "postcss",
+		name: "PostCSS",
+		async run(ctx) {
+			let configPath;
+			if (options.auto) configPath = findPostcssConfig() ?? "postcss.config.mts";
+			else {
+				const usePostcss = await __clack_prompts.confirm({ message: "Do you use PostCSS?" });
+				if (__clack_prompts.isCancel(usePostcss) || !usePostcss) return;
+				const selected = await askForPath();
+				if (selected === false) return;
+				configPath = selected;
+			}
+			await addToConfig(configPath, pluginOptions);
+			__clack_prompts.log.step("Added mochi plugin to the postcss config");
+			ctx.requirePackage("@mochi-css/postcss");
+		}
+	};
+}
+const postcssModule = createPostcssModule();
+
+//#endregion
+//#region src/presets/lib.ts
+const libPreset = {
+	id: "lib",
+	name: "Library",
+	setup(runner) {
+		runner.register(createPostcssModule());
+	}
+};
+
+//#endregion
+//#region src/modules/vite.ts
+const viteConfigNames = [
+	"vite.config.ts",
+	"vite.config.mts",
+	"vite.config.js",
+	"vite.config.mjs"
+];
+function findViteConfig() {
+	return viteConfigNames.find((name) => fs_extra.default.existsSync(name));
+}
+const defaultViteConfig = `import { defineConfig } from "vite"
+import { mochiCss } from "@mochi-css/vite"
+
+export default defineConfig({
+    plugins: [mochiCss()],
+})
+`;
+function getPluginsElements(obj, configPath) {
+	const existing = obj.properties.find((prop) => getPropKeyName(prop) === "plugins");
+	if (existing) {
+		const value = existing["value"];
+		if (value["type"] !== "ArrayExpression") throw new Error(`Unrecognized plugins config type in ${configPath}`);
+		return value["elements"];
+	}
+	const elements = [];
+	obj.properties.push({
+		type: "ObjectProperty",
+		key: {
+			type: "Identifier",
+			name: "plugins"
+		},
+		value: {
+			type: "ArrayExpression",
+			elements
+		},
+		computed: false,
+		shorthand: false
+	});
+	return elements;
+}
+function addPluginCallToObj(obj, configPath) {
+	getPluginsElements(obj, configPath).push({
+		type: "CallExpression",
+		callee: {
+			type: "Identifier",
+			name: "mochiCss"
+		},
+		arguments: []
+	});
+}
+function addToVitePlugins(mod, configPath) {
+	const body = mod.$ast.body;
+	const exportDefault = body.find((s) => s.type === "ExportDefaultDeclaration");
+	if (!exportDefault) throw new Error(`No default export found in ${configPath}`);
+	const decl = exportDefault.declaration;
+	if (decl["type"] === "ObjectExpression") {
+		addPluginCallToObj(decl, configPath);
+		return;
+	}
+	if (decl["type"] === "CallExpression") {
+		const firstArg = decl["arguments"][0];
+		if (firstArg?.["type"] === "ObjectExpression") {
+			addPluginCallToObj(firstArg, configPath);
+			return;
+		}
+	}
+	if (decl["type"] === "Identifier") {
+		const varName = decl["name"];
+		for (const stmt of body) {
+			if (stmt.type !== "VariableDeclaration") continue;
+			for (const d of stmt.declarations) {
+				if (d.id.type !== "Identifier" || d.id.name !== varName) continue;
+				if (d.init?.["type"] !== "ObjectExpression") throw new Error(`Failed to add vite plugin to ${configPath}`);
+				addPluginCallToObj(d.init, configPath);
+				return;
+			}
+		}
+	}
+	throw new Error(`Failed to add vite plugin to ${configPath}`);
+}
+async function addMochiToViteConfig(configPath) {
+	const mod = (0, magicast.parseModule)(await fs_promises.default.readFile(configPath, "utf-8"));
+	mod.imports.$prepend({
+		from: "@mochi-css/vite",
+		imported: "mochiCss",
+		local: "mochiCss"
+	});
+	addToVitePlugins(mod, configPath);
+	const { code } = (0, magicast.generateCode)(mod);
+	await fs_promises.default.writeFile(configPath, code);
+}
+const viteModule = {
+	id: "vite",
+	name: "Vite",
+	async run(ctx) {
+		const existingConfig = findViteConfig();
+		let configPath;
+		if (!existingConfig) {
+			const selected = await __clack_prompts.text({
+				message: "Path to Vite config",
+				placeholder: "vite.config.ts",
+				defaultValue: "vite.config.ts"
+			});
+			if (__clack_prompts.isCancel(selected)) return;
+			configPath = selected;
+		} else configPath = existingConfig;
+		if (!fs_extra.default.existsSync(configPath)) {
+			await fs_promises.default.writeFile(configPath, defaultViteConfig);
+			__clack_prompts.log.step("Created vite config with mochi plugin");
+		} else {
+			await addMochiToViteConfig(configPath);
+			__clack_prompts.log.step("Added mochiCss() to vite config");
+		}
+		ctx.requirePackage("@mochi-css/vite");
+	}
+};
+
+//#endregion
+//#region src/presets/vite.ts
+const vitePreset = {
+	id: "vite",
+	name: "Vite",
+	setup(runner) {
+		runner.register(createPostcssModule({ outDir: ".mochi" }));
+		runner.register(viteModule);
+	}
+};
+
+//#endregion
+//#region src/modules/next.ts
+const nextConfigNames = [
+	"next.config.ts",
+	"next.config.mts",
+	"next.config.js",
+	"next.config.mjs"
+];
+function findNextConfig() {
+	return nextConfigNames.find((name) => fs_extra.default.existsSync(name));
+}
+const defaultNextConfig = `import { withMochi } from "@mochi-css/next"
+
+export default withMochi({})
+`;
+function wrapExportDefault(mod, configPath) {
+	const exportDefault = mod.$ast.body.find((s) => s.type === "ExportDefaultDeclaration");
+	if (!exportDefault) throw new Error(`No default export found in ${configPath}`);
+	exportDefault["declaration"] = {
+		type: "CallExpression",
+		callee: {
+			type: "Identifier",
+			name: "withMochi"
+		},
+		arguments: [exportDefault.declaration]
+	};
+}
+async function addMochiToNextConfig(configPath) {
+	const mod = (0, magicast.parseModule)(await fs_promises.default.readFile(configPath, "utf-8"));
+	mod.imports.$prepend({
+		from: "@mochi-css/next",
+		imported: "withMochi",
+		local: "withMochi"
+	});
+	wrapExportDefault(mod, configPath);
+	const { code } = (0, magicast.generateCode)(mod);
+	await fs_promises.default.writeFile(configPath, code);
+}
+const nextModule = {
+	id: "next",
+	name: "Next.js",
+	async run(ctx) {
+		const existingConfig = findNextConfig();
+		let configPath;
+		if (!existingConfig) {
+			const selected = await __clack_prompts.text({
+				message: "Path to Next.js config",
+				placeholder: "next.config.ts",
+				defaultValue: "next.config.ts"
+			});
+			if (__clack_prompts.isCancel(selected)) return;
+			configPath = selected;
+		} else configPath = existingConfig;
+		if (!fs_extra.default.existsSync(configPath)) {
+			await fs_promises.default.writeFile(configPath, defaultNextConfig);
+			__clack_prompts.log.step("Created next config with mochi");
+		} else {
+			await addMochiToNextConfig(configPath);
+			__clack_prompts.log.step("Added withMochi() to next config");
+		}
+		ctx.requirePackage("@mochi-css/next");
+	}
+};
+
+//#endregion
+//#region src/presets/nextjs.ts
+const nextjsPreset = {
+	id: "nextjs",
+	name: "Next.js",
+	setup(runner) {
+		runner.register(createPostcssModule({
+			outDir: ".mochi",
+			auto: true
+		}));
+		runner.register(nextModule);
+	}
+};
+
+//#endregion
+//#region src/presets/index.ts
+const presets = {
+	lib: libPreset,
+	vite: vitePreset,
+	nextjs: nextjsPreset
+};
+
+//#endregion
+//#region src/index.ts
+commander.program.name("tsuki").description("Add mochi-css to your project").version("1.1.0").addOption(new commander.Option("-p, --preset <preset>", "Preset to use").choices([
+	"vite",
+	"nextjs",
+	"lib"
+])).action(async (options) => {
+	__clack_prompts.intro(picocolors.default.cyan("Installing Mochi-CSS..."));
+	try {
+		const runner = new ModuleRunner();
+		let presetId = options.preset;
+		if (presetId === void 0) {
+			const selected = await __clack_prompts.select({
+				message: "Which framework are you using?",
+				options: Object.values(presets).map((preset$1) => ({
+					value: preset$1.id,
+					label: preset$1.name
+				}))
+			});
+			if (__clack_prompts.isCancel(selected)) {
+				__clack_prompts.outro(picocolors.default.red("Cancelled"));
+				return;
+			}
+			presetId = selected;
+		}
+		const preset = presets[presetId];
+		if (!preset) throw new Error(`Unknown preset: ${presetId}`);
+		preset.setup(runner);
+		await runner.run();
+		__clack_prompts.outro(picocolors.default.green("Done!"));
+	} catch (e) {
+		if (e instanceof Error) __clack_prompts.outro(picocolors.default.red(e.message));
+	}
+});
+commander.program.parse();
+
+//#endregion

package/package.json

@@ -0,0 +1,47 @@
+{
+    "name": "@mochi-css/tsuki",
+    "repository": "git@github.com:Niikelion/mochi-css.git",
+    "version": "1.1.0",
+    "license": "MIT",
+    "bin": "./dist/index.js",
+    "files": [
+        "/dist"
+    ],
+    "scripts": {
+        "build": "tsc --noEmit && tsdown",
+        "test": "vitest",
+        "coverage": "vitest run --coverage",
+        "smoke": "jiti scripts/smoke.ts",
+        "manual": "jiti scripts/manual.ts",
+        "lint": "eslint src",
+        "lint:fix": "eslint src --fix",
+        "format": "prettier --write"
+    },
+    "devDependencies": {
+        "@eslint/js": "^9.18.0",
+        "@gamedev-sensei/ts-config": "^2.1.0",
+        "@types/cross-spawn": "^6.0.6",
+        "@types/fs-extra": "^11.0.4",
+        "@types/node": "^24.8.1",
+        "@vitest/coverage-v8": "^4.0.15",
+        "eslint": "^9.39.2",
+        "eslint-config-prettier": "^10.1.8",
+        "eslint-plugin-prettier": "^5.5.5",
+        "jiti": "^2.6.1",
+        "prettier": "^3.8.1",
+        "tsdown": "^0.15.7",
+        "typescript": "^5.9.3",
+        "typescript-eslint": "^8.21.0",
+        "vite-tsconfig-paths": "^5.1.4",
+        "vitest": "^4.0.15"
+    },
+    "dependencies": {
+        "@clack/prompts": "^1.0.1",
+        "commander": "^13.1.0",
+        "cross-spawn": "^7.0.6",
+        "fs-extra": "^11.3.0",
+        "magicast": "^0.5.1",
+        "package-manager-detector": "^1.6.0",
+        "picocolors": "^1.1.1"
+    }
+}