Function parseInternal

packages/cli/src/internal/options.ts:1185–1371

(
  self: Instruction,
  args: HashMap.HashMap<string, ReadonlyArray<string>>,
  config: CliConfig.CliConfig
)

const keyValueSplitter = /=(.*)/

const parseInternal = (
  self: Instruction,
  args: HashMap.HashMap<string, ReadonlyArray<string>>,
  config: CliConfig.CliConfig
): Effect.Effect<
  unknown,
  ValidationError.ValidationError,
  FileSystem.FileSystem | Path.Path | Terminal.Terminal
> => {
  switch (self._tag) {
    case "Empty": {
      return Effect.void
    }
    case "Single": {
      const singleNames = Arr.filterMap(getNames(self), (name) => HashMap.get(args, name))
      if (Arr.isNonEmptyReadonlyArray(singleNames)) {
        const head = Arr.headNonEmpty(singleNames)
        const tail = Arr.tailNonEmpty(singleNames)
        if (Arr.isEmptyReadonlyArray(tail)) {
          if (Arr.isEmptyReadonlyArray(head)) {
            return InternalPrimitive.validate(self.primitiveType, Option.none(), config).pipe(
              Effect.mapError((e) => InternalValidationError.invalidValue(InternalHelpDoc.p(e)))
            )
          }
          if (
            Arr.isNonEmptyReadonlyArray(head) &&
            Arr.isEmptyReadonlyArray(Arr.tailNonEmpty(head))
          ) {
            const value = Arr.headNonEmpty(head)
            return InternalPrimitive.validate(self.primitiveType, Option.some(value), config).pipe(
              Effect.mapError((e) => InternalValidationError.invalidValue(InternalHelpDoc.p(e)))
            )
          }
          return Effect.fail(
            InternalValidationError.multipleValuesDetected(InternalHelpDoc.empty, head)
          )
        }
        const error = InternalHelpDoc.p(
          `More than one reference to option '${self.fullName}' detected`
        )
        return Effect.fail(InternalValidationError.invalidValue(error))
      }
      const error = InternalHelpDoc.p(`Expected to find option: '${self.fullName}'`)
      return Effect.fail(InternalValidationError.missingValue(error))
    }
    case "KeyValueMap": {
      const extractKeyValue = (
        value: string
      ): Effect.Effect<[string, string], ValidationError.ValidationError> => {
        const split = value.trim().split(keyValueSplitter, 2)
        if (Arr.isNonEmptyReadonlyArray(split) && split.length === 2 && split[1] !== "") {
          return Effect.succeed(split as unknown as [string, string])
        }
        const error = InternalHelpDoc.p(`Expected a key/value pair but received '${value}'`)
        return Effect.fail(InternalValidationError.invalidArgument(error))
      }
      return parseInternal(self.argumentOption, args, config).pipe(Effect.matchEffect({
        onFailure: (e) =>