@shell-shock/plugin-prompts 0.3.51 → 0.3.53

package/dist/components/prompts-builtin.mjs

@@ -1,7 +1,6 @@
 import { createComponent, createIntrinsic, mergeProps } from "@alloy-js/core/jsx-runtime";
 import { Show, code, splitProps } from "@alloy-js/core";
 import { FunctionDeclaration, VarDeclaration } from "@alloy-js/typescript";
-import { ReflectionKind } from "@powerlines/deepkit/vendor/type";
 import { Spacing } from "@powerlines/plugin-alloy/core/components/spacing";
 import { BuiltinFile } from "@powerlines/plugin-alloy/typescript/components/builtin-file";
 import { ClassDeclaration, ClassField, ClassMethod, ClassPropertyGet } from "@powerlines/plugin-alloy/typescript/components/class-declaration";
@@ -88,7 +87,7 @@ function BasePromptDeclarations() {
 					createComponent(Spacing, {}),
 					createComponent(InterfaceMember, {
 						name: "errorMessage",
-						optional: true,
+						required: false,
 						type: "string",
 						doc: "If the prompt is in an error state, this will contain the error message to display"
 					}),
@@ -126,14 +125,14 @@ function BasePromptDeclarations() {
 				return [
 					createComponent(InterfaceMember, {
 						name: "input",
-						optional: true,
+						required: false,
 						type: "NodeJS.ReadStream",
 						doc: "The readable stream to use for prompt input, defaults to process.stdin"
 					}),
 					createComponent(Spacing, {}),
 					createComponent(InterfaceMember, {
 						name: "output",
-						optional: true,
+						required: false,
 						type: "NodeJS.WriteStream",
 						doc: "The writable stream to use for prompt output, defaults to process.stdout"
 					}),
@@ -146,63 +145,63 @@ function BasePromptDeclarations() {
 					createComponent(Spacing, {}),
 					createComponent(InterfaceMember, {
 						name: "description",
-						optional: true,
+						required: false,
 						type: "string",
 						doc: "The prompt description message to display"
 					}),
 					createComponent(Spacing, {}),
 					createComponent(InterfaceMember, {
 						name: "initialValue",
-						optional: true,
+						required: false,
 						type: "TValue",
 						doc: "The initial value of the prompt"
 					}),
 					createComponent(Spacing, {}),
 					createComponent(InterfaceMember, {
 						name: "validate",
-						optional: true,
+						required: false,
 						type: "(value: TValue) => boolean | string | null | undefined | Promise<boolean | string | null | undefined>",
 						doc: "A validation function that returns true if the input is valid, false or a string error message if the input is invalid"
 					}),
 					createComponent(Spacing, {}),
 					createComponent(InterfaceMember, {
 						name: "parse",
-						optional: true,
+						required: false,
 						type: "PromptParser<TValue>",
 						doc: "A function that parses the input value and returns the parsed result or throws an error if the input is invalid"
 					}),
 					createComponent(Spacing, {}),
 					createComponent(InterfaceMember, {
 						name: "format",
-						optional: true,
+						required: false,
 						type: "PromptFormatter<TValue>",
 						doc: "A function that formats the input value and returns the formatted result or throws an error if the input is invalid"
 					}),
 					createComponent(Spacing, {}),
 					createComponent(InterfaceMember, {
 						name: "mask",
-						optional: true,
+						required: false,
 						type: "(input: string) => string",
 						doc: "A function that masks the input value and returns the masked result. This can be used to create password inputs or other sensitive input types where the actual input value should not be displayed. If not provided, the prompt will display the input as is without masking."
 					}),
 					createComponent(Spacing, {}),
 					createComponent(InterfaceMember, {
 						name: "maskCompleted",
-						optional: true,
+						required: false,
 						type: "(input: string) => string",
 						doc: "A function that masks the value submitted by the user so that it can then be used in the console output or elsewhere without exposing sensitive information. If not provided, the prompt will use the same mask function for both input and submitted value masking."
 					}),
 					createComponent(Spacing, {}),
 					createComponent(InterfaceMember, {
 						name: "defaultErrorMessage",
-						optional: true,
+						required: false,
 						type: "string",
 						doc: "The default error message to display when validation fails"
 					}),
 					createComponent(Spacing, {}),
 					createComponent(InterfaceMember, {
 						name: "timeout",
-						optional: true,
+						required: false,
 						type: "number",
 						doc: "The timeout duration in milliseconds for the prompt. If none is provided, the prompt will not time out."
 					})
@@ -230,8 +229,7 @@ function BasePromptDeclarations() {
 					createComponent(ClassField, {
 						name: "value",
 						isPrivateMember: true,
-						optional: true,
-						type: "TValue"
+						type: "TValue | undefined"
 					}),
 					createIntrinsic("hbr", {}),
 					createComponent(ClassField, {
@@ -913,21 +911,21 @@ function BasePromptDeclarations() {
 				return [
 					createComponent(InterfaceMember, {
 						name: "onState",
-						optional: true,
+						required: false,
 						type: "(state: PromptState<TValue>) => any",
 						doc: "A function that is called when the prompt state changes, useful for updating the prompt message or other properties dynamically"
 					}),
 					createComponent(Spacing, {}),
 					createComponent(InterfaceMember, {
 						name: "onSubmit",
-						optional: true,
+						required: false,
 						type: "(value: TValue) => any",
 						doc: "A function that is called when the prompt is submitted, useful for handling the submitted value or performing actions based on the prompt state"
 					}),
 					createComponent(Spacing, {}),
 					createComponent(InterfaceMember, {
 						name: "onCancel",
-						optional: true,
+						required: false,
 						type: "(event: any) => any",
 						doc: "A function that is called when the prompt is canceled, useful for handling the canceled value or performing actions based on the prompt state"
 					})
@@ -976,14 +974,14 @@ function TextPromptDeclarations() {
 				return [
 					createComponent(InterfaceMember, {
 						name: "initialValue",
-						optional: true,
+						required: false,
 						type: "string",
 						doc: "The initial value of the prompt"
 					}),
 					createComponent(Spacing, {}),
 					createComponent(InterfaceMember, {
 						name: "mask",
-						optional: true,
+						required: false,
 						type: "(input: string) => string",
 						doc: "A function that masks the input value and returns the masked result"
 					})
@@ -1230,15 +1228,15 @@ function SelectPromptDeclarations() {
 				return [
 					createComponent(InterfaceMember, {
 						name: "label",
-						optional: true,
-						type: "string",
+						schema: { type: "string" },
+						required: false,
 						doc: "The message label for the option"
 					}),
 					createComponent(Spacing, {}),
 					createComponent(InterfaceMember, {
 						name: "icon",
-						optional: true,
-						type: "string",
+						schema: { type: "string" },
+						required: false,
 						doc: "An icon for the option"
 					}),
 					createComponent(Spacing, {}),
@@ -1250,22 +1248,22 @@ function SelectPromptDeclarations() {
 					createComponent(Spacing, {}),
 					createComponent(InterfaceMember, {
 						name: "description",
-						optional: true,
-						type: "string",
+						schema: { type: "string" },
+						required: false,
 						doc: "The description of the option"
 					}),
 					createComponent(Spacing, {}),
 					createComponent(InterfaceMember, {
 						name: "selected",
-						optional: true,
-						type: "boolean",
+						schema: { type: "boolean" },
+						required: false,
 						doc: "Whether the option is selected"
 					}),
 					createComponent(Spacing, {}),
 					createComponent(InterfaceMember, {
 						name: "disabled",
-						optional: true,
-						type: "boolean",
+						schema: { type: "boolean" },
+						required: false,
 						doc: "Whether the option is disabled"
 					})
 				];
@@ -1321,7 +1319,7 @@ function SelectPromptDeclarations() {
 				return [
 					createComponent(InterfaceMember, {
 						name: "hint",
-						optional: true,
+						required: false,
 						type: "string",
 						doc: "A hint to display to the user"
 					}),
@@ -1334,7 +1332,7 @@ function SelectPromptDeclarations() {
 					createComponent(Spacing, {}),
 					createComponent(InterfaceMember, {
 						name: "optionsPerPage",
-						optional: true,
+						required: false,
 						type: "number",
 						doc: "The number of options to display per page, defaults to 8"
 					})
@@ -1680,6 +1678,416 @@ run(); ` }),
 	];
 }
 /**
+* Declarations for a multi-select prompt that allows users to choose multiple options from a list, with support for disabled options, bulk selection shortcuts, and required validation. This prompt type is useful for scenarios where users need to select one or more values from a predefined set.
+*/
+function MultiSelectPromptDeclarations() {
+	return [
+		createComponent(InterfaceDeclaration, {
+			name: "MultiSelectPromptConfig",
+			"extends": "PromptConfig<TValue[]>",
+			doc: "An options object for configuring a multi-select prompt",
+			typeParameters: [{
+				name: "TValue",
+				default: "string"
+			}],
+			get children() {
+				return [
+					createComponent(InterfaceMember, {
+						name: "options",
+						type: "Array<string | PromptOptionConfig<TValue>>",
+						doc: "The options available for the multi-select prompt"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "required",
+						required: false,
+						type: "boolean",
+						doc: "Whether at least one option must be selected, defaults to true"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "initialValue",
+						required: false,
+						type: "TValue[]",
+						doc: "The initial selected values"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "cursorAt",
+						required: false,
+						type: "TValue",
+						doc: "A value indicating which option should be focused initially"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "optionsPerPage",
+						required: false,
+						type: "number",
+						doc: "The number of options to display per page, defaults to 8"
+					})
+				];
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(ClassDeclaration, {
+			name: "MultiSelectPrompt",
+			doc: "A prompt for selecting multiple options from a list",
+			"extends": "Prompt<TValue[]>",
+			typeParameters: [{
+				name: "TValue",
+				default: "string"
+			}],
+			get children() {
+				return [
+					createComponent(ClassField, {
+						name: "initialValue",
+						"protected": true,
+						override: true,
+						type: "TValue[]",
+						children: code`[]; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "required",
+						"protected": true,
+						type: "boolean",
+						children: code`true; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "optionsPerPage",
+						"protected": true,
+						type: "number",
+						children: code`8; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "options",
+						"protected": true,
+						type: "PromptOption<TValue>[]",
+						children: code`[]; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "cursorHidden",
+						"protected": true,
+						override: true,
+						type: "boolean",
+						children: code`true; `
+					}),
+					createComponent(Spacing, {}),
+					code`constructor(config: MultiSelectPromptConfig<TValue>) {
+          super(config);
+
+          this.required = config.required ?? true;
+          this.initialValue = Array.isArray(config.initialValue) ? [...config.initialValue] : [];
+
+          if (config.optionsPerPage) {
+            this.optionsPerPage = config.optionsPerPage;
+          }
+
+          this.options = config.options.map((opt, index) => {
+            let option = {} as Partial<PromptOption<TValue>>;
+            if (typeof opt === "string") {
+              option = {
+                label: opt,
+                value: opt as TValue,
+                selected: this.initialValue.includes(opt as TValue),
+                disabled: false
+              };
+            } else if (typeof opt === "object" && opt !== null) {
+              option = {
+                ...opt,
+                selected: this.initialValue.includes(opt.value as TValue) || !!opt.selected
+              };
+            } else {
+              throw new Error("Invalid option provided to MultiSelectPrompt at index #" + index);
+            }
+
+            return {
+              label: option.label || String(option.value),
+              ...option,
+              description: option.description,
+              selected: !!option.selected,
+              disabled: !!option.disabled,
+              index
+            } as PromptOption<TValue>;
+          });
+
+          if (config.cursorAt !== undefined) {
+            const index = this.options.findIndex(option => option.value === config.cursorAt);
+            if (index > -1) {
+              this.cursor = index;
+            }
+          }
+
+          if (this.options[this.cursor]?.disabled) {
+            this.moveCursor(this.findNextEnabled(this.cursor, 1));
+          } else {
+            this.changeValue(this.getSelectedValues());
+          }
+
+          this.sync();
+        }
+
+        protected getAction(key: Key): string | false {
+          let action = super.getAction(key);
+          if (!action) {
+            if (key.name === "j") action = "down";
+            if (key.name === "k") action = "up";
+            if (key.name === "a") action = "toggleAll";
+            if (key.name === "i") action = "toggleInvert";
+            if (key.name === "space") action = "toggleCurrent";
+          }
+
+          return action || false;
+        }
+
+        protected override async submit() {
+          const selectedValues = this.getSelectedValues();
+          if (this.required && selectedValues.length === 0) {
+            this.error(
+              "Please select at least one option. Press <space> to toggle and <enter> to submit."
+            );
+            this.bell();
+            return;
+          }
+
+          this.changeValue(selectedValues);
+          await super.submit();
+        }
+
+        protected toggleCurrent() {
+          const option = this.options[this.cursor];
+          if (!option || option.disabled) {
+            this.bell();
+            return;
+          }
+
+          option.selected = !option.selected;
+          this.changeValue(this.getSelectedValues());
+          this.sync();
+        }
+
+        protected toggleAll() {
+          const enabled = this.options.filter(option => !option.disabled);
+          const areAllSelected = enabled.every(option => option.selected);
+          for (const option of enabled) {
+            option.selected = !areAllSelected;
+          }
+
+          this.changeValue(this.getSelectedValues());
+          this.sync();
+        }
+
+        protected toggleInvert() {
+          for (const option of this.options) {
+            if (!option.disabled) {
+              option.selected = !option.selected;
+            }
+          }
+
+          this.changeValue(this.getSelectedValues());
+          this.sync();
+        }
+
+        protected findNextEnabled(from: number, direction: 1 | -1): number {
+          if (this.options.length === 0) {
+            return 0;
+          }
+
+          let index = from;
+          for (let i = 0; i < this.options.length; i++) {
+            index = (index + direction + this.options.length) % this.options.length;
+            if (!this.options[index]?.disabled) {
+              return index;
+            }
+          }
+
+          return from;
+        }
+
+        protected getSelectedValues(): TValue[] {
+          return this.options
+            .filter(option => option.selected)
+            .map(option => option.value as TValue);
+        }
+
+        protected next() {
+          this.moveCursor(this.findNextEnabled(this.cursor, 1));
+          this.sync();
+        }
+
+        protected up() {
+          this.moveCursor(this.findNextEnabled(this.cursor, -1));
+          this.sync();
+        }
+
+        protected down() {
+          this.moveCursor(this.findNextEnabled(this.cursor, 1));
+          this.sync();
+        }
+
+        protected first() {
+          this.moveCursor(this.findNextEnabled(0, 1));
+          this.sync();
+        }
+
+        protected last() {
+          this.moveCursor(this.findNextEnabled(this.options.length - 1, -1));
+          this.sync();
+        }
+
+        protected override moveCursor(count: number) {
+          this.cursor = count;
+          this.changeValue(this.getSelectedValues());
+          this.sync();
+        }
+
+        protected override onRender() {
+          const spacing = Math.max(...this.options.map(option => option.label?.length || 0), 0) + 2;
+          const startIndex = Math.max(
+            Math.min(
+              this.options.length - this.optionsPerPage,
+              this.cursor - Math.floor(this.optionsPerPage / 2)
+            ),
+            0
+          );
+          const endIndex = Math.min(startIndex + this.optionsPerPage, this.options.length);
+
+          let output = "";
+          if (!this.isCompleted) {
+            output += " \\\n";
+
+            for (let index = startIndex; index < endIndex; index++) {
+              const option = this.options[index]!;
+              const active = this.cursor === index;
+              const selected = !!option.selected;
+              const disabled = !!option.disabled;
+
+              const pointer = disabled
+                ? active
+                  ? bold(textColors.prompt.input.disabled(">"))
+                  : index === startIndex
+                    ? borderColors.app.divider.tertiary("↑")
+                    : index === endIndex - 1
+                      ? borderColors.app.divider.tertiary("↓")
+                      : " "
+                : active
+                  ? bold(textColors.prompt.input.active(">"))
+                  : index === startIndex
+                    ? borderColors.app.divider.tertiary("↑")
+                    : index === endIndex - 1
+                      ? borderColors.app.divider.tertiary("↓")
+                      : " ";
+
+              const marker = isUnicodeSupported ? (selected ? "🗹" : "☐") : (selected ? "[x]" : "[ ]");
+              const markerText = disabled
+                ? active
+                  ? bold(textColors.prompt.input.disabled(marker))
+                  : textColors.prompt.input.disabled(marker)
+                : active
+                  ? bold(textColors.prompt.input.active(marker))
+                  : textColors.prompt.input.inactive(marker);
+
+              const labelText = disabled
+                ? active
+                  ? bold(underline(textColors.prompt.input.disabled(option.label)))
+                  : strikethrough(textColors.prompt.input.disabled(option.label))
+                : active
+                  ? bold(underline(textColors.prompt.input.active(option.label)))
+                  : selected
+                    ? textColors.prompt.input.active(option.label)
+                    : textColors.prompt.input.inactive(option.label);
+
+              output +=
+                pointer +
+                " " +
+                markerText +
+                " " +
+                labelText +
+                " " +
+                " ".repeat(Math.max(0, spacing - option.label.length)) +
+                (option.description && active
+                  ? italic(textColors.prompt.description.active(option.description))
+                  : "") +
+                " \\\n";
+            }
+          } else {
+            const selected = this.options.filter(option => option.selected);
+            this.displayValue =
+              selected.length > 0
+                ? selected.map(option => option.label).join(", ")
+                : "(none)";
+            output += super.onRender();
+          }
+
+          return output;
+        }`
+				];
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(TSDoc, { heading: "A type definition for the configuration options to pass to the multi-select prompt, which extends the base PromptConfig with additional options specific to multi-select prompts." }),
+		createComponent(TypeDeclaration, {
+			"export": true,
+			name: "MultiSelectConfig",
+			children: code`PromptFactoryConfig<string[]> & MultiSelectPromptConfig; `
+		}),
+		createComponent(Spacing, {}),
+		createComponent(TSDoc, {
+			heading: "A function to create and run a multi-select prompt, which returns a promise that resolves with the submitted values or a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled.",
+			get children() {
+				return [
+					createComponent(TSDocExample, { children: `import { multiselect, isCancel } from "shell-shock:prompts";
+
+async function run() {
+  const tools = await multiselect({
+    message: "Select tools",
+    options: [
+      { value: "eslint", label: "ESLint" },
+      { value: "prettier", label: "Prettier" },
+      { value: "vitest", label: "Vitest", disabled: true }
+    ]
+  });
+
+  if (isCancel(tools)) {
+    console.log("Prompt was cancelled");
+    return;
+  }
+
+  console.log("Selected tools:", tools.join(", "));
+}
+
+run(); ` }),
+					createComponent(Spacing, {}),
+					createComponent(TSDocParam, {
+						name: "config",
+						children: `The configuration options to pass to the multi-select prompt`
+					}),
+					createComponent(TSDocReturns, { children: `A promise that resolves with the selected values or a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled` })
+				];
+			}
+		}),
+		createComponent(FunctionDeclaration, {
+			name: "multiselect",
+			"export": true,
+			parameters: [{
+				name: "config",
+				type: "MultiSelectConfig"
+			}],
+			returnType: "Promise<string[] | symbol>",
+			children: code`return new Promise<string[] | symbol>((response, reject) => {
+            const prompt = new MultiSelectPrompt(config);
+
+            prompt.on("state", state => config.onState?.(state));
+            prompt.on("submit", value => response(value));
+            prompt.on("cancel", event => response(CANCEL_SYMBOL));
+          });`
+		})
+	];
+}
+/**
 * A component that renders the declarations for the built-in numeric prompt, which allows users to input and select numeric values with various configuration options such as floating point support, precision, increment, and min/max values.
 */
 function NumericPromptDeclarations() {
@@ -1692,35 +2100,35 @@ function NumericPromptDeclarations() {
 				return [
 					createComponent(InterfaceMember, {
 						name: "isFloat",
-						optional: true,
+						required: false,
 						type: "boolean",
 						doc: "Whether the prompt should accept floating point numbers"
 					}),
 					createComponent(Spacing, {}),
 					createComponent(InterfaceMember, {
 						name: "precision",
-						optional: true,
+						required: false,
 						type: "number",
 						doc: "The number of decimal places to round the input to, defaults to 2"
 					}),
 					createComponent(Spacing, {}),
 					createComponent(InterfaceMember, {
 						name: "increment",
-						optional: true,
+						required: false,
 						type: "number",
 						doc: "The increment value for the number prompt, defaults to 1"
 					}),
 					createComponent(Spacing, {}),
 					createComponent(InterfaceMember, {
 						name: "min",
-						optional: true,
+						required: false,
 						type: "number",
 						doc: "The minimum value for the number prompt, defaults to -Infinity"
 					}),
 					createComponent(Spacing, {}),
 					createComponent(InterfaceMember, {
 						name: "max",
-						optional: true,
+						required: false,
 						type: "number",
 						doc: "The maximum value for the number prompt, defaults to Infinity"
 					})
@@ -2070,14 +2478,14 @@ function TogglePromptDeclarations() {
 				return [
 					createComponent(InterfaceMember, {
 						name: "trueMessage",
-						optional: true,
+						required: false,
 						type: "string",
 						doc: "The message for the true state of the prompt"
 					}),
 					createComponent(Spacing, {}),
 					createComponent(InterfaceMember, {
 						name: "falseMessage",
-						optional: true,
+						required: false,
 						type: "string",
 						doc: "The message for the false state of the prompt"
 					}),
@@ -2326,16 +2734,14 @@ function ConfirmPromptDeclarations() {
 						heading: "The message for the \\`Yes\\` state of the prompt",
 						get children() {
 							return createComponent(TSDocDefaultValue, {
-								get type() {
-									return ReflectionKind.string;
-								},
+								type: "string",
 								defaultValue: "Yes"
 							});
 						}
 					}),
 					createComponent(InterfaceMember, {
 						name: "yesMessage",
-						optional: true,
+						required: false,
 						type: "string"
 					}),
 					createComponent(Spacing, {}),
@@ -2343,16 +2749,14 @@ function ConfirmPromptDeclarations() {
 						heading: "The \\`Yes\\` option when choosing between yes/no",
 						get children() {
 							return createComponent(TSDocDefaultValue, {
-								get type() {
-									return ReflectionKind.string;
-								},
+								type: "string",
 								defaultValue: "1"
 							});
 						}
 					}),
 					createComponent(InterfaceMember, {
 						name: "yesOption",
-						optional: true,
+						required: false,
 						type: "string"
 					}),
 					createComponent(Spacing, {}),
@@ -2360,16 +2764,14 @@ function ConfirmPromptDeclarations() {
 						heading: "The message for the \\`No\\` state of the prompt",
 						get children() {
 							return createComponent(TSDocDefaultValue, {
-								get type() {
-									return ReflectionKind.string;
-								},
+								type: "string",
 								defaultValue: "(Y/n)"
 							});
 						}
 					}),
 					createComponent(InterfaceMember, {
 						name: "noMessage",
-						optional: true,
+						required: false,
 						type: "string"
 					}),
 					createComponent(Spacing, {}),
@@ -2377,16 +2779,14 @@ function ConfirmPromptDeclarations() {
 						heading: "The \\`No\\` option when choosing between yes/no",
 						get children() {
 							return createComponent(TSDocDefaultValue, {
-								get type() {
-									return ReflectionKind.string;
-								},
+								type: "string",
 								defaultValue: "(y/N)"
 							});
 						}
 					}),
 					createComponent(InterfaceMember, {
 						name: "noOption",
-						optional: true,
+						required: false,
 						type: "string"
 					})
 				];
@@ -2715,6 +3115,7 @@ function PromptsBuiltin(props) {
 					"splitText",
 					"error"
 				],
+				utils: ["isUnicodeSupported"],
 				env: [
 					"env",
 					"isCI",
@@ -2734,6 +3135,8 @@ function PromptsBuiltin(props) {
 				createComponent(Spacing, {}),
 				createComponent(SelectPromptDeclarations, {}),
 				createComponent(Spacing, {}),
+				createComponent(MultiSelectPromptDeclarations, {}),
+				createComponent(Spacing, {}),
 				createComponent(NumericPromptDeclarations, {}),
 				createComponent(Spacing, {}),
 				createComponent(TogglePromptDeclarations, {}),
@@ -2756,5 +3159,5 @@ function PromptsBuiltin(props) {
 }
 
 //#endregion
-export { BasePromptDeclarations, ConfirmPromptDeclarations, NumericPromptDeclarations, PasswordPromptDeclaration, PromptsBuiltin, SelectPromptDeclarations, TextPromptDeclarations, TogglePromptDeclarations, WaitForKeyPressDeclaration };
+export { BasePromptDeclarations, ConfirmPromptDeclarations, MultiSelectPromptDeclarations, NumericPromptDeclarations, PasswordPromptDeclaration, PromptsBuiltin, SelectPromptDeclarations, TextPromptDeclarations, TogglePromptDeclarations, WaitForKeyPressDeclaration };
 //# sourceMappingURL=prompts-builtin.mjs.map