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

package/node_modules/@clack/core/CHANGELOG.md

@@ -1,12 +1,95 @@
 # @clack/core
 
-## 0.4.2
+## 1.2.0
+
+### Minor Changes
+
+- 9786226: Externalize `fast-string-width` and `fast-wrap-ansi` to avoid double dependencies
+- 090902c: Adds `date` prompt with `format` support (YMD, MDY, DMY)
+
+### Patch Changes
+
+- bdf89a5: Adds `placeholder` option to `autocomplete`. When the placeholder is set and the input is empty, pressing `tab` will set the value to `placeholder`.
+- 417b451: Only apply autocomplete default filter if it has been explicitly set or if options is not a getter.
+
+## 1.1.0
+
+### Minor Changes
+
+- e3333fb: Replaces `picocolors` with Node.js built-in `styleText`.
+
+## 1.0.1
+
+### Patch Changes
+
+- 6404dc1: Disallows selection of `disabled` options in autocomplete.
+- 2533180: Updates the documentation to mention `userInputWithCursor` when using the `TextPrompt` primitive.
+
+## 1.0.0
+
+### Major Changes
+
+- c713fd5: The package is now distributed as ESM-only. In `v0` releases, the package was dual-published as CJS and ESM.
+
+  For existing CJS projects using Node v20+, please see Node's guide on [Loading ECMAScript modules using `require()`](https://nodejs.org/docs/latest-v20.x/api/modules.html#loading-ecmascript-modules-using-require).
+
+### Minor Changes
+
+- 7bc3301: Prompts now have a `userInput` stored separately from their `value`.
+- 2837845: Adds suggestion and path prompts
+- 729bbb6: Add support for customizable spinner cancel and error messages. Users can now customize these messages either per spinner instance or globally via the `updateSettings` function to support multilingual CLIs.
+
+  This update also improves the architecture by exposing the core settings to the prompts package, enabling more consistent default message handling across the codebase.
+
+  ```ts
+  // Per-instance customization
+  const spinner = prompts.spinner({
+    cancelMessage: "Operación cancelada", // "Operation cancelled" in Spanish
+    errorMessage: "Se produjo un error", // "An error occurred" in Spanish
+  });
+
+  // Global customization via updateSettings
+  prompts.updateSettings({
+    messages: {
+      cancel: "Operación cancelada", // "Operation cancelled" in Spanish
+      error: "Se produjo un error", // "An error occurred" in Spanish
+    },
+  });
+
+  // Settings can now be accessed directly
+  console.log(prompts.settings.messages.cancel); // "Operación cancelada"
+
+  // Direct options take priority over global settings
+  const spinner = prompts.spinner({
+    cancelMessage: "Cancelled", // This will be used instead of the global setting
+  });
+  ```
+
+- 55645c2: Support wrapping autocomplete and select prompts.
+- f2c2b89: Adds `AutocompletePrompt` to core with comprehensive tests and implement both `autocomplete` and `autocomplete-multiselect` components in prompts package.
+- df4eea1: Remove `suggestion` prompt and change `path` prompt to be an autocomplete prompt.
+- 1604f97: Add `clearOnError` option to password prompt to automatically clear input when validation fails
 
 ### Patch Changes
 
