feat: support array-type

README.md

@@ -36,6 +36,13 @@ const parsed = typeFlag(process.argv.slice(2), {
  someBoolean: {
  type: Boolean,
  alias: 'b'
+ },
+
+ // Wrap with an array to indicate an array type
+ stringArray: [String],
+
+ numberArray: {
+ type: [Number]
  }
 })
 
@@ -46,9 +53,11 @@ console.log(parsed.flags.someString[0])
 ```ts
 {
  flags: {
- someString: string[];
- someNumber: boolean[];
- someBoolean: number[];
+ someString: string | undefined;
+ someNumber: boolean | undefined;
+ someBoolean: number | undefined;
+ stringArray: string[];
+ numberArray: number[];
  };
  unknownFlags: {
  [flagName: string]: (string | boolean)[];
@@ -142,7 +151,7 @@ const parsed = typeFlag(process.argv.slice(2), {
 ```ts
 const parsed: {
  flags: {
- size: Sizes[];
+ size: Sizes | undefined;
  };
  ...
 }
@@ -182,7 +191,7 @@ function EnvObject(value: string): Env {
 }
 
 const parsed = typeFlag(process.argv.slice(2), {
- env: EnvObject,
+ env: [EnvObject],
 });
 
 const env = parsed.flags.env.reduce((agg, next) => Object.assign(agg, next), {});
