@travetto/cli 8.0.0-alpha.27 → 8.0.0-alpha.29

package/src/parse.ts

@@ -25,32 +25,35 @@ const STATE_SYMBOL = Symbol();
  * Parsing support for the cli
  */
 export class CliParseUtil {
-
   static toEnvField(key: string): string {
     return key.startsWith(ENV_PREFIX) ? key : `${ENV_PREFIX}${key}`;
   }
 
-  static readToken(text: string, start = 0): { next: number, value?: string } {
+  static readToken(text: string, start = 0): { next: number; value?: string } {
     const collected: number[] = [];
     let i = start;
     let done = false;
     let quote: number | undefined;
     let escaped = false;
-    outer: for (; i < text.length; i += 1) {
+    for (; i < text.length; i += 1) {
       const ch = text.charCodeAt(i);
       const space = SPACE.has(ch);
       if (escaped) {
         escaped = false;
         collected.push(ch);
       } else if (done && !space) {
-        break outer;
+        break;
       } else if (!quote && space) {
         done = true;
       } else {
         switch (ch) {
-          case 92: /* Backslash */ escaped = true; break;
-          case 39: /* Single quote */ case 34: /* Double quote */
-            if (quote === ch) { // End quote
+          case 92:
+            /* Backslash */ escaped = true;
+            break;
+          case 39: /* Single quote */
+          case 34 /* Double quote */:
+            if (quote === ch) {
+              // End quote
               quote = undefined;
             } else if (!quote) {
               quote = ch;
@@ -58,7 +61,8 @@ export class CliParseUtil {
               collected.push(ch);
             }
             break;
-          default: collected.push(ch);
+          default:
+            collected.push(ch);
         }
       }
     }
@@ -73,10 +77,9 @@ export class CliParseUtil {
     const input = Object.values(schema.fields).find(config => config.specifiers?.includes('module'));
     const envKey = input?.aliases?.filter(alias => alias.startsWith(ENV_PREFIX)).map(alias => alias.replace(ENV_PREFIX, ''))[0] ?? '';
     const flags = new Set(input?.aliases ?? []);
-    const check = (key?: string, value?: string): string | undefined => flags.has(key!) ? value : undefined;
+    const check = (key?: string, value?: string): string | undefined => (flags.has(key!) ? value : undefined);
     return args.reduce(
-      (name, value, i, values) =>
-        (i < separatorIndex ? check(values[i - 1], value) ?? check(...value.split('=')) : undefined) ?? name,
+      (name, value, i, values) => (i < separatorIndex ? (check(values[i - 1], value) ?? check(...value.split('='))) : undefined) ?? name,
       process.env[envKey]
     );
   }
@@ -89,18 +92,20 @@ export class CliParseUtil {
     const overrides = { '@': module ?? Runtime.main.name };
 
     // We have a file
-    const relativePath = (key.includes('/') ? key : `@#support/pack.${key}.flags`)
-      .replace(/^(@[^#]*)#(.*)$/, (_, imp, rest) => `${Runtime.modulePath(imp, overrides)}/${rest}`);
+    const relativePath = (key.includes('/') ? key : `@#support/pack.${key}.flags`).replace(
+      /^(@[^#]*)#(.*)$/,
+      (_, imp, rest) => `${Runtime.modulePath(imp, overrides)}/${rest}`
+    );
 
     const file = path.resolve(relativePath);
 
-    if (!await fs.stat(file, { throwIfNoEntry: false })) {
+    if (!(await fs.stat(file, { throwIfNoEntry: false }))) {
       throw new Error(`Missing flag file: ${key}, unable to proceed`);
     }
 
     const data = await fs.readFile(file, 'utf8');
     const args: string[] = [];
-    let token: { next: number, value?: string } = { next: 0 };
+    let token: { next: number; value?: string } = { next: 0 };
     while (token.next < data.length) {
       token = this.readToken(data, token.next);
       if (token.value !== undefined) {
@@ -114,7 +119,7 @@ export class CliParseUtil {
    * Parse args to extract command from argv along with other params.  Will skip
    * argv[0] and argv[1] if equal to process.argv[0:2]
    */
-  static getArgs(argv: string[]): { cmd?: string, args: string[], help?: boolean } {
+  static getArgs(argv: string[]): { cmd?: string; args: string[]; help?: boolean } {
     let offset = 0;
     if (argv[0] === process.argv[0] && argv[1] === process.argv[1]) {
       offset = 2;
@@ -135,11 +140,12 @@ export class CliParseUtil {
   static async expandArgs(schema: SchemaClassConfig, args: string[]): Promise<string[]> {
     const separatorIndex = args.includes(RAW_SEPARATOR) ? args.indexOf(RAW_SEPARATOR) : args.length;
     const module = this.getSpecifiedModule(schema, args);
-    return Promise
-      .all(args.map(async (arg, i) =>
-        await (arg.startsWith(CONFIG_PREFIX) && (i < separatorIndex || separatorIndex < 0) ? this.readFlagFile(arg, module) : arg))
+    return Promise.all(
+      args.map(
+        async (arg, i) =>
+          await (arg.startsWith(CONFIG_PREFIX) && (i < separatorIndex || separatorIndex < 0) ? this.readFlagFile(arg, module) : arg)
       )
-      .then(expanded => expanded.flat());
+    ).then(expanded => expanded.flat());
   }
 
   /**
@@ -159,7 +165,9 @@ export class CliParseUtil {
         if (simple in process.env) {
           const value: string = process.env[simple]!;
           if (field.array) {
-            out.push(...value.split(/\s*,\s*/g).map(item => ({ type: 'flag', fieldName: field.name, input: envName, value: item }) as const));
+            out.push(
+              ...value.split(/\s*,\s*/g).map(item => ({ type: 'flag', fieldName: field.name, input: envName, value: item }) as const)
+            );
           } else {
             out.push({ type: 'flag', fieldName: field.name, input: envName, value });
           }
@@ -172,7 +180,8 @@ export class CliParseUtil {
     for (let i = 0; i < inputs.length; i += 1) {
       const input = inputs[i];
 
-      if (input === RAW_SEPARATOR) { // Raw separator
+      if (input === RAW_SEPARATOR) {
+        // Raw separator
         out.push(...inputs.slice(i + 1).map((arg, idx) => ({ type: 'unknown', input: arg, index: argIdx + idx }) as const));
         break;
       } else if (LONG_FLAG_WITH_EQ.test(input)) {
@@ -183,7 +192,8 @@ export class CliParseUtil {
         } else {
           out.push({ type: 'unknown', input });
         }
-      } else if (VALID_FLAG.test(input)) { // Flag
+      } else if (VALID_FLAG.test(input)) {
+        // Flag
         const field = flagMap.get(input);
         if (!field) {
           out.push({ type: 'unknown', input });
@@ -224,27 +234,33 @@ export class CliParseUtil {
    * Parse aliases into categories for registration
    */
   static parseAliases(aliases: string[]): AliasesParseResult {
-    return aliases.reduce<AliasesParseResult>((result, alias) => {
-      if (VALID_FLAG.test(alias)) {
-        if (alias.startsWith('--')) {
-          result.long.push(alias);
+    return aliases.reduce<AliasesParseResult>(
+      (result, alias) => {
+        if (VALID_FLAG.test(alias)) {
+          if (alias.startsWith('--')) {
+            result.long.push(alias);
+          } else {
+            result.short.push(alias);
+          }
+        } else if (alias.startsWith(ENV_PREFIX)) {
+          result.env.push(alias);
         } else {
-          result.short.push(alias);
+          result.raw.push(alias);
         }
-      } else if (alias.startsWith(ENV_PREFIX)) {
-        result.env.push(alias);
-      } else {
-        result.raw.push(alias);
-      }
-      return result;
-    }, { long: [], short: [], raw: [], env: [] });
+        return result;
+      },
+      { long: [], short: [], raw: [], env: [] }
+    );
   }
 
   /**
    * Build aliases for a schema config
    */
-  static buildAliases(config: { full?: string, short?: string, envVars?: string[] }, ...extraEnvVars: string[]): Partial<SchemaFieldConfig> {
-    const envVars = [...config.envVars ?? [], ...extraEnvVars];
+  static buildAliases(
+    config: { full?: string; short?: string; envVars?: string[] },
+    ...extraEnvVars: string[]
+  ): Partial<SchemaFieldConfig> {
+    const envVars = [...(config.envVars ?? []), ...extraEnvVars];
     return {
       aliases: [
         ...(config.full ? [config.full.startsWith('-') ? config.full : `--${config.full}`] : []),
@@ -269,4 +285,4 @@ export class CliParseUtil {
     const local: T & { [STATE_SYMBOL]?: ParsedState } = item;
     local[STATE_SYMBOL] = state;
   }
-}
+}

package/src/registry/decorator.ts

@@ -1,14 +1,14 @@
-import { type Class, type ClassInstance, Env, Runtime, RuntimeIndex, castTo, describeFunction, getClass } from '@travetto/runtime';
+import { type Class, type ClassInstance, castTo, describeFunction, Env, getClass, Runtime, RuntimeIndex } from '@travetto/runtime';
 import { SchemaRegistryIndex, type ValidationError } from '@travetto/schema';
 
-import type { CliCommandShape } from '../types.ts';
-import { CliCommandRegistryIndex } from './registry-index.ts';
 import { CliModuleUtil } from '../module.ts';
 import { CliParseUtil } from '../parse.ts';
+import type { CliCommandShape } from '../types.ts';
 import { CliUtil } from '../util.ts';
+import { CliCommandRegistryIndex } from './registry-index.ts';
 
 type CliCommandConfigOptions = { runTarget?: boolean };
-type CliFlagOptions = { full?: string, short?: string, envVars?: string[] };
+type CliFlagOptions = { full?: string; short?: string; envVars?: string[] };
 
 /**
  * Decorator to register a CLI command
@@ -32,8 +32,7 @@ export function CliCommand(config: CliCommandConfigOptions = {}) {
  */
 export function CliFlag(config: CliFlagOptions) {
   return function (instance: ClassInstance, property: string): void {
-    SchemaRegistryIndex.getForRegister(getClass(instance))
-      .registerField(property, CliParseUtil.buildAliases(config));
+    SchemaRegistryIndex.getForRegister(getClass(instance)).registerField(property, CliParseUtil.buildAliases(config));
   };
 }
 
@@ -65,9 +64,9 @@ export function CliProfilesFlag(config: CliFlagOptions = {}) {
       description: 'Application profiles'
     });
 
-    CliCommandRegistryIndex.registerPreMain<typeof instance>(cls, 1, cmd => Env.TRV_PROFILES.add(...cmd[property] ?? []));
+    CliCommandRegistryIndex.registerPreMain<typeof instance>(cls, 1, cmd => Env.TRV_PROFILES.add(...(cmd[property] ?? [])));
   };
-};
+}
 
 /**
  * Registers a flag to support targeting a specific module
@@ -84,28 +83,35 @@ export function CliModuleFlag(config: CliFlagOptions & { scope?: 'current' | 'co
       ...CliParseUtil.buildAliases(config, Env.TRV_MODULE.key),
       description: 'Module to run for',
       specifiers: ['module'],
-      required: { active: Runtime.monoRoot && config.scope !== 'command' },
+      required: { active: Runtime.monoRoot && config.scope !== 'command' }
     });
 
     SchemaRegistryIndex.getForRegister(cls).register({
-      validators: [async (cmd: CliCommandShape): Promise<ValidationError | undefined> => {
-        const typed: (typeof cmd) & { [property]?: string } = castTo(cmd);
-        const providedModule = typed[property];
-        const runModule = (config.scope === 'command' ? commandModule : providedModule) || Runtime.main.name;
-
-        // If we need to run as a specific module
-        if (runModule !== Runtime.main.name && RuntimeIndex.getModule(runModule) === undefined) {
-          return { source: 'flag', message: `${runModule} is an unknown module`, kind: 'custom', path: property };
+      validators: [
+        async (cmd: CliCommandShape): Promise<ValidationError | undefined> => {
+          const typed: typeof cmd & { [property]?: string } = castTo(cmd);
+          const providedModule = typed[property];
+          const runModule = (config.scope === 'command' ? commandModule : providedModule) || Runtime.main.name;
+
+          // If we need to run as a specific module
+          if (runModule !== Runtime.main.name && RuntimeIndex.getModule(runModule) === undefined) {
+            return { source: 'flag', message: `${runModule} is an unknown module`, kind: 'custom', path: property };
+          }
+
+          if (!(await CliModuleUtil.moduleHasDependency(runModule, commandModule))) {
+            return {
+              source: 'flag',
+              message: `${runModule} does not have ${commandModule} as a dependency`,
+              kind: 'custom',
+              path: property
+            };
+          }
         }
-
-        if (!(await CliModuleUtil.moduleHasDependency(runModule, commandModule))) {
-          return { source: 'flag', message: `${runModule} does not have ${commandModule} as a dependency`, kind: 'custom', path: property };
-        }
-      }],
+      ]
     });
 
     CliCommandRegistryIndex.registerPreMain<typeof instance>(cls, 5, cmd => {
-      const typed: (typeof cmd) & { [property]?: string } = castTo(cmd);
+      const typed: typeof cmd & { [property]?: string } = castTo(cmd);
       const providedModule = typed[property];
       const runModule = (config.scope === 'command' ? commandModule : providedModule) || Runtime.main.name;
       if (runModule !== Runtime.main.name) {
@@ -123,7 +129,9 @@ export function CliModuleFlag(config: CliFlagOptions & { scope?: 'current' | 'co
 export function CliRestartOnChangeFlag(config: CliFlagOptions = {}) {
   return function <K extends string, T extends Partial<Record<K, boolean>>>(instance: T, property: K): void {
     const cls = getClass(instance);
-    if (Runtime.production) { return; }
+    if (Runtime.production) {
+      return;
+    }
 
     SchemaRegistryIndex.getForRegister(cls).registerField(property, {
       ...CliParseUtil.buildAliases(config),
@@ -142,7 +150,9 @@ export function CliRestartOnChangeFlag(config: CliFlagOptions = {}) {
  */
 export function CliDebugIpcFlag(config: CliFlagOptions = {}) {
   return function <K extends string, T extends Partial<Record<K, boolean>>>(instance: T, property: K): void {
-    if (Runtime.production) { return; }
+    if (Runtime.production) {
+      return;
+    }
 
     const cls = getClass(instance);
     SchemaRegistryIndex.getForRegister(cls).registerField(property, {
@@ -156,4 +166,4 @@ export function CliDebugIpcFlag(config: CliFlagOptions = {}) {
       return cmd[property] && CliUtil.runWithDebugIpc(cliConfig.name);
     });
   };
-}
+}

package/src/registry/registry-adapter.ts

@@ -1,21 +1,22 @@
-import { type Class, classConstruct, describeFunction } from '@travetto/runtime';
 import type { RegistryAdapter } from '@travetto/registry';
+import { type Class, classConstruct, describeFunction } from '@travetto/runtime';
 import { SchemaRegistryIndex } from '@travetto/schema';
 
-import type { CliCommandConfig, CliCommandShape } from '../types.ts';
 import { CliParseUtil, ENV_PREFIX } from '../parse.ts';
+import type { CliCommandConfig, CliCommandShape } from '../types.ts';
 
 const CLI_FILE_REGEX = /\/cli[.](?<name>.{0,100}?)([.]tsx?)?$/;
 
 const getName = (name: string): string => (name.match(CLI_FILE_REGEX)?.groups?.name ?? name).replaceAll('_', ':');
 const stripDashes = (flag?: string): string | undefined => flag?.replace(/^-+/, '');
-const toFlagName = (field: string): string => field.replace(/([a-z])([A-Z])/g, (_, left: string, right: string) => `${left}-${right.toLowerCase()}`);
+const toFlagName = (field: string): string =>
+  field.replace(/([a-z])([A-Z])/g, (_, left: string, right: string) => `${left}-${right.toLowerCase()}`);
 
 function combineClasses(base: CliCommandConfig, ...configs: Partial<CliCommandConfig>[]): CliCommandConfig {
   for (const config of configs) {
     base.runTarget = config.runTarget ?? base.runTarget;
     if (config.preMain) {
-      base.preMain = [...base.preMain ?? [], ...config.preMain ?? []];
+      base.preMain = [...(base.preMain ?? []), ...(config.preMain ?? [])];
     }
   }
   return base;
@@ -33,10 +34,11 @@ export class CliCommandRegistryAdapter implements RegistryAdapter<CliCommandConf
   finalize(parent?: CliCommandConfig): void {
     // Add help command
     const schema = SchemaRegistryIndex.getConfig(this.#cls);
-    const used = new Set(Object.values(schema.fields)
-      .flatMap(field => field.aliases ?? [])
-      .filter(alias => !alias.startsWith(ENV_PREFIX))
-      .map(stripDashes)
+    const used = new Set(
+      Object.values(schema.fields)
+        .flatMap(field => field.aliases ?? [])
+        .filter(alias => !alias.startsWith(ENV_PREFIX))
+        .map(stripDashes)
     );
 
     for (const field of Object.values(schema.fields)) {
@@ -45,7 +47,7 @@ export class CliCommandRegistryAdapter implements RegistryAdapter<CliCommandConf
 
       let short = stripDashes(shortAliases?.[0]) ?? rawAliases.find(alias => alias.length <= 2);
       const long = stripDashes(longAliases?.[0]) ?? rawAliases.find(alias => alias.length >= 3) ?? toFlagName(fieldName);
-      const aliases: string[] = field.aliases = [...envAliases];
+      const aliases: string[] = (field.aliases = [...envAliases]);
 
       if (short === undefined) {
         short = fieldName.charAt(0);
@@ -65,7 +67,7 @@ export class CliCommandRegistryAdapter implements RegistryAdapter<CliCommandConf
     }
 
     if (parent) {
-      this.#config.preMain = [...this.#config.preMain, ...parent?.preMain ?? []];
+      this.#config.preMain = [...this.#config.preMain, ...(parent?.preMain ?? [])];
     }
 
     // Sort
@@ -91,4 +93,4 @@ export class CliCommandRegistryAdapter implements RegistryAdapter<CliCommandConf
   getInstance(): CliCommandShape {
     return classConstruct(this.#cls);
   }
-}
+}

package/src/registry/registry-index.ts

@@ -1,5 +1,5 @@
+import { Registry, type RegistryAdapter, type RegistryIndex, RegistryIndexStore } from '@travetto/registry';
 import { type Any, type Class, getClass, getParentClass, isClass, Runtime, RuntimeIndex } from '@travetto/runtime';
-import { type RegistryAdapter, type RegistryIndex, RegistryIndexStore, Registry } from '@travetto/registry';
 import { type SchemaClassConfig, SchemaRegistryIndex } from '@travetto/schema';
 
 import type { CliCommandConfig, CliCommandShape, PreMainHandler } from '../types.ts';
@@ -8,12 +8,11 @@ import { CliCommandRegistryAdapter } from './registry-adapter.ts';
 const CLI_FILE_REGEX = /\/cli[.](?<name>.{0,100}?)([.]tsx?)?$/;
 const getName = (field: string): string => (field.match(CLI_FILE_REGEX)?.groups?.name ?? field).replaceAll('_', ':');
 
-type CliCommandLoadResult = { command: string, config: CliCommandConfig, instance: CliCommandShape, schema: SchemaClassConfig };
+type CliCommandLoadResult = { command: string; config: CliCommandConfig; instance: CliCommandShape; schema: SchemaClassConfig };
 
 export const UNKNOWN_COMMAND = Symbol();
 
 export class CliCommandRegistryIndex implements RegistryIndex {
-
   static #instance = Registry.registerIndex(this);
 
   static getForRegister(cls: Class): RegistryAdapter<CliCommandConfig> {
@@ -37,7 +36,9 @@ export class CliCommandRegistryIndex implements RegistryIndex {
 
   store = new RegistryIndexStore(CliCommandRegistryAdapter);
 
-  /** @private */ constructor(source: unknown) { Registry.validateConstructor(source); }
+  /** @private */ constructor(source: unknown) {
+    Registry.validateConstructor(source);
+  }
 
   /**
    * Get list of all commands available
@@ -71,19 +72,16 @@ export class CliCommandRegistryIndex implements RegistryIndex {
 
     const found = this.#commandMapping.get(name)!;
     const values = Object.values(await Runtime.importFrom<Record<string, Class>>(found));
-    const filtered = values
-      .filter(isClass)
-      .reduce<Class[]>((classes, cls) => {
-        const parent = getParentClass(cls);
-        if (parent && !classes.includes(parent)) {
-          classes.push(parent);
-        }
-        classes.push(cls);
-        return classes;
-      }, []);
-
-    const uninitialized = filtered
-      .filter(cls => !this.store.finalized(cls));
+    const filtered = values.filter(isClass).reduce<Class[]>((classes, cls) => {
+      const parent = getParentClass(cls);
+      if (parent && !classes.includes(parent)) {
+        classes.push(parent);
+      }
+      classes.push(cls);
+      return classes;
+    }, []);
+
+    const uninitialized = filtered.filter(cls => !this.store.finalized(cls));
 
     // Initialize any uninitialized commands
     if (uninitialized.length) {
@@ -110,13 +108,15 @@ export class CliCommandRegistryIndex implements RegistryIndex {
   async load(names?: string[]): Promise<CliCommandLoadResult[]> {
     const keys = names ?? [...this.#commandMapping.keys()];
 
-    const list = await Promise.all(keys.map(async key => {
-      const instance = await this.#getInstance(key);
-      const config = this.store.get(getClass(instance)).get();
-      const schema = SchemaRegistryIndex.getConfig(getClass(instance));
-      return { command: key, instance, config, schema };
-    }));
+    const list = await Promise.all(
+      keys.map(async key => {
+        const instance = await this.#getInstance(key);
+        const config = this.store.get(getClass(instance)).get();
+        const schema = SchemaRegistryIndex.getConfig(getClass(instance));
+        return { command: key, instance, config, schema };
+      })
+    );
 
     return list.sort((a, b) => a.command.localeCompare(b.command));
   }
-}
+}

package/src/schema-export.ts

@@ -1,4 +1,4 @@
-import { castTo, type Class, describeFunction } from '@travetto/runtime';
+import { type Class, castTo, describeFunction } from '@travetto/runtime';
 import { type SchemaInputConfig, SchemaRegistryIndex } from '@travetto/schema';
 
 import { CliCommandRegistryIndex } from './registry/registry-index.ts';
@@ -32,24 +32,30 @@ export interface CliCommandSchema<K extends string = string> {
 }
 
 export class CliSchemaExportUtil {
-
   /**
    * Get the base type for a CLI command input
    */
   static baseInputType(config: SchemaInputConfig): Pick<CliCommandInput, 'type' | 'fileExtensions'> {
     switch (castTo<Function>(config.type)) {
-      case Date: return { type: 'date' };
-      case Boolean: return { type: 'boolean' };
-      case Number: return { type: 'number' };
-      case RegExp: return { type: 'regex' };
-      case BigInt: return { type: 'bigint' };
+      case Date:
+        return { type: 'date' };
+      case Boolean:
+        return { type: 'boolean' };
+      case Number:
+        return { type: 'number' };
+      case RegExp:
+        return { type: 'regex' };
+      case BigInt:
+        return { type: 'bigint' };
       case String: {
         switch (true) {
-          case config.specifiers?.includes('module'): return { type: 'module' };
-          case config.specifiers?.includes('file'): return {
-            type: 'file',
-            fileExtensions: config.specifiers?.map(specifier => specifier.split('ext:')[1]).filter(specifier => !!specifier)
-          };
+          case config.specifiers?.includes('module'):
+            return { type: 'module' };
+          case config.specifiers?.includes('file'):
+            return {
+              type: 'file',
+              fileExtensions: config.specifiers?.map(specifier => specifier.split('ext:')[1]).filter(specifier => !!specifier)
+            };
         }
       }
     }
@@ -62,14 +68,17 @@ export class CliSchemaExportUtil {
   static processInput(config: SchemaInputConfig): CliCommandInput {
     return {
       ...this.baseInputType(config),
-      ...(('name' in config && typeof config.name === 'string') ? { name: config.name } : { name: '' }),
+      ...('name' in config && typeof config.name === 'string' ? { name: config.name } : { name: '' }),
       description: config.description,
       array: config.array,
       required: config.required?.active !== false,
       choices: config.enum?.values,
       default: Array.isArray(config.default) ? config.default.slice(0) : config.default,
       flagNames: (config.aliases ?? []).slice(0).filter(value => !value.startsWith('env.')),
-      envVars: (config.aliases ?? []).slice(0).filter(value => value.startsWith('env.')).map(value => value.replace('env.', ''))
+      envVars: (config.aliases ?? [])
+        .slice(0)
+        .filter(value => value.startsWith('env.'))
+        .map(value => value.replace('env.', ''))
     };
   }
 
@@ -87,4 +96,4 @@ export class CliSchemaExportUtil {
       runTarget: config.runTarget ?? false
     };
   }
-}
+}

package/src/schema.ts

@@ -1,15 +1,18 @@
 import { castKey, castTo, getClass } from '@travetto/runtime';
-import { BindUtil, SchemaRegistryIndex, SchemaValidator, ValidationResultError, type ValidationError } from '@travetto/schema';
+import { BindUtil, SchemaRegistryIndex, SchemaValidator, type ValidationError, ValidationResultError } from '@travetto/schema';
 
-import type { ParsedState, CliCommandShape } from './types.ts';
+import type { CliCommandShape, ParsedState } from './types.ts';
 
 const getSource = (source: string | undefined, defaultSource: ValidationError['source']): ValidationError['source'] => {
   switch (source) {
     case 'custom':
     case 'arg':
-    case 'flag': return source;
-    case undefined: return defaultSource;
-    default: return 'custom';
+    case 'flag':
+      return source;
+    case undefined:
+      return defaultSource;
+    default:
+      return 'custom';
   }
 };
 
@@ -41,7 +44,7 @@ export class CliCommandSchemaUtil {
           const key = castKey<T>(item.fieldName);
           const value = item.value!;
           if (item.array) {
-            castTo<unknown[]>(template[key] ??= castTo([])).push(value);
+            castTo<unknown[]>((template[key] ??= castTo([]))).push(value);
           } else {
             template[key] = castTo(value);
           }
@@ -49,7 +52,7 @@ export class CliCommandSchemaUtil {
         }
         case 'arg': {
           if (item.array) {
-            castTo<unknown[]>(bound[item.index] ??= []).push(item.input);
+            castTo<unknown[]>((bound[item.index] ??= [])).push(item.input);
           } else {
             bound[item.index] = item.input;
           }
@@ -67,11 +70,13 @@ export class CliCommandSchemaUtil {
    */
   static async validate(command: CliCommandShape, args: unknown[]): Promise<typeof command> {
     const cls = getClass(command);
-    const paramNames = SchemaRegistryIndex.get(cls).getMethod('main').parameters.map(config => config.name!);
+    const paramNames = SchemaRegistryIndex.get(cls)
+      .getMethod('main')
+      .parameters.map(config => config.name!);
 
     const results = await Promise.all([
       SchemaValidator.validate(cls, command).then(() => [], transformFlagErrors),
-      SchemaValidator.validateMethod(cls, 'main', args, paramNames).then(() => [], transformArgErrors),
+      SchemaValidator.validateMethod(cls, 'main', args, paramNames).then(() => [], transformArgErrors)
     ]);
 
     const errors = results.flat();
@@ -80,4 +85,4 @@ export class CliCommandSchemaUtil {
     }
     return command;
   }
-}
+}