-- 30aa7ed: Adds a new `selectableGroups` boolean to the group multi-select prompt. Using `selectableGroups: false` will disable the ability to select a top-level group, but still allow every child to be selected individually.
-- 5dfce8a: Fixes an edge case for placeholder values. Previously, when pressing `enter` on an empty prompt, placeholder values would be ignored. Now, placeholder values are treated as the prompt value.
-- f574297: Fix "TTY initialization failed: uv_tty_init returned EBADF (bad file descriptor)" error happening on Windows for non-tty terminals.
+- 0718b07: fix: export `*Options` types for prompts.
+- bfe0dd3: Prevents placeholder from being used as input value in text prompts
+- 6868c1c: Adds a new `selectableGroups` boolean to the group multi-select prompt. Using `selectableGroups: false` will disable the ability to select a top-level group, but still allow every child to be selected individually.
+- 7df841d: Removed all trailing space in prompt output and fixed various padding rendering bugs.
+- a4f5034: Fixes an edge case for placeholder values. Previously, when pressing `enter` on an empty prompt, placeholder values would be ignored. Now, placeholder values are treated as the prompt value.
+- b103ad3: Allow disabled options in multi-select and select prompts.
+- 71b5029: Add missing nullish checks around values.
+- a36292b: Fix "TTY initialization failed: uv_tty_init returned EBADF (bad file descriptor)" error happening on Windows for non-tty terminals.
+- 1a45f93: Switched from wrap-ansi to fast-wrap-ansi
+- 4ba2d78: Support short terminal windows when re-rendering by accounting for off-screen lines
+- 34f52fe: Validates initial values immediately when using text prompts with initialValue and validate props.
+- 94fee2a: Changes `placeholder` to be a visual hint rather than a tabbable value.
+- 4f6b3c2: Set initial values of auto complete prompt to first option when multiple is false.
+- 8ead5d3: Avoid passing initial values to core when using auto complete prompt
+- acc4c3a: Add a new `withGuide` option to all prompts to disable the default clack border
+- 68dbf9b: select-key: Fixed wrapping and added new `caseSensitive` option
+- 2310b43: Allow custom writables as output stream.
+- d98e033: add invert selection for multiselect prompt
 
 ## 0.4.1
 

package/node_modules/@clack/core/README.md

@@ -11,7 +11,7 @@ import { TextPrompt, isCancel } from '@clack/core';
 
 const p = new TextPrompt({
   render() {
-    return `What's your name?\n${this.valueWithCursor}`;
+    return `What's your name?\n${this.userInputWithCursor}`;
   },
 });
 

package/node_modules/@clack/core/dist/index.d.mts

@@ -1,7 +1,29 @@
+import { Key } from 'node:readline';
 import { Readable, Writable } from 'node:stream';
 
 declare const actions: readonly ["up", "down", "left", "right", "space", "enter", "cancel"];
 type Action = (typeof actions)[number];
+/** Global settings for Clack programs, stored in memory */
+interface InternalClackSettings {
+    actions: Set<Action>;
+    aliases: Map<string, Action>;
+    messages: {
+        cancel: string;
+        error: string;
+    };
+    withGuide: boolean;
+    date: {
+        monthNames: string[];
+        messages: {
+            invalidMonth: string;
+            required: string;
+            invalidDay: (days: number, month: string) => string;
+            afterMin: (min: Date) => string;
+            beforeMax: (max: Date) => string;
+        };
+    };
+}
+declare const settings: InternalClackSettings;
 interface ClackSettings {
     /**
      * Set custom global aliases for the default actions.
@@ -10,7 +32,42 @@ interface ClackSettings {
      * @param aliases - An object that maps aliases to actions
      * @default { k: 'up', j: 'down', h: 'left', l: 'right', '\x03': 'cancel', 'escape': 'cancel' }
      */
-    aliases: Record<string, Action>;
+    aliases?: Record<string, Action>;
+    /**
+     * Custom messages for prompts
+     */
+    messages?: {
+        /**
+         * Custom message to display when a spinner is cancelled
+         * @default "Canceled"
+         */
+        cancel?: string;
+        /**
+         * Custom message to display when a spinner encounters an error
+         * @default "Something went wrong"
+         */
+        error?: string;
+    };
+    withGuide?: boolean;
+    /**
+     * Date prompt localization
+     */
+    date?: {
+        /** Month names for validation messages (January, February, ...) */
+        monthNames?: string[];
+        messages?: {
+            /** Shown when date is missing */
+            required?: string;
+            /** Shown when month > 12 */
+            invalidMonth?: string;
+            /** (days, monthName) => message for invalid day */
+            invalidDay?: (days: number, month: string) => string;
+            /** (min) => message when date is before minDate */
+            afterMin?: (min: Date) => string;
+            /** (max) => message when date is after maxDate */
+            beforeMax?: (max: Date) => string;
+        };
+    };
 }
 declare function updateSettings(updates: ClackSettings): void;
 
