@elinzy/core 0.1.1 → 0.2.0

package/README.md

@@ -1 +1,83 @@
-## @elinzy/e-core
+# @elinzy/core
+
+Node.js runtime primitives for the `e` CLI: process execution built on [execa](https://github.com/sindresorhus/execa), with command logging, dry-run and abbreviated output support.
+
+## Install
+
+```shell
+npm install @elinzy/core
+```
+
+## Usage
+
+- ESM
+
+```js
+import { exec, execSync, execCommand, execCommandSync } from '@elinzy/core';
+
+// Asynchronous, array-style (like execa)
+const result = await exec('git', ['status']);
+console.log(result.stdout);
+
+// Synchronous, string-style
+const version = execCommandSync('node -v', { abbrev: true });
+
+// Dry run: log the command, skip execution
+await exec('rm', ['-rf', 'dist'], { dryRun: true });
+```
+
+- CJS
+
+```js
+const { execSync } = require('@elinzy/core');
+
+const stdout = execSync('node', ['-v'], { abbrev: true });
+```
+
+## API
+
+### exec(cmd, args, opts?)
+
+Execute a command asynchronously. Returns the execa result promise.
+
+### execSync(cmd, args, opts?)
+
+Execute a command synchronously. Returns the execa result.
+
+### execCommand(cmd, opts?)
+
+Execute a command string asynchronously (`'git status'` style). Returns the execa result promise.
+
+### execCommandSync(cmd, opts?)
+
+Execute a command string synchronously. Returns the execa result.
+
+#### cmd
+
+- Type: `String`
+
+#### args
+
+- Type: `String[]`
+
+#### opts
+
+- Type: `Object`
+- All [execa options](https://github.com/sindresorhus/execa/blob/main/docs/execution.md#options-1) are passed through (`cwd`, `env`, `stdio`, ...), plus:
+
+| Option | Type | Default | Description |
+| ------ | ---- | ------- | ----------- |
+| `abbrev` | `Boolean` | `false` | Return only `stdout` instead of the full result |
+| `logger` | `Boolean` | `false` | Print the command before executing it |
+| `dryRun` | `Boolean` | `false` | Print the command but skip execution |
+| `throwOnError` | `Boolean` | `true` | Throw a colored error including `stderr` / stack on failure; when `false`, failures resolve to `undefined` |
+
+## License
+
+[MIT](https://github.com/Appleec/e/blob/main/packages/core/LICENSE)
+
+## Related
+
+- [`@elinzy/logger`](https://github.com/Appleec/e/tree/main/packages/logger) — styled terminal logging
+- [`@elinzy/git`](https://github.com/Appleec/e/tree/main/packages/git) — git operations built on this package
+- [`e`](https://github.com/Appleec/e) — the monorepo root

package/dist/child_process.cjs

@@ -1,67 +1,107 @@
-'use strict';
-
-var execa = require('execa');
-var c = require('ansis');
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+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 || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let execa = require("execa");
+let ansis = require("ansis");
+ansis = __toESM(ansis, 1);
+//#region src/child_process.ts
+/**
+* Execute a command asynchronously
+* @param {string} cmd
+* @param {string[]} args
+* @param {import("execa").Options} [opts]
+*/
 function exec(cmd, args, opts) {
-  if (opts?.logger || opts?.dryRun)
-    console.log(c.green(`> ${[cmd, ...args].join(" ")}`));
-  if (opts?.dryRun)
-    return Promise.resolve(void 0);
-  return execa.execa(cmd, args, opts).then((spawned) => opts?.abbrev ? spawned?.stdout : spawned).catch((e) => {
-    if (opts?.throwOnError ?? true)
-      throw new Error(
-        c.red(`Running ${c.bold([cmd, ...args].join(" "))} in ${c.underline(opts?.cwd || e?.cwd || process.cwd())}:`) + (e.stderr || e.stack || e.message)
-      );
-    return Promise.resolve(void 0);
-  });
+	opts = {
+		throwOnError: true,
+		...opts
+	};
+	if (opts.logger || opts.dryRun) console.log(ansis.default.green(`> ${[cmd, ...args].join(" ")}`));
+	if (opts.dryRun) return Promise.resolve(void 0);
+	return (0, execa.execa)(cmd, args, opts).then((spawned) => opts.abbrev ? spawned.stdout : spawned).catch((e) => {
+		if (opts.throwOnError) throw new Error(ansis.default.red(`Running ${ansis.default.bold([cmd, ...args].join(" "))} in ${ansis.default.underline(opts.cwd || e.cwd || process.cwd())}:`) + (e.stderr || e.stack || e.message));
+		return Promise.resolve(void 0);
+	});
 }
+/**
+* Execute a command synchronously
+* @param {string} cmd
+* @param {string[]} args
+* @param {import("execa").SyncOptions} [opts]
+*/
 function execSync(cmd, args, opts) {
-  if (opts?.logger || opts?.dryRun)
-    console.log(c.green(`> ${[cmd, ...args].join(" ")}`));
-  if (opts?.dryRun)
-    return void 0;
-  try {
-    const spawned = execa.execaSync(cmd, args, opts);
-    return opts?.abbrev ? spawned?.stdout : spawned;
-  } catch (e) {
-    if (opts?.throwOnError ?? true)
-      throw new Error(
-        c.red(`Running ${c.bold([cmd, ...args].join(" "))} in ${c.underline(opts?.cwd || e?.cwd || process.cwd())}:`) + (e.stderr || e.stack || e.message)
-      );
-    return void 0;
-  }
+	opts = {
+		throwOnError: true,
+		...opts
+	};
+	if (opts.logger || opts.dryRun) console.log(ansis.default.green(`> ${[cmd, ...args].join(" ")}`));
+	if (opts.dryRun) return void 0;
+	try {
+		const spawned = (0, execa.execaSync)(cmd, args, opts);
+		return opts.abbrev ? spawned.stdout : spawned;
+	} catch (e) {
+		if (opts?.throwOnError) throw new Error(ansis.default.red(`Running ${ansis.default.bold([cmd, ...args].join(" "))} in ${ansis.default.underline(opts.cwd || e.cwd || process.cwd())}:`) + (e.stderr || e.stack || e.message));
+		return;
+	}
 }
+/**
+* Execute a command asynchronously (string)
+* @param cmd
+* @param opts
+*/
 function execCommand(cmd, opts) {
-  if (opts?.logger || opts?.dryRun)
-    console.log(c.green(`> ${[cmd].join(" ")}`));
-  if (opts?.dryRun)
-    return Promise.resolve(void 0);
-  return execa.execaCommand(cmd, opts).then((spawned) => opts?.abbrev ? spawned?.stdout : spawned).catch((e) => {
-    if (opts?.throwOnError ?? true)
-      throw new Error(
-        c.red(`Running ${c.bold([cmd].join(" "))} in ${c.underline(opts?.cwd || e?.cwd || process.cwd())}:`) + (e.stderr || e.stack || e.message)
-      );
-    return Promise.resolve(void 0);
-  });
+	opts = {
+		throwOnError: true,
+		...opts
+	};
+	if (opts.logger || opts.dryRun) console.log(ansis.default.green(`> ${[cmd].join(" ")}`));
+	if (opts.dryRun) return Promise.resolve(void 0);
+	return (0, execa.execaCommand)(cmd, opts).then((spawned) => opts.abbrev ? spawned.stdout : spawned).catch((e) => {
+		if (opts.throwOnError) throw new Error(ansis.default.red(`Running ${ansis.default.bold([cmd].join(" "))} in ${ansis.default.underline(opts.cwd || e.cwd || process.cwd())}:`) + (e.stderr || e.stack || e.message));
+		return Promise.resolve(void 0);
+	});
 }
+/**
+* Execute a command synchronously (string)
+* @param cmd
+* @param opts
+*/
 function execCommandSync(cmd, opts) {
-  if (opts?.logger || opts?.dryRun)
-    console.log(c.green(`> ${[cmd].join(" ")}`));
-  if (opts?.dryRun)
-    return void 0;
-  try {
-    const spawned = execa.execaCommandSync(cmd, opts);
-    return opts?.abbrev ? spawned?.stdout : spawned;
-  } catch (e) {
-    if (opts?.throwOnError ?? true)
-      throw new Error(
-        c.red(`Running ${c.bold([cmd].join(" "))} in ${c.underline(opts?.cwd || e?.cwd || process.cwd())}:`) + (e.stderr || e.stack || e.message)
-      );
-    return void 0;
-  }
+	opts = {
+		throwOnError: true,
+		...opts
+	};
+	if (opts.logger || opts.dryRun) console.log(ansis.default.green(`> ${[cmd].join(" ")}`));
+	if (opts.dryRun) return void 0;
+	try {
+		const spawned = (0, execa.execaCommandSync)(cmd, opts);
+		return opts.abbrev ? spawned.stdout : spawned;
+	} catch (e) {
+		if (opts.throwOnError) throw new Error(ansis.default.red(`Running ${ansis.default.bold([cmd].join(" "))} in ${ansis.default.underline(opts.cwd || e.cwd || process.cwd())}:`) + (e.stderr || e.stack || e.message));
+		return;
+	}
 }
-
+//#endregion
 exports.exec = exec;
 exports.execCommand = execCommand;
 exports.execCommandSync = execCommandSync;

package/dist/child_process.d.cts

@@ -0,0 +1,44 @@
+import { Options, Result, ResultPromise, SyncOptions, SyncResult } from "execa";
+//#region src/child_process.d.ts
+export interface ExecOptions extends Options {
+  abbrev?: boolean;
+  logger?: boolean;
+  dryRun?: boolean;
+  throwOnError?: boolean;
+}
+export interface ExecSyncOptions extends SyncOptions {
+  abbrev?: boolean;
+  logger?: boolean;
+  dryRun?: boolean;
+  throwOnError?: boolean;
+}
+export type ExecResult = Result;
+export type ExecSyncResult = SyncResult;
+export type ExecResultPromise = ResultPromise;
+/**
+ * Execute a command asynchronously
+ * @param {string} cmd
+ * @param {string[]} args
+ * @param {import("execa").Options} [opts]
+ */
+export declare function exec(cmd: string, args: string[], opts?: ExecOptions): Promise<any>;
+/**
+ * Execute a command synchronously
+ * @param {string} cmd
+ * @param {string[]} args
+ * @param {import("execa").SyncOptions} [opts]
+ */
+export declare function execSync(cmd: string, args: string[], opts?: ExecSyncOptions): string | SyncResult<ExecSyncOptions> | unknown[] | Uint8Array<ArrayBufferLike> | undefined;
+/**
+ * Execute a command asynchronously (string)
+ * @param cmd
+ * @param opts
+ */
+export declare function execCommand(cmd: string, opts?: ExecOptions): Promise<string | unknown[] | Uint8Array<ArrayBufferLike> | Result<ExecOptions> | undefined>;
+/**
+ * Execute a command synchronously (string)
+ * @param cmd
+ * @param opts
+ */
+export declare function execCommandSync(cmd: string, opts?: ExecSyncOptions): string | SyncResult<ExecSyncOptions> | unknown[] | Uint8Array<ArrayBufferLike> | undefined;
+//#endregion

package/dist/child_process.d.mts

@@ -0,0 +1,44 @@
+import { Options, Result, ResultPromise, SyncOptions, SyncResult } from "execa";
+//#region src/child_process.d.ts
+export interface ExecOptions extends Options {
+  abbrev?: boolean;
+  logger?: boolean;
+  dryRun?: boolean;
+  throwOnError?: boolean;
+}
+export interface ExecSyncOptions extends SyncOptions {
+  abbrev?: boolean;
+  logger?: boolean;
+  dryRun?: boolean;
+  throwOnError?: boolean;
+}
+export type ExecResult = Result;
+export type ExecSyncResult = SyncResult;
+export type ExecResultPromise = ResultPromise;
+/**
+ * Execute a command asynchronously
+ * @param {string} cmd
+ * @param {string[]} args
+ * @param {import("execa").Options} [opts]
+ */
+export declare function exec(cmd: string, args: string[], opts?: ExecOptions): Promise<any>;
+/**
+ * Execute a command synchronously
+ * @param {string} cmd
+ * @param {string[]} args
+ * @param {import("execa").SyncOptions} [opts]
+ */
+export declare function execSync(cmd: string, args: string[], opts?: ExecSyncOptions): string | SyncResult<ExecSyncOptions> | unknown[] | Uint8Array<ArrayBufferLike> | undefined;
+/**
+ * Execute a command asynchronously (string)
+ * @param cmd
+ * @param opts
+ */
+export declare function execCommand(cmd: string, opts?: ExecOptions): Promise<string | unknown[] | Uint8Array<ArrayBufferLike> | Result<ExecOptions> | undefined>;
+/**
+ * Execute a command synchronously (string)
+ * @param cmd
+ * @param opts
+ */
+export declare function execCommandSync(cmd: string, opts?: ExecSyncOptions): string | SyncResult<ExecSyncOptions> | unknown[] | Uint8Array<ArrayBufferLike> | undefined;
+//#endregion

package/dist/child_process.mjs

@@ -1,63 +1,81 @@
-import { execa, execaSync, execaCommand, execaCommandSync } from 'execa';
-import c from 'ansis';
-
+import { execa, execaCommand, execaCommandSync, execaSync } from "execa";
+import c from "ansis";
+//#region src/child_process.ts
+/**
+* Execute a command asynchronously
+* @param {string} cmd
+* @param {string[]} args
+* @param {import("execa").Options} [opts]
+*/
 function exec(cmd, args, opts) {
-  if (opts?.logger || opts?.dryRun)
-    console.log(c.green(`> ${[cmd, ...args].join(" ")}`));
-  if (opts?.dryRun)
-    return Promise.resolve(void 0);
-  return execa(cmd, args, opts).then((spawned) => opts?.abbrev ? spawned?.stdout : spawned).catch((e) => {
-    if (opts?.throwOnError ?? true)
-      throw new Error(
-        c.red(`Running ${c.bold([cmd, ...args].join(" "))} in ${c.underline(opts?.cwd || e?.cwd || process.cwd())}:`) + (e.stderr || e.stack || e.message)
-      );
-    return Promise.resolve(void 0);
-  });
+	opts = {
+		throwOnError: true,
+		...opts
+	};
+	if (opts.logger || opts.dryRun) console.log(c.green(`> ${[cmd, ...args].join(" ")}`));
+	if (opts.dryRun) return Promise.resolve(void 0);
+	return execa(cmd, args, opts).then((spawned) => opts.abbrev ? spawned.stdout : spawned).catch((e) => {
+		if (opts.throwOnError) throw new Error(c.red(`Running ${c.bold([cmd, ...args].join(" "))} in ${c.underline(opts.cwd || e.cwd || process.cwd())}:`) + (e.stderr || e.stack || e.message));
+		return Promise.resolve(void 0);
+	});
 }
+/**
+* Execute a command synchronously
+* @param {string} cmd
+* @param {string[]} args
+* @param {import("execa").SyncOptions} [opts]
+*/
 function execSync(cmd, args, opts) {
-  if (opts?.logger || opts?.dryRun)
-    console.log(c.green(`> ${[cmd, ...args].join(" ")}`));
-  if (opts?.dryRun)
-    return void 0;
-  try {
-    const spawned = execaSync(cmd, args, opts);
-    return opts?.abbrev ? spawned?.stdout : spawned;
-  } catch (e) {
-    if (opts?.throwOnError ?? true)
-      throw new Error(
-        c.red(`Running ${c.bold([cmd, ...args].join(" "))} in ${c.underline(opts?.cwd || e?.cwd || process.cwd())}:`) + (e.stderr || e.stack || e.message)
-      );
-    return void 0;
-  }
+	opts = {
+		throwOnError: true,
+		...opts
+	};
+	if (opts.logger || opts.dryRun) console.log(c.green(`> ${[cmd, ...args].join(" ")}`));
+	if (opts.dryRun) return void 0;
+	try {
+		const spawned = execaSync(cmd, args, opts);
+		return opts.abbrev ? spawned.stdout : spawned;
+	} catch (e) {
+		if (opts?.throwOnError) throw new Error(c.red(`Running ${c.bold([cmd, ...args].join(" "))} in ${c.underline(opts.cwd || e.cwd || process.cwd())}:`) + (e.stderr || e.stack || e.message));
+		return;
+	}
 }
+/**
+* Execute a command asynchronously (string)
+* @param cmd
+* @param opts
+*/
 function execCommand(cmd, opts) {
-  if (opts?.logger || opts?.dryRun)
-    console.log(c.green(`> ${[cmd].join(" ")}`));
-  if (opts?.dryRun)
-    return Promise.resolve(void 0);
-  return execaCommand(cmd, opts).then((spawned) => opts?.abbrev ? spawned?.stdout : spawned).catch((e) => {
-    if (opts?.throwOnError ?? true)
-      throw new Error(
-        c.red(`Running ${c.bold([cmd].join(" "))} in ${c.underline(opts?.cwd || e?.cwd || process.cwd())}:`) + (e.stderr || e.stack || e.message)
-      );
-    return Promise.resolve(void 0);
-  });
+	opts = {
+		throwOnError: true,
+		...opts
+	};
+	if (opts.logger || opts.dryRun) console.log(c.green(`> ${[cmd].join(" ")}`));
+	if (opts.dryRun) return Promise.resolve(void 0);
+	return execaCommand(cmd, opts).then((spawned) => opts.abbrev ? spawned.stdout : spawned).catch((e) => {
+		if (opts.throwOnError) throw new Error(c.red(`Running ${c.bold([cmd].join(" "))} in ${c.underline(opts.cwd || e.cwd || process.cwd())}:`) + (e.stderr || e.stack || e.message));
+		return Promise.resolve(void 0);
+	});
 }
+/**
+* Execute a command synchronously (string)
+* @param cmd
+* @param opts
+*/
 function execCommandSync(cmd, opts) {
-  if (opts?.logger || opts?.dryRun)
-    console.log(c.green(`> ${[cmd].join(" ")}`));
-  if (opts?.dryRun)
-    return void 0;
-  try {
-    const spawned = execaCommandSync(cmd, opts);
-    return opts?.abbrev ? spawned?.stdout : spawned;
-  } catch (e) {
-    if (opts?.throwOnError ?? true)
-      throw new Error(
-        c.red(`Running ${c.bold([cmd].join(" "))} in ${c.underline(opts?.cwd || e?.cwd || process.cwd())}:`) + (e.stderr || e.stack || e.message)
-      );
-    return void 0;
-  }
+	opts = {
+		throwOnError: true,
+		...opts
+	};
+	if (opts.logger || opts.dryRun) console.log(c.green(`> ${[cmd].join(" ")}`));
+	if (opts.dryRun) return void 0;
+	try {
+		const spawned = execaCommandSync(cmd, opts);
+		return opts.abbrev ? spawned.stdout : spawned;
+	} catch (e) {
+		if (opts.throwOnError) throw new Error(c.red(`Running ${c.bold([cmd].join(" "))} in ${c.underline(opts.cwd || e.cwd || process.cwd())}:`) + (e.stderr || e.stack || e.message));
+		return;
+	}
 }
-
+//#endregion
 export { exec, execCommand, execCommandSync, execSync };

package/dist/index.cjs

@@ -1,10 +1,6 @@
-'use strict';
-
-var child_process = require('./child_process.cjs');
-
-
-
-exports.exec = child_process.exec;
-exports.execCommand = child_process.execCommand;
-exports.execCommandSync = child_process.execCommandSync;
-exports.execSync = child_process.execSync;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_child_process = require("./child_process.cjs");
+exports.exec = require_child_process.exec;
+exports.execCommand = require_child_process.execCommand;
+exports.execCommandSync = require_child_process.execCommandSync;
+exports.execSync = require_child_process.execSync;

package/dist/index.d.cts

@@ -0,0 +1,2 @@
+import { ExecOptions, ExecResult, ExecResultPromise, ExecSyncOptions, ExecSyncResult, exec, execCommand, execCommandSync, execSync } from "./child_process.cjs";
+export { type ExecOptions, type ExecResult, type ExecResultPromise, type ExecSyncOptions, type ExecSyncResult, exec, execCommand, execCommandSync, execSync };

package/dist/index.d.mts

@@ -0,0 +1,2 @@
+import { ExecOptions, ExecResult, ExecResultPromise, ExecSyncOptions, ExecSyncResult, exec, execCommand, execCommandSync, execSync } from "./child_process.mjs";
+export { type ExecOptions, type ExecResult, type ExecResultPromise, type ExecSyncOptions, type ExecSyncResult, exec, execCommand, execCommandSync, execSync };

package/dist/index.mjs

@@ -1 +1 @@
-export { exec, execCommand, execCommandSync, execSync } from './child_process.mjs';
+export { exec, execCommand, execCommandSync, execSync } from "./child_process.mjs";

package/package.json

@@ -1,68 +1,62 @@
 {
   "name": "@elinzy/core",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "e core implementation module",
+  "homepage": "https://github.com/Appleec/e#readme",
+  "bugs": {
+    "url": "https://github.com/Appleec/e/issues"
+  },
+  "license": "MIT",
+  "author": "Appleec <771992522@qq.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Appleec/e.git",
+    "directory": "packages/core"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "keywords": [
+    "e",
+    "core"
+  ],
+  "files": [
+    "dist"
+  ],
   "type": "module",
+  "sideEffects": false,
   "main": "./dist/index.cjs",
-  "types": "./dist/index.d.ts",
+  "types": "./dist/index.d.cts",
+  "module": "./dist/index.mjs",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
       "require": "./dist/index.cjs"
     },
     "./child_process": {
-      "types": "./dist/child_process.d.ts",
       "import": "./dist/child_process.mjs",
       "require": "./dist/child_process.cjs"
-    }
-  },
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
-  },
-  "files": [
-    "dist"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Appleec/e.git",
-    "directory": "packages/core"
+    },
+    "./package.json": "./package.json"
   },
-  "keywords": [
-    "e",
-    "core",
-    "e-core"
-  ],
-  "author": "Appleec <771992522@qq.com>",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/Appleec/e/issues"
+  "dependencies": {
+    "ansis": "4.2.0",
+    "execa": "^9.5.2"
   },
-  "homepage": "https://github.com/Appleec/e#readme",
   "devDependencies": {
-    "@babel/core": "7.26.10",
-    "@babel/preset-env": "7.26.9",
-    "@babel/preset-typescript": "7.26.0",
-    "@rollup/plugin-babel": "6.0.4",
-    "@rollup/plugin-node-resolve": "16.0.1",
-    "rollup": "4.35.0",
-    "rollup-plugin-dts": "6.1.1",
-    "rollup-plugin-esbuild": "6.2.1",
-    "rollup-plugin-node-externals": "8.0.0",
-    "tslib": "2.8.1",
-    "typescript": "^5.8.2"
+    "tsdown": "^0.23.1"
   },
-  "dependencies": {
-    "ansis": "^3.17.0",
-    "execa": "^9.5.2"
+  "engines": {
+    "node": "^18.18.0 || ^20.9.0 || >=21.1.0",
+    "npm": "please-use-pnpm",
+    "pnpm": ">=10.0.0",
+    "yarn": "please-use-pnpm"
   },
   "scripts": {
-    "dev": "rollup --config rollup.config.mjs --watch",
-    "build": "npm-run-all --parallel build:clean build:main build:type",
-    "build:main": "rollup --config rollup.config.mjs",
-    "build:type": "tsc --project tsconfig.build.json --emitDeclarationOnly --preserveWatchOutput",
-    "build:clean": "rimraf ./dist",
+    "dev": "tsdown --watch",
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit",
     "test": "echo \"Error: no test specified\" && exit 1"
   }
 }

package/dist/child_process.d.ts

@@ -1,39 +0,0 @@
-import { type Options as ExecaOptions, type SyncOptions as ExecaSyncOptions } from 'execa';
-export interface ExecOptions extends ExecaOptions {
-    abbrev?: boolean;
-    logger?: boolean;
-    dryRun?: boolean;
-    throwOnError?: boolean;
-}
-export interface ExecSyncOptions extends ExecaSyncOptions {
-    abbrev?: boolean;
-    logger?: boolean;
-    dryRun?: boolean;
-    throwOnError?: boolean;
-}
-/**
- * Execute a command asynchronously
- * @param {string} cmd
- * @param {string[]} args
- * @param {import("execa").Options} [opts]
- */
-export declare function exec(cmd: string, args: string[], opts?: ExecOptions): Promise<any>;
-/**
- * Execute a command synchronously
- * @param {string} cmd
- * @param {string[]} args
- * @param {import("execa").SyncOptions} [opts]
- */
-export declare function execSync(cmd: string, args: string[], opts?: ExecSyncOptions): string | unknown[] | Uint8Array<ArrayBufferLike> | import("execa").SyncResult<ExecSyncOptions> | undefined;
-/**
- * Execute a command asynchronously (string)
- * @param cmd
- * @param opts
- */
-export declare function execCommand(cmd: string, opts?: ExecOptions): Promise<string | unknown[] | import("execa").Result<ExecOptions> | Uint8Array<ArrayBufferLike> | undefined>;
-/**
- * Execute a command synchronously (string)
- * @param cmd
- * @param opts
- */
-export declare function execCommandSync(cmd: string, opts?: ExecSyncOptions): string | unknown[] | Uint8Array<ArrayBufferLike> | import("execa").SyncResult<ExecSyncOptions> | undefined;

package/dist/index.d.ts

@@ -1,22 +0,0 @@
-import * as execa from 'execa';
-import { Options, SyncOptions } from 'execa';
-
-interface ExecOptions extends Options {
-    abbrev?: boolean;
-    logger?: boolean;
-    dryRun?: boolean;
-    throwOnError?: boolean;
-}
-interface ExecSyncOptions extends SyncOptions {
-    abbrev?: boolean;
-    logger?: boolean;
-    dryRun?: boolean;
-    throwOnError?: boolean;
-}
-declare function exec(cmd: string, args: string[], opts?: ExecOptions): Promise<any>;
-declare function execSync(cmd: string, args: string[], opts?: ExecSyncOptions): string | execa.SyncResult<ExecSyncOptions> | unknown[] | Uint8Array<ArrayBufferLike> | undefined;
-declare function execCommand(cmd: string, opts?: ExecOptions): Promise<string | unknown[] | Uint8Array<ArrayBufferLike> | execa.Result<ExecOptions> | undefined>;
-declare function execCommandSync(cmd: string, opts?: ExecSyncOptions): string | execa.SyncResult<ExecSyncOptions> | unknown[] | Uint8Array<ArrayBufferLike> | undefined;
-
-export { exec, execCommand, execCommandSync, execSync };
-export type { ExecOptions, ExecSyncOptions };