@@ -206,7 +215,7 @@ $ node ./cli --boolean-flag false
 ```ts
 {
  flags: {
- booleanFlag: [true]
+ booleanFlag: true
  },
  _: ['false']
 }
@@ -220,7 +229,7 @@ Returns an object with the shape:
 ```ts
 {
  flags: {
- [flagName: string]: InferredType[];
+ [flagName: string]: InferredType;
  };
  unknownFlags: {
  [flagName: string]: (string | boolean)[];
@@ -241,8 +250,8 @@ Type:
 type TypeFunction = (argvValue: any) => any;
 
 type FlagSchema = {
- [flagName: string]: TypeFunction | {
- type?: TypeFunction; // defaults to String
+ [flagName: string]: TypeFunction | [TypeFunction] | {
+ type: TypeFunction | [TypeFunction];
  alias?: string;
  };
 };

examples/dot-nested.ts

@@ -20,7 +20,7 @@ function EnvironmentObject(value: string): Environment {
 }
 
 const parsed = typeFlag(process.argv.slice(2), {
- env: EnvironmentObject,
+ env: [EnvironmentObject],
 });
 
 // eslint-disable-next-line unicorn/no-array-reduce,unicorn/prefer-object-from-entries

src/index.ts

@@ -1,54 +1,69 @@
 import type {
  TypeFunction,
- FlagSchema,
  Flags,
- ParsedFlags,
+ FlagTypeOrSchema,
 } from './types';
 import {
  toCamelCase,
  createFlagsObject,
  mapAliases,
  parseFlag,
  getDefaultFromTypeWithValue,
- isFlagSchemaWithType,
 } from './utils';
 
 const isAliasPattern = /^-[\da-z]+/i;
 const isFlagPattern = /^--[\w-]{2,}/;
 
+const getFlagType = (
+ flagSchema: FlagTypeOrSchema,
+): TypeFunction => {
+ if (typeof flagSchema === 'function') {
+ return flagSchema;
+ }
+
+ if (Array.isArray(flagSchema)) {
+ return flagSchema[0];
+ }
+
+ return getFlagType(flagSchema.type);
+};
+
 function typeFlag<Schemas extends Flags>(
  argv: string[],
  schemas: Schemas,
 ) {
  const aliasesMap = mapAliases(schemas);
  const flags = createFlagsObject<Schemas>(schemas);
- const unknownFlags: ParsedFlags = {};
+ const unknownFlags: {
+ [flag: string]: (string | boolean)[];
+ } = {};
  const remainingArguments: string[] = [];
 
  let expectingValue: undefined | ((value?: string | boolean) => void);
 
  const setKnown = (
- flagName: string,
- flagSchema: TypeFunction | FlagSchema,
+ flagName: keyof Schemas,
+ flagSchema: FlagTypeOrSchema,
  flagValue: any,
  ) => {
- const flagType = (
- typeof flagSchema === 'function'
- ? flagSchema
- : (
- isFlagSchemaWithType(flagSchema)
- ? flagSchema.type
- : String
- )
- );
+ const flagType = getFlagType(flagSchema);
 
  flagValue = getDefaultFromTypeWithValue(flagType, flagValue);
 
  if (flagValue !== undefined && !Number.isNaN(flagValue)) {
- flags[flagName].push(flagType(flagValue));
+ if (Array.isArray(flags[flagName])) {
+ flags[flagName].push(flagType(flagValue));
+ } else {
+ flags[flagName] = flagType(flagValue);
+ }
  } else {
  expectingValue = (value) => {
- flags[flagName].push(flagType(getDefaultFromTypeWithValue(flagType, value || '')));
+ if (Array.isArray(flags[flagName])) {
+ flags[flagName].push(flagType(getDefaultFromTypeWithValue(flagType, value || '')));
+ } else {
+ flags[flagName] = flagType(getDefaultFromTypeWithValue(flagType, value || ''));
+ }
+
  expectingValue = undefined;
  };
  }
@@ -93,7 +108,7 @@ function typeFlag<Schemas extends Flags>(
  let { flagName } = parsedFlag;
 
  if (isAlias) {
- const aliases = flagName.split('');
+ const aliases = flagName.split(''); // TODO: no need to splitt
  for (let j = 0; j < aliases.length; j += 1) {
  const alias = aliases[j];
  const hasAlias = aliasesMap.get(alias);

src/types.ts

@@ -1,30 +1,31 @@
-export type TypeFunction = (argvValue: any) => any;
+export type TypeFunction<T = any> = (argvValue: any) => T;
+
+export type TypeFunctionArray<T = any> = [TypeFunction<T>];
 
 export type FlagSchema = {
- type?: TypeFunction;
+ type: TypeFunction | TypeFunctionArray;
  alias?: string;
 };
 
+export type FlagTypeOrSchema = TypeFunction | TypeFunctionArray | FlagSchema;
+
 export type Flags = {
- [flagName: string]: TypeFunction | FlagSchema;
+ [flagName: string]: FlagTypeOrSchema;
 };
 
 export type ParsedFlags = {
  [flag: string]: (string | boolean)[];
 };
 
-export type InferFlagType<Flag extends (TypeFunction | FlagSchema)> = ReturnType<
- Flag extends TypeFunction
- // Constructor function
- ? Flag
-
- // Schema object
- : (
- Flag extends { type: TypeFunction }
- // Constructor function
- ? Flag['type']
+export type InferFlagType<
+ Flag extends FlagTypeOrSchema
+> = Flag extends (TypeFunction<infer T> | { type: TypeFunction<infer T> })
+ // Type function return-type
+ ? (T | undefined)
 
- // Fallback to string
- : StringConstructor
- )
->;
+ // Type function return-type in array
+ : (
+ Flag extends (TypeFunctionArray<infer T> | { type: TypeFunctionArray<infer T> })
+ ? T[]
+ : never
+ );

src/utils.ts

@@ -3,8 +3,8 @@ import type {
  TypeFunction,
  FlagSchema,
  Flags,
- ParsedFlags,
  InferFlagType,
+ FlagTypeOrSchema,
 } from './types';
 
 const kebabCasePattern = /-(\w)/g;
@@ -85,9 +85,9 @@ export function mapAliases<Schemas extends Flags>(
 
  validateFlagName(schemas, name);
 
- const schema = schemas[name];
+ const schema = schemas[name] as FlagSchema;
  if (schema && typeof schema === 'object') {
- const { alias } = schema as FlagSchema;
+ const { alias } = schema;
  if (alias) {
  assert(alias.length > 0, `Invalid flag alias ${stringify(name)}: flag alias cannot be empty`);
  assert(alias.length === 1, `Invalid flag alias ${stringify(name)}: flag aliases can only be a single-character`);
@@ -107,17 +107,25 @@ export function mapAliases<Schemas extends Flags>(
  return aliases;
 }
 
+const isArrayType = (schema: FlagTypeOrSchema) => {
+ if (typeof schema === 'function') {
+ return false;
+ }
+
+ return (Array.isArray(schema) || Array.isArray(schema.type));
+};
+
 export const createFlagsObject = <Schemas extends Flags>(schema: Flags) => {
- const flags: ParsedFlags = {};
+ const flags: Record<string, any> = {};
 
  for (const flag in schema) {
  if (hasOwn(schema, flag)) {
- flags[flag] = [];
+ flags[flag] = isArrayType(schema[flag]) ? [] : undefined;
  }
  }
 
  return flags as {
- [flag in keyof Schemas]: InferFlagType<Schemas[flag]>[];
+ [flag in keyof Schemas]: InferFlagType<Schemas[flag]>;
  };
 };
 
@@ -135,10 +143,3 @@ export const getDefaultFromTypeWithValue = (
 
  return value;
 };
-
-export const isFlagSchemaWithType = (
- schema: FlagSchema,
-): schema is { type: TypeFunction } => (
- ('type' in schema)
- && (typeof schema.type === 'function')
-);