@@ -21,30 +78,32 @@ type ClackState = 'initial' | 'active' | 'cancel' | 'submit' | 'error';
 /**
  * Typed event emitter for clack
  */
-interface ClackEvents {
+interface ClackEvents<TValue> {
     initial: (value?: any) => void;
     active: (value?: any) => void;
     cancel: (value?: any) => void;
     submit: (value?: any) => void;
     error: (value?: any) => void;
     cursor: (key?: Action) => void;
-    key: (key?: string) => void;
-    value: (value?: string) => void;
+    key: (key: string | undefined, info: Key) => void;
+    value: (value?: TValue) => void;
+    userInput: (value: string) => void;
     confirm: (value?: boolean) => void;
     finalize: () => void;
+    beforePrompt: () => void;
 }
 
-interface PromptOptions<Self extends Prompt> {
+interface PromptOptions<TValue, Self extends Prompt<TValue>> {
     render(this: Omit<Self, 'prompt'>): string | undefined;
-    placeholder?: string;
     initialValue?: any;
-    validate?: ((value: any) => string | Error | undefined) | undefined;
+    initialUserInput?: string;
+    validate?: ((value: TValue | undefined) => string | Error | undefined) | undefined;
     input?: Readable;
     output?: Writable;
     debug?: boolean;
     signal?: AbortSignal;
 }
-declare class Prompt {
+declare class Prompt<TValue> {
     protected input: Readable;
     protected output: Writable;
     private _abortSignal?;
@@ -57,8 +116,9 @@ declare class Prompt {
     protected _cursor: number;
     state: ClackState;
     error: string;
-    value: any;
-    constructor(options: PromptOptions<Prompt>, trackValue?: boolean);
+    value: TValue | undefined;
+    userInput: string;
+    constructor(options: PromptOptions<TValue, Prompt<TValue>>, trackValue?: boolean);
     /**
      * Unsubscribe all listeners
      */
@@ -73,40 +133,111 @@ declare class Prompt {
      * @param event - The event name
      * @param cb - The callback
      */
-    on<T extends keyof ClackEvents>(event: T, cb: ClackEvents[T]): void;
+    on<T extends keyof ClackEvents<TValue>>(event: T, cb: ClackEvents<TValue>[T]): void;
     /**
      * Subscribe to an event once
      * @param event - The event name
      * @param cb - The callback
      */
-    once<T extends keyof ClackEvents>(event: T, cb: ClackEvents[T]): void;
+    once<T extends keyof ClackEvents<TValue>>(event: T, cb: ClackEvents<TValue>[T]): void;
     /**
      * Emit an event with data
      * @param event - The event name
      * @param data - The data to pass to the callback
      */
-    emit<T extends keyof ClackEvents>(event: T, ...data: Parameters<ClackEvents[T]>): void;
-    prompt(): Promise<string | symbol>;
+    emit<T extends keyof ClackEvents<TValue>>(event: T, ...data: Parameters<ClackEvents<TValue>[T]>): void;
+    prompt(): Promise<symbol | TValue | undefined>;
+    protected _isActionKey(char: string | undefined, _key: Key): boolean;
+    protected _setValue(value: TValue | undefined): void;
+    protected _setUserInput(value: string | undefined, write?: boolean): void;
+    protected _clearUserInput(): void;
     private onKeypress;
     protected close(): void;
     private restoreCursor;
     private render;
 }
 
-interface ConfirmOptions extends PromptOptions<ConfirmPrompt> {
+interface OptionLike$1 {
+    value: unknown;
+    label?: string;
+    disabled?: boolean;
+}
+type FilterFunction<T extends OptionLike$1> = (search: string, opt: T) => boolean;
+interface AutocompleteOptions<T extends OptionLike$1> extends PromptOptions<T['value'] | T['value'][], AutocompletePrompt<T>> {
+    options: T[] | ((this: AutocompletePrompt<T>) => T[]);
+    filter?: FilterFunction<T>;
+    multiple?: boolean;
+    /**
+     * When set (non-empty), pressing Tab with no input fills the field with this value
+     * and runs the normal filter/selection logic so the user can confirm with Enter.
+     * Tab only fills the input when the placeholder matches at least one option under
+     * the prompt's filter (so the value remains selectable).
+     */
+    placeholder?: string;
+}
+declare class AutocompletePrompt<T extends OptionLike$1> extends Prompt<T['value'] | T['value'][]> {
+    #private;
+    filteredOptions: T[];
+    multiple: boolean;
+    isNavigating: boolean;
+    selectedValues: Array<T['value']>;
+    focusedValue: T['value'] | undefined;
+    get cursor(): number;
+    get userInputWithCursor(): string;
+    get options(): T[];
+    constructor(opts: AutocompleteOptions<T>);
+    protected _isActionKey(char: string | undefined, key: Key): boolean;
+    deselectAll(): void;
+    toggleSelected(value: T['value']): void;
+}
+
+interface ConfirmOptions extends PromptOptions<boolean, ConfirmPrompt> {
     active: string;
     inactive: string;
     initialValue?: boolean;
 }
-declare class ConfirmPrompt extends Prompt {
+declare class ConfirmPrompt extends Prompt<boolean> {
     get cursor(): 0 | 1;
     private get _value();
     constructor(opts: ConfirmOptions);
 }
 
+interface SegmentConfig {
+    type: 'year' | 'month' | 'day';
+    len: number;
+}
+interface DateParts {
+    year: string;
+    month: string;
+    day: string;
+}
+type DateFormat = 'YMD' | 'MDY' | 'DMY';
+interface DateOptions extends PromptOptions<Date, DatePrompt> {
+    format?: DateFormat;
+    locale?: string;
+    separator?: string;
+    defaultValue?: Date;
+    initialValue?: Date;
+    minDate?: Date;
+    maxDate?: Date;
+}
+declare class DatePrompt extends Prompt<Date> {
+    #private;
+    inlineError: string;
+    get segmentCursor(): {
+        segmentIndex: number;
+        positionInSegment: number;
+    };
+    get segmentValues(): DateParts;
+    get segments(): readonly SegmentConfig[];
+    get separator(): string;
+    get formattedValue(): string;
+    constructor(opts: DateOptions);
+}
+
 interface GroupMultiSelectOptions<T extends {
     value: any;
-}> extends PromptOptions<GroupMultiSelectPrompt<T>> {
+}> extends PromptOptions<T['value'][], GroupMultiSelectPrompt<T>> {
     options: Record<string, T[]>;
     initialValues?: T['value'][];
     required?: boolean;
@@ -115,7 +246,7 @@ interface GroupMultiSelectOptions<T extends {
 }
 declare class GroupMultiSelectPrompt<T extends {
     value: any;
-}> extends Prompt {
+}> extends Prompt<T['value'][]> {
     #private;
     options: (T & {
         group: string | boolean;
@@ -127,85 +258,92 @@ declare class GroupMultiSelectPrompt<T extends {
     constructor(opts: GroupMultiSelectOptions<T>);
 }
 
-interface MultiSelectOptions<T extends {
+interface OptionLike {
     value: any;
-}> extends PromptOptions<MultiSelectPrompt<T>> {
+    disabled?: boolean;
+}
+interface MultiSelectOptions<T extends OptionLike> extends PromptOptions<T['value'][], MultiSelectPrompt<T>> {
     options: T[];
     initialValues?: T['value'][];
     required?: boolean;
     cursorAt?: T['value'];
 }
-declare class MultiSelectPrompt<T extends {
-    value: any;
-}> extends Prompt {
+declare class MultiSelectPrompt<T extends OptionLike> extends Prompt<T['value'][]> {
     options: T[];
     cursor: number;
     private get _value();
+    private get _enabledOptions();
     private toggleAll;
+    private toggleInvert;
     private toggleValue;
     constructor(opts: MultiSelectOptions<T>);
 }
 
-interface PasswordOptions extends PromptOptions<PasswordPrompt> {
+interface PasswordOptions extends PromptOptions<string, PasswordPrompt> {
     mask?: string;
 }
-declare class PasswordPrompt extends Prompt {
-    valueWithCursor: string;
+declare class PasswordPrompt extends Prompt<string> {
     private _mask;
     get cursor(): number;
-    get masked(): any;
+    get masked(): string;
+    get userInputWithCursor(): string;
+    clear(): void;
     constructor({ mask, ...opts }: PasswordOptions);
 }
 
 interface SelectOptions<T extends {
     value: any;
-}> extends PromptOptions<SelectPrompt<T>> {
+    disabled?: boolean;
+}> extends PromptOptions<T['value'], SelectPrompt<T>> {
     options: T[];
     initialValue?: T['value'];
 }
 declare class SelectPrompt<T extends {
     value: any;
-}> extends Prompt {
+    disabled?: boolean;
+}> extends Prompt<T['value']> {
     options: T[];
     cursor: number;
-    private get _value();
+    private get _selectedValue();
     private changeValue;
     constructor(opts: SelectOptions<T>);
 }
 
 interface SelectKeyOptions<T extends {
-    value: any;
-}> extends PromptOptions<SelectKeyPrompt<T>> {
+    value: string;
+}> extends PromptOptions<T['value'], SelectKeyPrompt<T>> {
     options: T[];
+    caseSensitive?: boolean;
 }
 declare class SelectKeyPrompt<T extends {
-    value: any;
-}> extends Prompt {
+    value: string;
+}> extends Prompt<T['value']> {
     options: T[];
     cursor: number;
     constructor(opts: SelectKeyOptions<T>);
 }
 
-interface TextOptions extends PromptOptions<TextPrompt> {
+interface TextOptions extends PromptOptions<string, TextPrompt> {
     placeholder?: string;
     defaultValue?: string;
 }
-declare class TextPrompt extends Prompt {
-    get valueWithCursor(): any;
+declare class TextPrompt extends Prompt<string> {
+    get userInputWithCursor(): string;
     get cursor(): number;
     constructor(opts: TextOptions);
 }
 
 declare function isCancel(value: unknown): value is symbol;
-declare function block({ input, output, overwrite, hideCursor, }?: {
-    input?: (NodeJS.ReadStream & {
-        fd: 0;
-    }) | undefined;
-    output?: (NodeJS.WriteStream & {
-        fd: 1;
-    }) | undefined;
-    overwrite?: boolean | undefined;
-    hideCursor?: boolean | undefined;
-}): () => void;
+interface BlockOptions {
+    input?: Readable;
+    output?: Writable;
+    overwrite?: boolean;
+    hideCursor?: boolean;
+}
+declare function block({ input, output, overwrite, hideCursor, }?: BlockOptions): () => void;
+declare const getColumns: (output: Writable) => number;
+declare const getRows: (output: Writable) => number;
+declare function wrapTextWithPrefix(output: Writable | undefined, text: string, prefix: string, startPrefix?: string): string;
 
-export { type ClackSettings, ConfirmPrompt, GroupMultiSelectPrompt, MultiSelectPrompt, PasswordPrompt, Prompt, SelectKeyPrompt, SelectPrompt, type ClackState as State, TextPrompt, block, isCancel, updateSettings };
+export { AutocompletePrompt, ConfirmPrompt, DatePrompt, GroupMultiSelectPrompt, MultiSelectPrompt, PasswordPrompt, Prompt, SelectKeyPrompt, SelectPrompt, TextPrompt, block, getColumns, getRows, isCancel, settings, updateSettings, wrapTextWithPrefix };
+export type { AutocompleteOptions, ClackSettings, ConfirmOptions, DateFormat, DateOptions, DateParts, GroupMultiSelectOptions, MultiSelectOptions, PasswordOptions, PromptOptions, SelectKeyOptions, SelectOptions, ClackState as State, TextOptions };