🐛 fix: type

Author: so1ve

package.json

@@ -45,7 +45,8 @@
   },
   "pnpm": {
     "patchedDependencies": {
-      "[email protected]": "patches/[email protected]"
+      "[email protected]": "patches/[email protected]",
+      "[email protected]": "patches/[email protected]"
     }
   }
 }

packages/core/src/cli.ts

@@ -1,6 +1,6 @@
 import { LiteEmit } from "lite-emit";
 import { typeFlag } from "type-flag";
-import type { Dict, LiteralUnion, MaybeArray } from "@clerc/utils";
+import type { LiteralUnion, MaybeArray } from "@clerc/utils";
 import { toArray } from "@clerc/utils";
 
 import {
@@ -18,7 +18,7 @@ import type {
   CommandRecord,
   CommandType,
   CommandWithHandler,
-  FlagOptions,
+  Flags,
   Handler,
   HandlerContext,
   Inspector,
@@ -155,8 +155,8 @@ export class Clerc<C extends CommandRecord = {}> {
    *   })
    * ```
    */
-  command<N extends string | RootType, O extends CommandOptions<[...P], A, F>, P extends string[] = string[], A extends MaybeArray<string | RootType> = MaybeArray<string | RootType>, F extends Dict<FlagOptions> = Dict<FlagOptions>>(c: CommandWithHandler<N, O & CommandOptions<[...P], A, F>>): this & Clerc<C & Record<N, Command<N, O>>>;
-  command<N extends string | RootType, O extends CommandOptions<[...P], A, F>, P extends string[] = string[], A extends MaybeArray<string | RootType> = MaybeArray<string | RootType>, F extends Dict<FlagOptions> = Dict<FlagOptions>>(name: N, description: string, options?: O & CommandOptions<[...P], A, F>): this & Clerc<C & Record<N, Command<N, O>>>;
+  command<N extends string | RootType, O extends CommandOptions<[...P], A, F>, P extends string[] = string[], A extends MaybeArray<string | RootType> = MaybeArray<string | RootType>, F extends Flags = Flags>(c: CommandWithHandler<N, O & CommandOptions<[...P], A, F>>): this & Clerc<C & Record<N, Command<N, O>>>;
+  command<N extends string | RootType, O extends CommandOptions<[...P], A, F>, P extends string[] = string[], A extends MaybeArray<string | RootType> = MaybeArray<string | RootType>, F extends Flags = Flags>(name: N, description: string, options?: O & CommandOptions<[...P], A, F>): this & Clerc<C & Record<N, Command<N, O>>>;
   command(nameOrCommand: any, description?: any, options: any = {}) {
     const checkIsCommandObject = (nameOrCommand: any): nameOrCommand is CommandWithHandler => !(typeof nameOrCommand === "string" || nameOrCommand === Root);
 
@@ -180,7 +180,7 @@ export class Clerc<C extends CommandRecord = {}> {
     (toArray(commandToSave.alias) || []).forEach(a => this.#usedNames.add(a));
 
     // Register handler
-    isCommandObject && handler && this.on(nameOrCommand.name, handler as any);
+    isCommandObject && handler && this.on(nameOrCommand.name, handler);
 
     return this as any;
   }

packages/core/src/helpers.ts

@@ -1,11 +1,13 @@
-import type { Dict, MaybeArray } from "@clerc/utils";
+/* eslint-disable @so1ve/generic-spacing */
 import type { Clerc, RootType } from "./cli";
-import type { CommandOptions, CommandWithHandler, FlagOptions, Handler, Inspector, Plugin } from "./types";
+import type { Command, CommandOptions, CommandWithHandler, Handler, HandlerContext, HandlerInCommand, Inspector, Plugin } from "./types";
 
 export const definePlugin = <T extends Clerc, U extends Clerc>(p: Plugin<T, U>) => p;
 
 export const defineHandler = <C extends Clerc, K extends keyof C["_commands"]>(_cli: C, _key: K, handler: Handler<C["_commands"], K>) => handler;
 
 export const defineInspector = <C extends Clerc>(_cli: C, inspector: Inspector<C["_commands"]>) => inspector;
 
-export const defineCommand = <N extends string | RootType, O extends CommandOptions<[...P], A, F>, P extends string[] = string[], A extends MaybeArray<string> = MaybeArray<string>, F extends Dict<FlagOptions> = Dict<FlagOptions>>(command: CommandWithHandler<N, O & CommandOptions<[...P], A, F>>) => command;
+export const defineCommand = <N extends string | RootType, O extends CommandOptions<[...P]>, P extends string[]>(command: Command<N, O & CommandOptions<[...P]>>, handler?: HandlerInCommand<
+  HandlerContext<Record<N, Command<N, O>> & Record<never, never>, N>
+>): CommandWithHandler<N, O & CommandOptions<[...P]>> => ({ ...command, handler });

packages/core/src/types/index.ts

@@ -9,9 +9,10 @@ export type FlagOptions = FlagSchema & {
 export type Flag = FlagOptions & {
   name: string
 };
+export type Flags = Dict<FlagOptions>;
 // Custom properties
 export declare interface CommandCustomProperties {}
-export interface CommandOptions<P extends string[] = string[], A extends MaybeArray<string | RootType> = MaybeArray<string | RootType>, F extends Dict<FlagOptions> = Dict<FlagOptions>> extends CommandCustomProperties {
+export interface CommandOptions<P extends string[] = string[], A extends MaybeArray<string | RootType> = MaybeArray<string | RootType>, F extends Flags = Flags> extends CommandCustomProperties {
   alias?: A
   parameters?: P
   flags?: F
@@ -25,9 +26,8 @@ export type Command<N extends string | RootType = string, O extends CommandOptio
 export type CommandAlias<N extends string | RootType = string, O extends CommandOptions = CommandOptions> = Command<N, O> & {
   __isAlias?: true
 };
-export type CommandWithHandler<N extends string | RootType = string, O extends CommandOptions = CommandOptions> = Command<N, O> & {
-  handler?: HandlerInCommand<Record<N, Command<N, O>> & Record<never, never>, N>
-};
+
+export type CommandWithHandler<N extends string | RootType = string, O extends CommandOptions = CommandOptions> = Command<N, O> & { handler?: HandlerInCommand<HandlerContext<Record<N, Command<N, O>> & Record<never, never>, N>> };
 type StripBrackets<Parameter extends string> = (
   Parameter extends `<${infer ParameterName}>` | `[${infer ParameterName}]`
     ? (
@@ -51,36 +51,29 @@ export type CommandRecord = Dict<Command> & { [Root]?: Command };
 export type MakeEventMap<T extends CommandRecord> = { [K in keyof T]: [InspectorContext] };
 export type PossibleInputKind = string | number | boolean | Dict<any>;
 type NonNullableParameters<T extends string[] | undefined> = T extends undefined ? [] : NonNullable<T>;
-type TransformParameters<C extends CommandRecord = CommandRecord, N extends keyof C = keyof C> = {
-  [Parameter in [...NonNullableParameters<C[N]["parameters"]>][number] as CamelCase<StripBrackets<Parameter>>]: ParameterType<Parameter>;
-};
-type TransformFlags<F extends Record<string, FlagSchema>> = {
-  [K in keyof F]: F[K]["type"] extends any[]
-    ? F[K]["default"] extends never[]
-      ? F[K] & { default: any[] }
-      : F[K]
-    : F[K]
+type TransformParameters<C extends Command> = {
+  [Parameter in NonNullableParameters<C["parameters"]>[number] as CamelCase<StripBrackets<Parameter>>]: ParameterType<Parameter>;
 };
-type TypeFlagWithDefault<C extends CommandRecord = CommandRecord, N extends keyof C = keyof C> = TypeFlag<TransformFlags<NonNullable<C[N]["flags"]>>>;
-type Raw<C extends CommandRecord = CommandRecord, N extends keyof C = keyof C> =
-  TypeFlagWithDefault<C, N> & {
+type TypeFlagWithDefault<C extends Command> = TypeFlag<NonNullable<C["flags"]>>;
+type Raw<C extends Command> =
+  TypeFlagWithDefault<C> & {
     parameters: string[]
-    mergedFlags: TypeFlagWithDefault<C, N>["flags"] & TypeFlagWithDefault<C, N>["unknownFlags"]
+    mergedFlags: TypeFlagWithDefault<C>["flags"] & TypeFlagWithDefault<C>["unknownFlags"]
   };
 export interface HandlerContext<C extends CommandRecord = CommandRecord, N extends keyof C = keyof C> {
-  name: N extends keyof C ? N : N | undefined
+  name?: N
   called?: string | RootType
-  resolved: N extends keyof C ? true : boolean
+  resolved: boolean
   hasRootOrAlias: boolean
   hasRoot: boolean
-  raw: Raw<C, N>
-  parameters: TransformParameters<C, N>
+  raw: { [K in keyof Raw<C[N]>]: Raw<C[N]>[K] }
+  parameters: { [K in keyof TransformParameters<C[N]>]: TransformParameters<C[N]>[K] }
   unknownFlags: ParsedFlags["unknownFlags"]
-  flags: TypeFlagWithDefault<C, N>["flags"]
+  flags: TypeFlagWithDefault<C[N]>["flags"]
   cli: Clerc<C>
 }
 export type Handler<C extends CommandRecord = CommandRecord, K extends keyof C = keyof C> = (ctx: HandlerContext<C, K>) => void;
-export type HandlerInCommand<C extends CommandRecord = CommandRecord, K extends keyof C = keyof C> = (ctx: HandlerContext<C, K> & { name: K }) => 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 CommandRecord = CommandRecord> = HandlerContext<C> & {
   flags: FallbackType<TypeFlag<NonNullable<C[keyof C]["flags"]>>["flags"], Dict<any>>

patches/[email protected]

@@ -0,0 +1,13 @@
+diff --git a/dist/index.d.ts b/dist/index.d.ts
+index d732d58ec773a3c8f55650995ba9a113bc04f505..75769f276cb3537fb0e0a418e0739bd72f08a6c6 100644
+--- a/dist/index.d.ts
++++ b/dist/index.d.ts
+@@ -2,7 +2,7 @@ interface EventMap {
+     [key: string | symbol]: any[];
+ }
+ declare type Listener<A extends any[]> = (...args: A) => void;
+-declare type _WildcardListener<EM extends EventMap, K extends keyof EM = keyof EM> = Listener<K extends unknown ? [K, ...EM[K]] : [K, ...EM[K]]>;
++declare type _WildcardListener<EM extends EventMap, K extends keyof EM = keyof EM> = Listener<[K, ...EM[K]]>;
+ declare type WildcardListener<EM extends EventMap> = _WildcardListener<EM>;
+ declare type ListenerMap<EM extends EventMap> = {
+     [K in keyof EM]?: Set<Listener<EM[K]>>;