feat: store end of flags in -- property

README.md

@@ -86,7 +86,9 @@ $ node ./cli --some-string 'hello' --some-boolean --some-number 3
  unknownFlags: {
  [flagName: string]: (string | boolean)[]
  }
- _: string[]
+ _: string[] & {
+ '--': string[]
+ }
 }
 ```
 
@@ -195,7 +197,7 @@ This outputs the following:
 ### Arguments
 All argument values are stored in the `_` property.
 
-Everything after `--` will not be parsed and be treated as arguments.
+Everything after `--` (end-of-flags) is treated as arguments and will be stored in the `_['--']` property.
 
 ```sh
 $ node ./cli --boolean value --string "hello world" "another value" -- --string "goodbye world"
@@ -204,7 +206,16 @@ $ node ./cli --boolean value --string "hello world" "another value" -- --string
 This outputs the following:
 ```json5
 {
- _: ['value', 'another value', '--string', 'goodbye world']
+ _: [
+ 'value',
+ 'another value',
+ '--string',
+ 'goodbye world',
+ '--': [
+ '--string',
+ 'goodbye world'
+ ]
+ ]
  // ...
 }
 ```

src/type-flag.ts

@@ -15,6 +15,7 @@ import {
 
 const isAliasPattern = /^-[\da-z]+/i;
 const isFlagPattern = /^--[\w-]{2,}/;
+const END_OF_FLAGS = '--';
 
 /**
 type-flag: typed argv parser
@@ -44,7 +45,9 @@ export function typeFlag<Schemas extends Flags>(
  const parsed: TypeFlag<Schemas> = {
  flags: createFlagsObject(schemas),
  unknownFlags: {},
- _: [],
+ _: Object.assign([], {
+ [END_OF_FLAGS]: [],
+ }),
  };
 
  let expectingValue: undefined | ((value?: string | boolean) => void);
@@ -98,8 +101,10 @@ export function typeFlag<Schemas extends Flags>(
  for (let i = 0; i < argv.length; i += 1) {
  const argvElement = argv[i];
 
- if (argvElement === '--') {
- parsed._.push(...argv.slice(i + 1));
+ if (argvElement === END_OF_FLAGS) {
+ const endOfFlags = argv.slice(i + 1);
+ parsed._[END_OF_FLAGS] = endOfFlags;
+ parsed._.push(...endOfFlags);
  break;
  }
 

src/types.ts

@@ -94,5 +94,7 @@ export type TypeFlag<Schemas extends Flags> = {
  unknownFlags: {
  [flag: string]: (string | boolean)[];
  };
- _: string[];
+ _: string[] & {
+ '--': string[];
+ };
 };

tests/type-flag.spec.ts

@@ -157,7 +157,7 @@ describe('Parsing', () => {
  const parsed = typeFlag({}, ['-invalidAlias']);
 
  expect(parsed).toStrictEqual({
- _: [],
+ _: Object.assign([], { '--': [] }),
  flags: {},
  unknownFlags: {
  i: [true, true, true],
@@ -180,7 +180,14 @@ describe('Parsing', () => {
 
  expect<string | undefined>(parsed.flags.flagA).toBe('');
  expect<string | undefined>(parsed.flags.flagB).toBe(undefined);
- expect<string[]>(parsed._).toStrictEqual(['--flagB']);
+ expect<string[]>(parsed._).toStrictEqual(
+ Object.assign(
+ ['--flagB'],
+ {
+ '--': ['--flagB'],
+ },
+ ),
+ );
  });
 
  test('strings, booleans, numbers', () => {
@@ -193,7 +200,12 @@ describe('Parsing', () => {
  expect<string | undefined>(parsed.flags.string).toBe('');
  expect<boolean | undefined>(parsed.flags.boolean).toBe(true);
  expect<number | undefined>(parsed.flags.number).toBe(Number.NaN);
- expect<string[]>(parsed._).toStrictEqual(['world']);
+ expect<string[]>(parsed._).toStrictEqual(
+ Object.assign(
+ ['world'],
+ { '--': [] },
+ ),
+ );
  });
 
  test('convert kebab-case to camelCase', () => {
@@ -226,7 +238,12 @@ describe('Parsing', () => {
  expect<string | undefined>(parsed.flags.string).toBe('');
  expect<boolean | undefined>(parsed.flags.boolean).toBe(true);
  expect<number | undefined>(parsed.flags.number).toBe(Number.NaN);
- expect<string[]>(parsed._).toStrictEqual(['world']);
+ expect<string[]>(parsed._).toStrictEqual(
+ Object.assign(
+ ['world'],
+ { '--': [] },
+ ),
+ );
  });
 
  test('flag: - to allow the use of = in values (or vice versa)', () => {
@@ -266,7 +283,12 @@ describe('Parsing', () => {
  expect<string | undefined>(parsed.flags.string).toBe('');
  expect<boolean | undefined>(parsed.flags.boolean).toBe(true);
  expect<string[]>(Object.keys(parsed.flags)).toStrictEqual(['string', 'boolean']);
- expect<string[]>(parsed._).toStrictEqual(['world']);
+ expect<string[]>(parsed._).toStrictEqual(
+ Object.assign(
+ ['world'],
+ { '--': [] },
+ ),
+ );
  });
 
  test('unknown flags', () => {
@@ -309,7 +331,12 @@ describe('Parsing', () => {
  unknownString: ['hello', true],
  'kebab-case': [true],
  });
- expect<string[]>(parsed._).toStrictEqual(['a']);
+ expect<string[]>(parsed._).toStrictEqual(
+ Object.assign(
+ ['a'],
+ { '--': [] },
+ ),
+ );
  });
 
  test('custom type', () => {
@@ -356,7 +383,12 @@ describe('Parsing', () => {
  expect<number | undefined>(parsed.flags.number).toBe(Number.NaN);
  expect<string[]>(parsed.flags.stringArray).toStrictEqual(['a', 'b']);
  expect<number[]>(parsed.flags.numberArray).toStrictEqual([1, 2]);
- expect<string[]>(parsed._).toStrictEqual(['world']);
+ expect<string[]>(parsed._).toStrictEqual(
+ Object.assign(
+ ['world'],
+ { '--': [] },
+ ),
+ );
  });
 
  describe('Default flag value', () => {

tests/type-flag.test-d.ts

@@ -38,7 +38,7 @@ type ExpectedType = {
  unknownFlags: {
  [flag: string]:(string | boolean)[];
  };
- _: string[];
+ _: string[] & { '--': string[] };
 };
 
 expectType<ExpectedType>(parsed);