fix(inquirer): Allow Partial<*> types as prefilled answers (#1889)

Fixes #1888

Author: SBoudrias

packages/inquirer/inquirer.test.ts

@@ -846,6 +846,120 @@ describe('inquirer.prompt(...)', () => {
       expectTypeOf(answers.prefilled).toEqualTypeOf<{ nested: string }>();
       expectTypeOf(answers.prefilled).not.toBeAny();
     });
+
+    describe('Partial<T> prefilled answers (issue #1888)', () => {
+      it('should accept Partial-like objects and strip undefined from types', async () => {
+        // Use a partial object without explicit Partial<T> type annotation
+        const partial = {
+          displayName: 'Custom Widget',
+          technology: 'vue',
+        };
+
+        const result = await inquirer.prompt(
+          [
+            {
+              name: 'displayName',
+              type: 'stub',
+              message: 'Widget Display Name',
+              answer: 'My Widget',
+            },
+            {
+              name: 'technology',
+              type: 'stub',
+              message: 'Technology',
+              answer: 'react',
+            },
+            {
+              name: 'iconUrl',
+              type: 'stub',
+              message: 'Icon URL',
+              answer: 'https://example.com/icon.png',
+            },
+          ],
+          partial,
+        );
+
+        // Runtime behavior: prefilled values are used
+        expect(result.displayName).toEqual('Custom Widget');
+        expect(result.technology).toEqual('vue');
+        expect(result.iconUrl).toEqual('https://example.com/icon.png');
+
+        // Type checks: result properties are string, not string | undefined
+        expectTypeOf(result.displayName).toEqualTypeOf<string>();
+        expectTypeOf(result.technology).toEqualTypeOf<string>();
+        expectTypeOf(result).not.toBeAny();
+      });
+
+      it('should handle prefilled answers with some fields undefined', async () => {
+        const partial = {
+          field1: 'value1',
+          field2: undefined as string | undefined,
+        };
+
+        const result = await inquirer.prompt(
+          [
+            {
+              name: 'field1',
+              type: 'stub',
+              message: 'Field 1',
+              answer: 'default1',
+            },
+            {
+              name: 'field2',
+              type: 'stub',
+              message: 'Field 2',
+              answer: 'default2',
+            },
+          ],
+          partial,
+        );
+
+        // field1 should be prefilled, field2 should be prompted
+        expect(result.field1).toEqual('value1');
+        expect(result.field2).toEqual('default2');
+        expectTypeOf(result.field1).toEqualTypeOf<string>();
+        expectTypeOf(result.field2).toEqualTypeOf<string>();
+        expectTypeOf(result).not.toBeAny();
+      });
+
+      it('should handle multiple prefilled fields of same type', async () => {
+        const partial = {
+          name: 'Custom Name',
+          description: 'Custom Description',
+        };
+
+        const result = await inquirer.prompt(
+          [
+            {
+              name: 'name',
+              type: 'stub',
+              message: 'Name',
+              answer: 'Default Name',
+            },
+            {
+              name: 'description',
+              type: 'stub',
+              message: 'Description',
+              answer: 'Default Description',
+            },
+            {
+              name: 'email',
+              type: 'stub',
+              message: 'Email',
+              answer: 'default@example.com',
+            },
+          ],
+          partial,
+        );
+
+        expect(result.name).toEqual('Custom Name');
+        expect(result.description).toEqual('Custom Description');
+        expect(result.email).toEqual('default@example.com');
+        expectTypeOf(result.name).toEqualTypeOf<string>();
+        expectTypeOf(result.description).toEqualTypeOf<string>();
+        expectTypeOf(result).not.toBeAny();
+      });
+    });
   });
 
   describe('#registerPrompt()', () => {

packages/inquirer/src/index.ts

@@ -121,6 +121,10 @@ export function createPromptModule<
     questions: QuestionsDictionary<A, PrefilledAnswers, Prompts>,
     answers?: PrefilledAnswers,
   ): PromptReturnType<DictionaryAnswers<A, PrefilledAnswers>>;
+  function promptModule<A extends Answers>(
+    questions: PromptSession<A>,
+    answers?: Partial<A>,
+  ): PromptReturnType<A>;
   function promptModule<A extends Answers>(
     questions: PromptSession<A>,
     answers?: Partial<A>,

packages/inquirer/src/types.ts

@@ -69,7 +69,13 @@ type WidenAnswerLiterals<T> = T extends string
             : T extends Array<infer U>
               ? Array<WidenAnswerLiterals<U>>
               : T extends Record<string, unknown>
-                ? { [K in keyof Mutable<T>]: WidenAnswerLiterals<Mutable<T>[K]> }
+                ? {
+                    [K in keyof Mutable<T>]: Mutable<T>[K] extends infer V
+                      ? V extends undefined
+                        ? never
+                        : WidenAnswerLiterals<V>
+                      : never;
+                  }
                 : T;
 
 type MergeAnswerObjects<Base, Override> = Prettify<Omit<Base, keyof Override> & Override>;