@maizzle/framework 6.0.0-rc.1 → 6.0.0-rc.11

package/node_modules/{commander → maizzle/node_modules/commander}/typings/index.d.ts

@@ -51,6 +51,7 @@ export class Argument {
   variadic: boolean;
   defaultValue?: any;
   defaultValueDescription?: string;
+  parseArg?: <T>(value: string, previous: T) => T;
   argChoices?: string[];
 
   /**
@@ -109,6 +110,7 @@ export class Option {
   parseArg?: <T>(value: string, previous: T) => T;
   hidden: boolean;
   argChoices?: string[];
+  helpGroupHeading?: string;
 
   constructor(flags: string, description?: string);
 
@@ -192,6 +194,11 @@ export class Option {
    */
   attributeName(): string;
 
+  /**
+   * Set the help group heading.
+   */
+  helpGroup(heading: string): this;
+
   /**
    * Return whether a boolean option.
    *
@@ -313,6 +320,20 @@ export class Help {
     helper: Help,
   ): string;
 
+  /**
+   * Format a list of items, given a heading and an array of formatted items.
+   */
+  formatItemList(heading: string, items: string[], helper: Help): string[];
+
+  /**
+   * Group items by their help group heading.
+   */
+  groupItems<T extends Command | Option>(
+    unsortedItems: T[],
+    visibleItems: T[],
+    getGroup: (item: T) => string,
+  ): Map<string, T[]>;
+
   /** Generate the built-in help text. */
   formatHelp(cmd: Command, helper: Help): string;
 }
