@gustcss/postcss 0.5.2 → 0.5.4

package/dist/index.cjs

@@ -0,0 +1,193 @@
+//#region \0rolldown/runtime.js
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+//#endregion
+//#region ../shared/runner.js
+var require_runner = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* gustcss shared runner — helpers for the @gustcss/postcss and @gustcss/vite
+	* plugins.
+	*
+	* These functions centralize the four pieces of logic that the two plugins
+	* previously duplicated:
+	*   - binary discovery (resolveBinary)
+	*   - config-file detection (resolveConfig)
+	*   - temporary config-file lifecycle (withTempConfig)
+	*   - CLI argument assembly (buildArgs)
+	*
+	* They are pure (no module-level state) and accept `fs` via dependency
+	* injection so callers and tests can substitute it. The implementation uses
+	* only Node's built-in `path`, `fs`, and `crypto` — no third-party dependencies.
+	*
+	* This module is NOT a public API. It is inlined into each plugin's `dist`
+	* bundle at build time (rolldown) and is never published as a standalone
+	* source file. The `npm/shared/` directory deliberately has no own
+	* package.json with a public name, only a private one for running tests.
+	*
+	* @security Paths (cwd, config, output) are trusted: they originate from the
+	* developer's build configuration. These helpers are for build-time use only.
+	*/
+	const path = require("path");
+	const crypto = require("crypto");
+	const DEFAULT_CONFIG_NAMES = ["gustcss.config.json", "gustcss.config.js"];
+	/**
+	* Locate the gustcss CLI binary, trying three paths in order:
+	*   1. <cwd>/node_modules/.bin/gustcss   (normal local install)
+	*   2. <cwd>/../../bin/gustcss           (sample projects in this repo)
+	*   3. 'gustcss'                         (global install — always accepted)
+	*
+	* @param {{ cwd: string, fs?: { existsSync: Function } }} options
+	* @returns {string} the resolved binary path or the bare 'gustcss' sentinel
+	*/
+	function resolveBinary({ cwd, fs = require("fs") }) {
+		const candidates = [path.join(cwd, "node_modules", ".bin", "gustcss"), path.join(cwd, "..", "..", "bin", "gustcss")];
+		for (const candidate of candidates) if (fs.existsSync(candidate)) return candidate;
+		return "gustcss";
+	}
+	/**
+	* Determine which config file the CLI should use.
+	*   - If an explicit configPath is given, it is returned as-is (no fs access).
+	*   - Otherwise auto-detect gustcss.config.json, then gustcss.config.js, in cwd.
+	*   - Returns null when nothing is found (caller falls back to a temp config).
+	*
+	* @param {{ cwd: string, configPath?: string, fs?: { existsSync: Function } }} options
+	* @returns {string|null}
+	*/
+	function resolveConfig({ cwd, configPath, fs = require("fs") }) {
+		if (configPath) return configPath;
+		for (const name of DEFAULT_CONFIG_NAMES) {
+			const fullPath = path.join(cwd, name);
+			if (fs.existsSync(fullPath)) return fullPath;
+		}
+		return null;
+	}
+	/**
+	* Write a temporary config file ({ content }) at <cwd>/<prefix>.<random8hex>.tmp.json,
+	* invoke `fn` with the temp file path, and always clean the file up afterwards.
+	*
+	* The file is created with the 'wx' flag (O_EXCL equivalent): if a file with
+	* the same name already exists the write fails, preventing symlink-redirection
+	* attacks and parallel-run collisions. Because the name contains 8 random bytes
+	* the probability of a collision is negligible.
+	*
+	* @param {{ cwd: string, content: any, prefix: string, fs?: { writeFileSync: Function, existsSync: Function, unlinkSync: Function } }} options
+	* @param {(tempConfigPath: string) => any} fn
+	* @returns {any} whatever `fn` returns
+	*/
+	function withTempConfig({ cwd, content, prefix, fs = require("fs") }, fn) {
+		const tmpName = `${prefix}.${crypto.randomBytes(8).toString("hex")}.tmp.json`;
+		const tempConfigPath = path.join(cwd, tmpName);
+		fs.writeFileSync(tempConfigPath, JSON.stringify({ content }), { flag: "wx" });
+		try {
+			return fn(tempConfigPath);
+		} finally {
+			if (fs.existsSync(tempConfigPath)) fs.unlinkSync(tempConfigPath);
+		}
+	}
+	/**
+	* Assemble the CLI argument array.
+	*
+	* @param {object} options
+	* @param {'stdout'|'output'} options.mode  'stdout' emits to stdout (postcss);
+	*                                           'output' writes to a file (-o, vite).
+	* @param {string} [options.output]         output path (required for 'output' mode)
+	* @param {boolean} [options.cssLayers]     append --css-layers when truthy
+	* @param {boolean} [options.watch]         append --watch when truthy
+	* @param {string|null} [options.configPath] append --config <path> when present
+	* @returns {string[]}
+	*/
+	function buildArgs({ mode, output, cssLayers, configPath, watch }) {
+		const args = ["build"];
+		if (watch) args.push("--watch");
+		if (mode === "stdout") args.push("--stdout");
+		else args.push("-o", output);
+		if (cssLayers) args.push("--css-layers");
+		if (configPath) args.push("--config", configPath);
+		return args;
+	}
+	module.exports = {
+		resolveBinary,
+		resolveConfig,
+		withTempConfig,
+		buildArgs
+	};
+}));
+//#endregion
+//#region src/index.js
+const childProcess = require("child_process");
+const runner = require_runner();
+/**
+* @gustcss/postcss - PostCSS plugin for CSS Utility Generator
+*
+* Usage in postcss.config.js:
+*   module.exports = {
+*     plugins: [
+*       require('@gustcss/postcss')({
+*         content: ['./src/**\/*.{js,ts,jsx,tsx}'],
+*       }),
+*     ],
+*   }
+*
+* In your CSS file:
+*   @gustcss;
+*
+* @security Configuration paths (content, config) are trusted as they are
+* provided by the developer in their build configuration. This plugin is
+* designed for build-time use only and should not process untrusted input.
+*/
+const plugin = (opts = {}) => {
+	const content = opts.content || ["./src/**/*.{js,ts,jsx,tsx}"];
+	const configPath = opts.config;
+	const outputToCssLayers = opts.outputToCssLayers;
+	return {
+		postcssPlugin: "gustcss",
+		Once(root, { result }) {
+			let directiveAtRule = null;
+			root.walkAtRules("gustcss", (atRule) => {
+				if (directiveAtRule === null) directiveAtRule = atRule;
+				else atRule.remove();
+			});
+			if (directiveAtRule === null) return;
+			const cwd = process.cwd();
+			const binaryPath = runner.resolveBinary({ cwd });
+			const resolvedConfigPath = runner.resolveConfig({
+				cwd,
+				configPath
+			});
+			const fromFile = root.source?.input?.file ?? result.opts?.from;
+			const run = (cfgPath) => {
+				const args = runner.buildArgs({
+					mode: "stdout",
+					cssLayers: outputToCssLayers,
+					configPath: cfgPath
+				});
+				try {
+					const spawnResult = childProcess.spawnSync(binaryPath, args, {
+						cwd,
+						encoding: "utf-8",
+						stdio: [
+							"pipe",
+							"pipe",
+							"pipe"
+						]
+					});
+					if (spawnResult.status !== 0) throw new Error(`gustcss build failed: ${spawnResult.stderr}`);
+					if (spawnResult.stderr) process.stderr.write(spawnResult.stderr);
+					const parsed = require("postcss").parse(spawnResult.stdout, { from: fromFile });
+					if (directiveAtRule) directiveAtRule.replaceWith(parsed);
+					else root.append(parsed);
+				} catch (error) {
+					throw new Error(`gustcss build failed: ${error.message}`);
+				}
+			};
+			if (resolvedConfigPath) run(resolvedConfigPath);
+			else runner.withTempConfig({
+				cwd,
+				content,
+				prefix: ".gustcss.postcss"
+			}, (tempConfigPath) => run(tempConfigPath));
+		}
+	};
+};
+module.exports = plugin;
+module.exports.postcss = true;
+//#endregion

