fix: downcast utility type (#75)

Author: eegli

.changeset/itchy-avocados-leave.md

@@ -0,0 +1,5 @@
+---
+"@eegli/tinyparse": patch
+---
+
+Fix downcast utility type to default to `string[]`

src/commands.ts

@@ -4,7 +4,7 @@ import {
   AnyGlobal,
   CommandArgPattern,
   DefaultHandler,
-  Downcast,
+  DowncastFlag,
   ErrorHandler,
   FlagOptions,
   FlagValue,
@@ -74,7 +74,7 @@ export class CommandBuilder<
 
     // TODO: Figure out how to make this typecheck properly
     return this as unknown as CommandBuilder<
-      Options & Record<K, Downcast<V>>,
+      Options & Record<K, DowncastFlag<V>>,
       Globals
     >;
   }

src/types.ts

@@ -16,7 +16,7 @@ export type FlagValue = string | number | boolean | Date;
 export type FlagOptions<V extends FlagValue = FlagValue> = {
   longFlag: LongFlag;
   shortFlag?: ShortFlag;
-  defaultValue: Downcast<V>;
+  defaultValue: DowncastFlag<V>;
   required?: boolean;
   description?: string;
 };
@@ -63,8 +63,10 @@ export type Subcommand<Options, Globals, Args> = {
   args: Args;
   description?: string;
   handler: Args extends string[]
-    ? GenericHandler<Options, Globals, Downcast<Args>>
-    : GenericHandler<Options, Globals, string[]>;
+    ? // Strict type annotation
+      GenericHandler<Options, Globals, DowncastArgs<Args>>
+    : // Loose type annotation
+      GenericHandler<Options, Globals, string[]>;
 };
 
 /**
@@ -149,20 +151,14 @@ type RemoveNever<T> = {
   [K in keyof T as T[K] extends never ? never : K]: T[K];
 };
 
-export type Downcast<T> = T extends unknown[]
-  ? {
-      [P in keyof T]: T[P] extends number
-        ? number
-        : T[P] extends string
-          ? string
-          : T[P] extends boolean
-            ? boolean
-            : T[P];
-    }
+export type DowncastArgs<T extends string[]> = {
+  [P in keyof T]: string;
+};
+
+export type DowncastFlag<T extends FlagValue> = T extends string
+  ? string
   : T extends number
     ? number
-    : T extends string
-      ? string
-      : T extends boolean
-        ? boolean
-        : T;
+    : T extends boolean
+      ? boolean
+      : T;

test/types/index.tst.ts

@@ -28,6 +28,7 @@ describe('subcommand option and global arguments', () => {
     })
     .setGlobals(() => ({
       database: 'db',
+      fetch: () => {},
     })).subcommand;
 
   type HandlerParams = Parameters<
@@ -37,6 +38,12 @@ describe('subcommand option and global arguments', () => {
   type HandlerGlobalParams = HandlerParams['globals'];
 
   test('flags are inferred', () => {
+    expect<HandlerFlagParams>().type.toBeAssignable<{
+      foo: string;
+      bar: number;
+      baz: boolean;
+      qux: Date;
+    }>();
     expect<HandlerFlagParams>().type.toMatch<{
       foo: string;
       bar: number;
@@ -45,8 +52,13 @@ describe('subcommand option and global arguments', () => {
     }>();
   });
   test('globals are inferred', () => {
+    expect<HandlerGlobalParams>().type.toBeAssignable<{
+      database: string;
+      fetch: () => void;
+    }>();
     expect<HandlerGlobalParams>().type.toMatch<{
       database: string;
+      fetch: () => void;
     }>();
   });
 });

test/types/utils.tst.ts

@@ -0,0 +1,15 @@
+import { describe, expect, test } from 'tstyche';
+import { DowncastArgs, DowncastFlag } from '../../src/types';
+
+describe('type utils', () => {
+  test('downcast args', () => {
+    expect<DowncastArgs<string[]>>().type.toEqual<string[]>();
+    expect<DowncastArgs<['a', 'b']>>().type.toEqual<[string, string]>();
+  });
+  test('downcast flag', () => {
+    expect<DowncastFlag<1>>().type.toEqual<number>();
+    expect<DowncastFlag<'as'>>().type.toEqual<string>();
+    expect<DowncastFlag<true>>().type.toEqual<boolean>();
+    expect<DowncastFlag<Date>>().type.toEqual<Date>();
+  });
+});