🐛 fix: global flag

Author: so1ve

packages/core/src/cli.ts

@@ -22,9 +22,9 @@ import type {
   CommandType,
   CommandWithHandler,
   Commands,
-  FlagWithoutDescription,
   Flags,
-  FlagsWithoutDescription,
+  GlobalFlagOption,
+  GlobalFlagOptions,
   Handler,
   HandlerContext,
   I18N,
@@ -50,7 +50,7 @@ import { locales } from "./locales";
 export const Root = Symbol.for("Clerc.Root");
 export type RootType = typeof Root;
 
-export class Clerc<C extends Commands = {}, GF extends FlagsWithoutDescription = {}> {
+export class Clerc<C extends Commands = {}, GF extends GlobalFlagOptions = {}> {
   #name = "";
   #description = "";
   #version = "";
@@ -289,18 +289,19 @@ export class Clerc<C extends Commands = {}, GF extends FlagsWithoutDescription =
   /**
    * Register a global flag
    * @param name
+   * @param description
    * @param options
    * @returns
    * @example
    * ```ts
    * Clerc.create()
-   *   .flag("help", {
+   *   .flag("help", "help", {
    *     alias: "h",
-   *     description: "help",
+   *     type: Boolean,
    *   })
    * ```
    */
-  flag<N extends string, O extends FlagWithoutDescription>(name: N, description: string, options: O): this & Clerc<C, GF & Record<N, O>> {
+  flag<N extends string, O extends GlobalFlagOption>(name: N, description: string, options: O): this & Clerc<C, GF & Record<N, O>> {
     this.#flags[name] = {
       description,
       ...options,
@@ -408,8 +409,12 @@ export class Clerc<C extends Commands = {}, GF extends FlagsWithoutDescription =
     const { t } = this.i18n;
     const [command, called] = getCommand();
     const isCommandResolved = !!command;
+    const flagsMerged = {
+      ...this.#flags,
+      ...command?.flags,
+    };
     // [...argv] is a workaround since TypeFlag modifies argv
-    const parsed = typeFlag(command?.flags || {}, [...argv]);
+    const parsed = typeFlag(flagsMerged, [...argv]);
     const { _: args, flags, unknownFlags } = parsed;
     let parameters = !isCommandResolved || command.name === Root ? args : args.slice(command.name.split(" ").length);
     let commandParameters = command?.parameters || [];

packages/core/src/types/index.ts

@@ -5,16 +5,15 @@ import type { FlagSchema, ParsedFlags, TypeFlag } from "./type-flag";
 import type { ParseFlag, ParseParameters, ParseRaw } from "./utils";
 
 export type CommandType = RootType | string;
-
 export type FlagOptions = FlagSchema & {
   description: string
 };
 export type Flag = FlagOptions & {
   name: string
 };
-export type FlagWithoutDescription = Omit<Flag, "description">;
+export type GlobalFlagOption = FlagSchema;
 export type Flags = Dict<FlagOptions>;
-export type FlagsWithoutDescription = Dict<FlagWithoutDescription>;
+export type GlobalFlagOptions = Dict<GlobalFlagOption>;
 
 export declare interface CommandCustomProperties {}
 export interface CommandOptions<P extends string[] = string[], A extends MaybeArray<string | RootType> = MaybeArray<string | RootType>, F extends Flags = Flags> extends CommandCustomProperties {
@@ -39,7 +38,7 @@ export interface ParseOptions {
   run?: boolean
 }
 
-export interface HandlerContext<C extends Commands = Commands, N extends keyof C = keyof C, GF extends FlagsWithoutDescription = {}> {
+export interface HandlerContext<C extends Commands = Commands, N extends keyof C = keyof C, GF extends GlobalFlagOptions = {}> {
   name?: LiteralUnion<N, string>
   called?: string | RootType
   resolved: boolean
@@ -51,7 +50,7 @@ export interface HandlerContext<C extends Commands = Commands, N extends keyof C
   flags: Simplify<ParseFlag<C, N, GF> & Record<string, any>>
   cli: Clerc<C, GF>
 }
-export type Handler<C extends Commands = Commands, K extends keyof C = keyof C, GF extends FlagsWithoutDescription = {}> = (ctx: HandlerContext<C, K, GF>) => void;
+export type Handler<C extends Commands = Commands, K extends keyof C = keyof C, GF extends GlobalFlagOptions = {}> = (ctx: HandlerContext<C, K, GF>) => void;
 export type HandlerInCommand<C extends HandlerContext> = (ctx: { [K in keyof C]: C[K] }) => void;
 export type FallbackType<T, U> = {} extends T ? U : T;
 export type InspectorContext<C extends Commands = Commands> = HandlerContext<C> & {

packages/core/src/types/type-flag.ts

@@ -54,7 +54,7 @@ export type FlagSchemaDefault<TF, DefaultType = any> = FlagSchemaBase<TF> & {
 };
 export type FlagSchema<TF = FlagType> = (FlagSchemaBase<TF> | FlagSchemaDefault<TF>);
 export type FlagTypeOrSchema<ExtraOptions = Record<string, unknown>> = FlagType | (FlagSchema & ExtraOptions);
-type Flags<ExtraOptions = Record<string, unknown>> = Record<string, FlagTypeOrSchema<ExtraOptions>>;
+export type Flags<ExtraOptions = Record<string, unknown>> = Record<string, FlagTypeOrSchema<ExtraOptions>>;
 export type InferFlagType<Flag extends FlagTypeOrSchema> = (Flag extends (TypeFunctionArray<infer T> | FlagSchema<TypeFunctionArray<infer T>>) ? (Flag extends FlagSchemaDefault<TypeFunctionArray<T>, infer D> ? T[] | D : T[]) : (Flag extends TypeFunction<infer T> | FlagSchema<TypeFunction<infer T>> ? (Flag extends FlagSchemaDefault<TypeFunction<T>, infer D> ? T | D : T | undefined) : never));
 export interface ParsedFlags<Schemas = Record<string, unknown>> {
   flags: Schemas
@@ -73,3 +73,9 @@ export interface IgnoreFunction {
   (type: typeof ARGUMENT, argvElement: string): boolean | void
   (type: typeof KNOWN_FLAG | typeof UNKNOWN_FLAG, flagName: string, flagValue: string | undefined): boolean | void
 }
+export interface TypeFlagOptions {
+  /**
+     * Which argv elements to ignore from parsing
+     */
+  ignore?: IgnoreFunction
+}

packages/core/src/types/utils.ts

@@ -1,7 +1,7 @@
 import type { CamelCase, Dict, Equals } from "@clerc/utils";
 import type { OmitIndexSignature } from "type-fest";
 import type { TypeFlag } from "./type-flag";
-import type { Command, Commands, Flags, FlagsWithoutDescription, InspectorContext } from ".";
+import type { Command, Commands, Flags, GlobalFlagOptions, InspectorContext } from ".";
 
 type StripBrackets<Parameter extends string> = (
   Parameter extends `<${infer ParameterName}>` | `[${infer ParameterName}]`
@@ -32,8 +32,8 @@ export type MakeEventMap<T extends Commands> = { [K in keyof T]: [InspectorConte
 
 type FallbackFlags<F extends Flags | undefined> = Equals<NonNullableFlag<F>["flags"], {}> extends true ? Dict<any> : NonNullableFlag<F>["flags"];
 type NonNullableFlag<F extends Flags | undefined> = TypeFlag<NonNullable<F>>;
-export type ParseFlag<C extends Commands, N extends keyof C, GF extends FlagsWithoutDescription = {}> = N extends keyof C ? OmitIndexSignature<NonNullableFlag<C[N]["flags"] & GF>["flags"]> : FallbackFlags<C[N]["flags"] & GF>["flags"];
-export type ParseRaw<C extends Command, GF extends FlagsWithoutDescription = {}> = NonNullableFlag<C["flags"] & GF> & {
+export type ParseFlag<C extends Commands, N extends keyof C, GF extends GlobalFlagOptions = {}> = N extends keyof C ? OmitIndexSignature<NonNullableFlag<C[N]["flags"] & GF>["flags"]> : FallbackFlags<C[N]["flags"] & GF>["flags"];
+export type ParseRaw<C extends Command, GF extends GlobalFlagOptions = {}> = NonNullableFlag<C["flags"] & GF> & {
   flags: FallbackFlags<C["flags"] & GF>
   parameters: string[]
   mergedFlags: FallbackFlags<C["flags"] & GF> & NonNullableFlag<C["flags"] & GF>["unknownFlags"]

packages/plugin-help/src/index.ts

@@ -172,7 +172,7 @@ export const helpPlugin = ({
     };
 
     if (command) {
-      cli = cli.command("help", t("help.comamndDescription")!, {
+      cli = cli.command("help", t("help.commandDescription")!, {
         parameters: [
           "[command...]",
         ],

packages/plugin-help/src/utils.ts

@@ -11,16 +11,18 @@ export const table = (items: string[][]) => textTable(items, { stringLength: str
 
 export const splitTable = (items: string[][]) => table(items).split("\n");
 
-const primitiveMap = new Map<any, string>([
-  [Boolean, ""],
+const primitiveMap = new Map<any, string | undefined>([
+  [Boolean, undefined],
   [String, "string"],
   [Number, "number"],
 ]);
 export const stringifyType = (type: any, hasDefault = false) => {
   const res = primitiveMap.has(type)
     ? primitiveMap.get(type)
     : "value";
-  return hasDefault ? `[${res}]` : `<${res}>`;
+  return res
+    ? hasDefault ? `[${res}]` : `<${res}>`
+    : "";
 };
 
 export const sortName = (a: CommandType, b: CommandType) => {
@@ -78,7 +80,7 @@ export const formatFlags = (flags: Flags) => Object.entries(flags).map(([name, f
   items.push(DELIMITER, flag.description);
   if (flag.type) {
     const type = stringifyType(flag.type);
-    items.push(pc.gray(`(${type})`));
+    type && items.push(pc.gray(`(${type})`));
   }
   return items;
 });

t.mts

@@ -0,0 +1,25 @@
+import { Clerc, helpPlugin } from "./packages/clerc/src/index";
+
+Clerc.create("1", "1", "1")
+  .use(helpPlugin())
+  .command("a a", "a", {
+    flags: {
+      aa: {
+        type: Boolean,
+        description: "",
+      },
+    },
+  })
+  .flag("hel", "1", {
+    type: Boolean,
+  })
+  .on("a a", (ctx) => {
+    console.log(ctx.flags.b);
+  })
+  .inspector((ctx, next) => {
+    next();
+    return () => {
+      console.log(ctx.flags);
+    };
+  })
+  .parse();