@vlandoss/clibuddy 0.0.9 → 0.0.11-git-9445806.0

package/dist/index.d.mts

@@ -0,0 +1,72 @@
+import { ChalkInstance } from "chalk";
+import * as _$zx from "zx";
+import { Options, ProcessOutput, Shell as Shell$1 } from "zx";
+import { Project } from "@pnpm/workspace.find-packages";
+import { NormalizedPackageJson } from "read-package-up";
+
+//#region src/colors.d.ts
+declare const colorIsSupported: () => boolean;
+declare const colorize: (hex: string) => ChalkInstance | (<T>(x: T) => T);
+declare const palette: {
+  bold: ChalkInstance | (<T>(x: T) => T);
+  italic: ChalkInstance | (<T>(x: T) => T);
+  link: ChalkInstance | (<T>(x: T) => T);
+  muted: ChalkInstance | (<T>(x: T) => T);
+  vland: ChalkInstance | (<T>(x: T) => T);
+};
+//#endregion
+//#region src/run.d.ts
+declare function run(fn: () => Promise<void>, logger: {
+  error: (...args: unknown[]) => void;
+}): Promise<void>;
+//#endregion
+//#region src/services/pkg.d.ts
+declare class PkgService {
+  #private;
+  get dirPath(): string;
+  get packageJson(): NormalizedPackageJson;
+  constructor(packageJson: NormalizedPackageJson, pkgPath: string);
+  info(): {
+    packageJson: NormalizedPackageJson;
+    dirPath: string;
+  };
+  hasFile(name: string, dir?: string): boolean;
+  isMonorepo(): boolean;
+  getWorkspaceProjects(): Promise<Project[]>;
+}
+declare function createPkgService(cwd: string): Promise<PkgService | null>;
+//#endregion
+//#region src/services/shell/types.d.ts
+type Shell = Shell$1;
+type ShellOptions = Partial<Options>;
+type CreateOptions = ShellOptions & {
+  localBaseBinPath?: string | Array<string>;
+};
+//#endregion
+//#region src/services/shell/shell.d.ts
+declare class ShellService {
+  #private;
+  constructor(options: ShellOptions);
+  get options(): Partial<_$zx.Options>;
+  get $(): Shell;
+  child(options: ShellOptions): ShellService;
+  quiet(options?: ShellOptions): ShellService;
+  at(cwd: string, options?: ShellOptions): ShellService;
+}
+//#endregion
+//#region src/services/shell/create.d.ts
+declare const cwd: string;
+declare function quote(arg: string): string;
+declare const isRaw: (arg: unknown) => arg is {
+  stdout: string;
+};
+declare function createShellService(options?: CreateOptions): ShellService;
+//#endregion
+//#region src/services/shell/utils.d.ts
+declare function isProcessOutput(value: unknown): value is ProcessOutput;
+declare function getPreferLocal(localBaseBinPath: string | Array<string> | undefined): string[] | undefined;
+//#endregion
+//#region src/version.d.ts
+declare function getVersion(pkg: PkgService): string;
+//#endregion
+export { CreateOptions, PkgService, type Project, Shell, ShellOptions, ShellService, colorIsSupported, colorize, createPkgService, createShellService, cwd, getPreferLocal, getVersion, isProcessOutput, isRaw, palette, quote, run };

package/dist/index.mjs