@@ -466,7 +487,7 @@ export class Command {
   argument<T>(
     flags: string,
     description: string,
-    fn: (value: string, previous: T) => T,
+    parseArg: (value: string, previous: T) => T,
     defaultValue?: T,
   ): this;
   argument(name: string, description?: string, defaultValue?: unknown): this;
@@ -968,6 +989,53 @@ export class Command {
    */
   executableDir(): string | null;
 
+  /**
+   * Set the help group heading for this subcommand in parent command's help.
+   *
+   * @returns `this` command for chaining
+   */
+  helpGroup(heading: string): this;
+  /**
+   * Get the help group heading for this subcommand in parent command's help.
+   */
+  helpGroup(): string;
+
+  /**
+   * Set the default help group heading for subcommands added to this command.
+   * (This does not override a group set directly on the subcommand using .helpGroup().)
+   *
+   * @example
+   * program.commandsGroup('Development Commands:);
+   * program.command('watch')...
+   * program.command('lint')...
+   * ...
+   *
+   * @returns `this` command for chaining
+   */
+  commandsGroup(heading: string): this;
+  /**
+   * Get the default help group heading for subcommands added to this command.
+   */
+  commandsGroup(): string;
+
+  /**
+   * Set the default help group heading for options added to this command.
+   * (This does not override a group set directly on the option using .helpGroup().)
+   *
+   * @example
+   * program
+   *   .optionsGroup('Development Options:')
+   *   .option('-d, --debug', 'output extra debugging')
+   *   .option('-p, --profile', 'output profiling information')
+   *
+   * @returns `this` command for chaining
+   */
+  optionsGroup(heading: string): this;
+  /**
+   * Get the default help group heading for options added to this command.
+   */
+  optionsGroup(): string;
+
   /**
    * Output help information for this command.
    *
@@ -976,7 +1044,7 @@ export class Command {
    */
   outputHelp(context?: HelpContext): void;
   /** @deprecated since v7 */
-  outputHelp(cb?: (str: string) => string): void;
+  outputHelp(cb: (str: string) => string): void;
 
   /**
    * Return command help documentation.
@@ -1003,7 +1071,7 @@ export class Command {
    */
   help(context?: HelpContext): never;
   /** @deprecated since v7 */
-  help(cb?: (str: string) => string): never;
+  help(cb: (str: string) => string): never;
 
   /**
    * Add additional text to be displayed with the built-in help.

package/node_modules/{@maizzle/cli → maizzle}/package.json

@@ -1,20 +1,21 @@
 {
-  "name": "@maizzle/cli",
-  "version": "3.0.0-rc.0",
+  "name": "maizzle",
+  "version": "1.0.2",
   "description": "CLI tool for the Maizzle Email Framework",
   "license": "MIT",
   "type": "module",
-  "publishConfig": {
-    "access": "public"
-  },
   "exports": {
     ".": {
       "import": "./dist/index.mjs",
       "types": "./dist/index.d.mts"
     }
   },
+  "bin": {
+    "maizzle": "./bin/maizzle.mjs"
+  },
   "files": [
-    "dist"
+    "dist",
+    "bin"
   ],
   "scripts": {
     "build": "tsdown",
@@ -24,17 +25,18 @@
     "release": "npm run build && npx np"
   },
   "dependencies": {
-    "@clack/prompts": "^0.10.0",
-    "commander": "^13.1.0",
-    "create-maizzle": "^1.0.0",
+    "@clack/prompts": "^1.2.0",
+    "commander": "^14.0.3",
+    "giget": "^3.2.0",
+    "nypm": "^0.6.5",
     "picocolors": "^1.1.1"
   },
   "devDependencies": {
     "@types/node": "^25.2.3",
-    "@vitest/coverage-v8": "^4.1.2",
+    "@vitest/coverage-v8": "^4.1.3",
     "tsdown": "^0.21.7",
-    "typescript": "^5.9.3",
-    "vitest": "^4.1.2"
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.3"
   },
   "repository": {
     "type": "git",

package/node_modules/tinyexec/README.md

@@ -25,7 +25,7 @@ const result = await x('ls', ['-l']);
 // result.exitCode - the process exit code as a number
 ```
 
-By default, tinyexec does not throw on non‑zero exit codes. Check `result.exitCode` or pass `{throwOnError: true}`. 
+By default, tinyexec does not throw on non‑zero exit codes. Check `result.exitCode` or pass `{throwOnError: true}`.
 
 Output is returned exactly as produced; trailing newlines are not trimmed. If you need trimming, do it explicitly:
 
@@ -58,12 +58,24 @@ await x('ls', [], {
 The options object can have the following properties:
 
 - `signal` - an `AbortSignal` to allow aborting of the execution
-- `timeout` - time in milliseconds at which the process will be forceably killed
+- `timeout` - time in milliseconds at which the process will be forcibly killed
 - `persist` - if `true`, the process will continue after the host exits
-- `stdin` - another `Result` can be used as the input to this process
+- `stdin` - `string` or another `Result` that will be used as the input to the process
 - `nodeOptions` - any valid options to node's underlying `spawn` function
 - `throwOnError` - if true, non-zero exit codes will throw an error
 
+### Passing a string to stdin
+
+You can pass a string to `stdin`, which is useful for whitespace-sensitive values and for secrets you shouldn’t be exposed in shell history:
+
+```ts
+const result = await x('gh', ['auth', 'login', '--with-token'], {
+  stdin: process.env.GITHUB_TOKEN
+});
+
+console.log(result.exitCode);
+```
+
 ### Piping to another process
 
 You can pipe a process to another via the `pipe` method:
@@ -149,6 +161,40 @@ const result = await x(command, args);
 result.stdout; // Hello, World!
 ```
 
+### Synchronous
+
+You can use `xSync` for synchronous (blocking) execution:
+
+```ts
+import {xSync} from 'tinyexec';
+
+const result = xSync('ls', ['-l']);
+
+// result.stdout - the stdout as a string
+// result.stderr - the stderr as a string
+// result.exitCode - the process exit code as a number
+```
+
+Like the async API, you can iterate over lines:
+
+```ts
+const result = xSync('ls', ['-l']);
+
+for (const line of result) {
+  // line will be from stdout then stderr
+}
+```
+
+Since the synchronous API blocks the event loop, there are some features that are supported in the async API that the sync API does not support:
+
+- `signal`
+- `persist`
+- `kill()` method
+- `stdin` piping
+- `pipe()` method
+
+Other options like `timeout`, `throwOnError`, and `nodeOptions` work the same way.
+
 ## API
 
 Calling `x(command[, args])` returns an awaitable `Result` which has the

package/node_modules/tinyexec/dist/main.d.mts

@@ -1,12 +1,12 @@
-import { ChildProcess, SpawnOptions } from "node:child_process";
+import { ChildProcess, SpawnOptions, SpawnSyncOptions } from "node:child_process";
 import { Readable } from "node:stream";
 
 //#region src/non-zero-exit-error.d.ts
 declare class NonZeroExitError extends Error {
-  readonly result: Result;
-  readonly output?: Output;
+  readonly result: CommonOutputApi;
+  readonly output?: Output | undefined;
   get exitCode(): number | undefined;
-  constructor(result: Result, output?: Output);
+  constructor(result: CommonOutputApi, output?: Output | undefined);
 }
 //#endregion
 //#region src/main.d.ts
@@ -17,23 +17,32 @@ interface Output {
 }
 interface PipeOptions extends Options {}
 type KillSignal = Parameters<ChildProcess['kill']>[0];
-interface OutputApi extends AsyncIterable<string> {
-  pipe(command: string, args?: string[], options?: Partial<PipeOptions>): Result;
-  process: ChildProcess | undefined;
-  kill(signal?: KillSignal): boolean;
+interface CommonOutputApi {
   get pid(): number | undefined;
-  get aborted(): boolean;
   get killed(): boolean;
   get exitCode(): number | undefined;
 }
+interface OutputApi extends AsyncIterable<string>, CommonOutputApi {
+  process: ChildProcess | undefined;
+  get aborted(): boolean;
+  pipe(command: string, args?: string[], options?: Partial<PipeOptions>): Result;
+  kill(signal?: KillSignal): boolean;
+}
+interface OutputApiSync extends Iterable<string>, CommonOutputApi {}
 type Result = PromiseLike<Output> & OutputApi;
-interface Options {
+type SyncResult = Output & OutputApiSync;
+interface CommonOptions {
+  timeout: number;
+  throwOnError: boolean;
+}
+interface Options extends CommonOptions {
   signal: AbortSignal;
   nodeOptions: SpawnOptions;
-  timeout: number;
   persist: boolean;
-  stdin: ExecProcess;
-  throwOnError: boolean;
+  stdin: Result | ExecProcess | string;
+}
+interface SyncOptions extends CommonOptions {
+  nodeOptions: SpawnSyncOptions;
 }
 interface TinyExec {
   (command: string, args?: string[], options?: Partial<Options>): Result;
@@ -65,7 +74,9 @@ declare class ExecProcess implements Result {
   protected _onError: (err: Error) => void;
   protected _onClose: () => void;
 }
+declare function xSync(command: string, args?: string[], options?: Partial<SyncOptions>): SyncResult;
 declare const x: TinyExec;
 declare const exec: TinyExec;
+declare const execSync: typeof xSync;
 //#endregion
-export { ExecProcess, KillSignal, NonZeroExitError, Options, Output, OutputApi, PipeOptions, Result, TinyExec, exec, x };
+export { CommonOptions, CommonOutputApi, ExecProcess, KillSignal, NonZeroExitError, Options, Output, OutputApi, OutputApiSync, PipeOptions, Result, SyncOptions, SyncResult, TinyExec, exec, execSync, x, xSync };