package/package.json

@@ -1,21 +1,40 @@
 {
   "name": "@gustcss/postcss",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "PostCSS plugin for GustCSS",
-  "main": "index.js",
+  "main": "dist/index.cjs",
   "type": "commonjs",
   "files": [
-    "index.js"
+    "dist/index.cjs",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "postcss",
+    "postcss-plugin",
+    "gustcss",
+    "gust",
+    "css",
+    "utility"
   ],
-  "keywords": ["postcss", "postcss-plugin", "gustcss", "gust", "css", "utility"],
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "gustcss": "^0.5.2"
+    "gustcss": "^0.5.4"
   },
   "peerDependencies": {
     "postcss": "^8.0.0"
   },
+  "devDependencies": {
+    "postcss": "^8.5.15",
+    "rolldown": "^1.1.0",
+    "vitest": "^4.1.8"
+  },
+  "scripts": {
+    "build": "node build.mjs",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run"
+  },
   "license": "MIT"
 }

package/index.js

@@ -1,136 +0,0 @@
-const { spawnSync } = require('child_process')
-const path = require('path')
-const fs = require('fs')
-
-/**
- * @gustcss/postcss - PostCSS plugin for CSS Utility Generator
- *
- * Usage in postcss.config.js:
- *   module.exports = {
- *     plugins: [
- *       require('@gustcss/postcss')({
- *         content: ['./src/**\/*.{js,ts,jsx,tsx}'],
- *       }),
- *     ],
- *   }
- *
- * In your CSS file:
- *   @gustcss;
- *
- * @security Configuration paths (content, config) are trusted as they are
- * provided by the developer in their build configuration. This plugin is
- * designed for build-time use only and should not process untrusted input.
- */
-module.exports = (opts = {}) => {
-  const content = opts.content || ['./src/**/*.{js,ts,jsx,tsx}']
-  const configPath = opts.config
-  const outputToCssLayers = opts.outputToCssLayers
-
-  return {
-    postcssPlugin: 'gustcss',
-    Once(root, { result }) {
-      let hasDirective = false
-      root.walkAtRules('gustcss', (atRule) => {
-        hasDirective = true
-        atRule.remove()
-      })
-
-      if (!hasDirective) {
-        return
-      }
-
-      // Find the CLI binary
-      const cwd = process.cwd()
-      const possiblePaths = [
-        path.join(cwd, 'node_modules', '.bin', 'gustcss'),
-        path.join(cwd, '..', '..', 'bin', 'gustcss'), // For sample projects
-        'gustcss', // Global installation
-      ]
-
-      let binaryPath = null
-      for (const p of possiblePaths) {
-        if (p === 'gustcss' || fs.existsSync(p)) {
-          binaryPath = p
-          break
-        }
-      }
-
-      if (!binaryPath) {
-        throw new Error('gustcss binary not found')
-      }
-
-      // Build CLI arguments
-      const args = ['build', '--stdout']
-
-      // Add --css-layers flag if enabled
-      if (outputToCssLayers) {
-        args.push('--css-layers')
-      }
-
-      // Determine config file path
-      let resolvedConfigPath = configPath
-      if (!resolvedConfigPath) {
-        // Auto-detect config file in current directory
-        const defaultConfigPaths = [
-          'gustcss.config.json',
-          'gustcss.config.js',
-        ]
-        for (const configName of defaultConfigPaths) {
-          const fullPath = path.join(cwd, configName)
-          if (fs.existsSync(fullPath)) {
-            resolvedConfigPath = fullPath
-            break
-          }
-        }
-      }
-
-      let tempConfigPath = null
-
-      if (resolvedConfigPath) {
-        // Use existing config file
-        args.push('--config', resolvedConfigPath)
-      } else {
-        // Create temporary config file to avoid glob pattern issues with CLI
-        tempConfigPath = path.join(cwd, '.gustcss.postcss.tmp.json')
-        const tempConfig = { content }
-        fs.writeFileSync(tempConfigPath, JSON.stringify(tempConfig))
-        args.push('--config', tempConfigPath)
-      }
-
-      try {
-        const result = spawnSync(binaryPath, args, {
-          cwd,
-          encoding: 'utf-8',
-          stdio: ['pipe', 'pipe', 'pipe'],
-        })
-
-        if (result.status !== 0) {
-          throw new Error(`gustcss build failed: ${result.stderr}`)
-        }
-
-        // Output generation time log from stderr
-        if (result.stderr) {
-          process.stderr.write(result.stderr)
-        }
-
-        // Parse the generated CSS and append to the root
-        const postcss = require('postcss')
-        const parsed = postcss.parse(result.stdout)
-        root.append(parsed)
-      } catch (error) {
-        // CLI build failures (status !== 0) are already thrown above with stderr details.
-        // This catch block handles other errors:
-        // - spawnSync failures (e.g., binary not found, spawn error)
-        // - postcss.parse errors (malformed CSS output)
-        throw new Error(`gustcss build failed: ${error.message}`)
-      } finally {
-        // Clean up temporary config file
-        if (tempConfigPath && fs.existsSync(tempConfigPath)) {
-          fs.unlinkSync(tempConfigPath)
-        }
-      }
-    },
-  }
-}
-
-module.exports.postcss = true