@@ -0,0 +1,172 @@
+import chalk from "chalk";
+import supportsColor from "supports-color";
+import path from "node:path";
+import { $, ProcessOutput } from "zx";
+import fs from "node:fs";
+import { findWorkspacePackages } from "@pnpm/workspace.find-packages";
+import { readWorkspaceManifest } from "@pnpm/workspace.read-manifest";
+import { readPackageUp } from "read-package-up";
+//#region src/colors.ts
+const colorIsSupported = () => supportsColor.stdout && !process.env.NO_COLOR;
+const identity = (x) => x;
+const safe = (style) => colorIsSupported() ? style : identity;
+const colorize = (hex) => safe(chalk.hex(hex));
+const palette = {
+	bold: safe(chalk.bold),
+	italic: safe(chalk.italic),
+	link: safe(chalk.underline),
+	muted: safe(chalk.dim),
+	vland: colorize("#36d399")
+};
+//#endregion
+//#region src/services/shell/utils.ts
+function isProcessOutput(value) {
+	return value instanceof ProcessOutput;
+}
+const getLocalBinPath = (dirPath) => path.join(dirPath, "node_modules", ".bin");
+function getPreferLocal(localBaseBinPath) {
+	return !localBaseBinPath ? void 0 : Array.isArray(localBaseBinPath) ? localBaseBinPath.map(getLocalBinPath) : [localBaseBinPath].map(getLocalBinPath);
+}
+//#endregion
+//#region src/run.ts
+function hasMessage(error) {
+	return typeof error === "object" && error !== null && "message" in error && typeof error.message === "string";
+}
+function formatError(error) {
+	if (hasMessage(error)) return error.message;
+	return String(error);
+}
+async function run(fn, logger) {
+	try {
+		await fn();
+	} catch (error) {
+		if (!isProcessOutput(error)) logger.error(formatError(error));
+		process.exit(1);
+	}
+}
+//#endregion
+//#region src/services/pkg.ts
+var PkgService = class {
+	#packageJson;
+	#dirPath;
+	get dirPath() {
+		return this.#dirPath;
+	}
+	get packageJson() {
+		return this.#packageJson;
+	}
+	constructor(packageJson, pkgPath) {
+		this.#packageJson = packageJson;
+		this.#dirPath = path.dirname(pkgPath);
+	}
+	info() {
+		return {
+			packageJson: this.#packageJson,
+			dirPath: this.#dirPath
+		};
+	}
+	hasFile(name, dir) {
+		const filepath = dir ? path.join(dir, name) : this.#fromApp(name);
+		return fs.existsSync(filepath);
+	}
+	isMonorepo() {
+		return this.#packageJson.workspaces !== void 0 || this.#hasPnpmWorkspace();
+	}
+	async getWorkspaceProjects() {
+		let patterns;
+		if (this.#hasPnpmWorkspace()) {
+			const manifest = await readWorkspaceManifest(this.#dirPath);
+			if (!manifest) throw new Error("Can't read pnpm workspace manifest");
+			patterns = manifest.packages;
+		} else patterns = Array.isArray(this.#packageJson.workspaces) ? this.#packageJson.workspaces : this.#packageJson.workspaces?.packages ?? [];
+		if (!Array.isArray(patterns) || patterns.some((p) => typeof p !== "string")) throw new Error("Invalid workspace patterns");
+		const projects = await findWorkspacePackages(this.#dirPath, { patterns });
+		const excludeRoot = (projects) => {
+			return projects.filter((project) => project.rootDir !== this.#dirPath);
+		};
+		return excludeRoot(projects);
+	}
+	#hasPnpmWorkspace() {
+		return this.hasFile("pnpm-workspace.yaml");
+	}
+	#fromApp(...args) {
+		return path.join(this.#dirPath, ...args);
+	}
+};
+async function createPkgService(cwd) {
+	const searchResult = await readPackageUp({ cwd });
+	if (!searchResult) return null;
+	const { packageJson, path } = searchResult;
+	return new PkgService(packageJson, path);
+}
+//#endregion
+//#region src/services/shell/shell.ts
+var ShellService = class ShellService {
+	#shell;
+	#options;
+	constructor(options) {
+		this.#options = Object.freeze(options);
+		this.#shell = $(options);
+	}
+	get options() {
+		return this.#options;
+	}
+	get $() {
+		return this.#shell;
+	}
+	child(options) {
+		return new ShellService({
+			...this.#options,
+			...options
+		});
+	}
+	quiet(options) {
+		return this.child({
+			...options,
+			verbose: false
+		});
+	}
+	at(cwd, options) {
+		const getLocals = (locals) => typeof locals === "boolean" ? [] : typeof locals === "undefined" ? [] : Array.isArray(locals) ? locals : [locals];
+		const cwdPreferLocal = getPreferLocal(cwd);
+		const preferLocal = options?.preferLocal === false ? false : [
+			...getLocals(this.#options.preferLocal),
+			...getLocals(options?.preferLocal),
+			...cwdPreferLocal ? cwdPreferLocal : []
+		];
+		return this.child({
+			...options,
+			cwd,
+			preferLocal
+		});
+	}
+};
+//#endregion
+//#region src/services/shell/create.ts
+const cwd = fs.realpathSync(process.cwd());
+function quote(arg) {
+	if (/^[\w./:=@-]+$/i.test(arg) || arg === "") return arg;
+	return arg.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\f/g, "\\f").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replace(/\v/g, "\\v").replace(/\0/g, "\\0");
+}
+const isRaw = (arg) => typeof arg === "object" && arg !== null && "stdout" in arg && typeof arg.stdout === "string";
+function defaultQuote(arg) {
+	if (typeof arg === "string") return quote(arg);
+	if (isRaw(arg)) return arg.stdout;
+	throw TypeError(`Unsupported argument type: ${typeof arg}`);
+}
+function createShellService(options = {}) {
+	return new ShellService({
+		verbose: true,
+		cwd,
+		preferLocal: getPreferLocal(options.localBaseBinPath),
+		quote: defaultQuote,
+		...options
+	});
+}
+//#endregion
+//#region src/version.ts
+function getVersion(pkg) {
+	return process.env.VERSION || pkg.packageJson.version;
+}
+//#endregion
+export { PkgService, ShellService, colorIsSupported, colorize, createPkgService, createShellService, cwd, getPreferLocal, getVersion, isProcessOutput, isRaw, palette, quote, run };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vlandoss/clibuddy",
-  "version": "0.0.9",
+  "version": "0.0.11-git-9445806.0",
   "description": "A helper library to create CLIs in Variable Land",
   "homepage": "https://github.com/variableland/dx/tree/main/packages/clibuddy#readme",
   "bugs": {
@@ -8,20 +8,23 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/variableland/dx.git"
+    "url": "git+https://github.com/variableland/dx.git",
+    "directory": "packages/clibuddy"
   },
   "license": "MIT",
   "author": "rcrd <rcrd@variable.land>",
   "type": "module",
   "exports": {
-    ".": "./src/index.ts",
-    "./test-helpers": {
-      "bun": "./test-helpers/index.ts"
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
     }
   },
   "files": [
     "dist",
-    "src"
+    "src",
+    "!src/**/__tests__",
+    "!src/**/*.test.*"
   ],
   "dependencies": {
     "@pnpm/workspace.find-packages": "1000.0.62",
@@ -35,9 +38,14 @@
     "access": "public"
   },
   "engines": {
+    "node": ">=20.0.0",
     "bun": ">=1.0.0"
   },
+  "devDependencies": {
+    "@vlandoss/tsdown-config": "^0.0.2-git-9445806.0"
+  },
   "scripts": {
+    "build": "tsdown",
     "test:types": "rr tsc"
   }
 }