refactor

src/argv-iterator.ts

@@ -1,6 +1,5 @@
 import {
  DOUBLE_DASH,
- parseFlagArgv,
 } from './utils';
 
 type BreakIteration = false;
@@ -26,6 +25,36 @@ type onEndOfFlags = (
  index: number,
 ) => void
 
+const valueDelimiterPattern = /[.:=]/;
+
+const isFlagPattern = /^-{1,2}[\da-z]/i;
+
+const parseFlagArgv = (
+ flagArgv: string,
+): [
+ flagName: string,
+ flagValue: string | undefined,
+ isAlias: boolean,
+] | undefined => {
+ if (!isFlagPattern.test(flagArgv)) {
+ return;
+ }
+
+ const isAlias = !flagArgv.startsWith(DOUBLE_DASH);
+ let flagName = flagArgv.slice(isAlias ? 1 : 2);
+
+ let flagValue;
+
+ const hasValueDalimiter = flagName.match(valueDelimiterPattern);
+ if (hasValueDalimiter?.index) {
+ const equalIndex = hasValueDalimiter.index;
+ flagValue = flagName.slice(equalIndex + 1);
+ flagName = flagName.slice(0, equalIndex);
+ }
+
+ return [flagName, flagValue, isAlias];
+};
+
 export const argvIterator = (
  argv: string[],
  callbacks: {

src/type-flag.ts

@@ -1,17 +1,12 @@
 import type {
  Flags,
- FlagTypeOrSchema,
  TypeFlag,
 } from './types';
 import {
  DOUBLE_DASH,
- kebabToCamel,
- createFlagsObject,
- mapAliases,
+ createRegistry,
  normalizeBoolean,
  applyParser,
- setDefaultFlagValues,
- parseFlagType,
  hasOwn,
  getOwn,
 } from './utils';
@@ -53,86 +48,42 @@ export const typeFlag = <Schemas extends Flags>(
  } = {},
 ) => {
  const { ignoreUnknown } = options;
- const aliasesMap = mapAliases(schemas);
+ const [flagRegistry, flags] = createRegistry(schemas);
  const parsed: ParsedFlags = {
- flags: createFlagsObject(schemas),
+ flags,
  unknownFlags: {},
  _: Object.assign([], {
  [DOUBLE_DASH]: [],
  }),
  };
 
- const setKnown = (
- flagName: string,
- flagSchema: FlagTypeOrSchema,
- explicitValue?: string,
- ) => {
- const [flagType] = parseFlagType(flagSchema);
- const flagValue = normalizeBoolean(flagType, explicitValue);
-
- const setValueOnPreviousFlag = (value?: string | boolean) => {
- const parsedValue = applyParser(flagType, value || '');
- const flagsArray = parsed.flags[flagName];
- if (Array.isArray(flagsArray)) {
- flagsArray.push(parsedValue);
- } else {
- parsed.flags[flagName] = parsedValue;
- }
- };
-
- return (
- flagValue === undefined
- ? setValueOnPreviousFlag
- : setValueOnPreviousFlag(flagValue)
- );
- };
-
- const setUnknown = (
- flagName: string,
- explicitValue?: string,
- ) => {
- if (!hasOwn(parsed.unknownFlags, flagName)) {
- parsed.unknownFlags[flagName] = [];
- }
-
- parsed.unknownFlags[flagName].push(
- explicitValue === undefined ? true : explicitValue,
- );
- };
-
  argvIterator(argv, {
- onFlag(name, value, index) {
- if (name.length === 1) {
- const hasAlias = getOwn(aliasesMap, name);
- if (hasAlias) {
- return setKnown(
- hasAlias.name,
- hasAlias.schema,
- value,
- );
- } if (ignoreUnknown) {
- parsed._.push(argv[index]);
- } else {
- setUnknown(name, value);
- }
+ onFlag(name, explicitValue, index) {
+ const knownFlag = getOwn(flagRegistry, name);
+
+ if (knownFlag) {
+ const [parser, values] = knownFlag;
+ const flagValue = normalizeBoolean(parser, explicitValue);
+ const getFollowingValue = (value?: string | boolean) => {
+ const parsedValue = applyParser(parser, value || '');
+ values.push(parsedValue);
+ };
+
+ return (
+ flagValue === undefined
+ ? getFollowingValue
+ : getFollowingValue(flagValue)
+ );
+ } if (ignoreUnknown) {
+ parsed._.push(argv[index]);
  } else {
- let flagSchema = getOwn(schemas, name);
- if (!flagSchema) {
- const camelized = kebabToCamel(name);
- flagSchema = getOwn(schemas, camelized);
-
- if (flagSchema) {
- name = camelized;
- }
+ if (!hasOwn(parsed.unknownFlags, name)) {
+ parsed.unknownFlags[name] = [];
  }
 
- if (flagSchema) {
- return setKnown(name, flagSchema, value);
- } if (ignoreUnknown) {
- parsed._.push(argv[index]);
- } else {
- setUnknown(name, value);
- }
+ parsed.unknownFlags[name].push(
+ explicitValue === undefined ? true : explicitValue,
+ );
  }
  },
 
@@ -147,8 +98,6 @@ export const typeFlag = <Schemas extends Flags>(
  },
  });
 
- setDefaultFlagValues(schemas, parsed.flags);
-
  type Result = TypeFlag<Schemas>;
  return parsed as {
  // This exposes the content of "TypeFlag<T>" in type hints