effect-start 0.25.0 → 0.27.0

package/dist/Commander.js

@@ -1,410 +0,0 @@
-import * as Data from "effect/Data"
-import * as Effect from "effect/Effect"
-import * as Pipeable from "effect/Pipeable"
-import * as Predicate from "effect/Predicate"
-import * as Schema from "effect/Schema"
-
-export class CommanderError extends Data.TaggedError("CommanderError") {}
-
-const TypeId = Symbol.for("effect-start/Commander")
-
-export const option = (
-  long,
-  short,
-) => {
-  const longName = long
-  const shortName = short ? short.slice(1) : undefined
-
-  return {
-    schema: (schema) => ({
-      _tag: /** @type {const} */ "OptionBuilder",
-      name: longName,
-      long: longName,
-      short: shortName,
-      description: "",
-      schema,
-    }),
-
-    description: (desc) => ({
-      schema: (schema) => ({
-        _tag: /** @type {const} */ "OptionBuilder",
-        name: longName,
-        long: longName,
-        short: shortName,
-        description: desc,
-        schema,
-      }),
-
-      default: (value) => ({
-        schema: (schema) => ({
-          _tag: /** @type {const} */ "OptionBuilder",
-          name: longName,
-          long: longName,
-          short: shortName,
-          description: desc,
-          schema,
-          defaultValue: value,
-        }),
-      }),
-    }),
-
-    default: (value) => ({
-      schema: (schema) => ({
-        _tag: /** @type {const} */ "OptionBuilder",
-        name: longName,
-        long: longName,
-        short: shortName,
-        description: "",
-        schema,
-        defaultValue: value,
-      }),
-
-      description: (desc) => ({
-        schema: (schema) => ({
-          _tag: /** @type {const} */ "OptionBuilder",
-          name: longName,
-          long: longName,
-          short: shortName,
-          description: desc,
-          schema,
-          defaultValue: value,
-        }),
-      }),
-    }),
-  }
-}
-
-const optionMethod = function (
-  opt,
-) {
-  const base = (this && typeof this === "object" ? this : {})
-  const baseName = base.name ?? ""
-  const baseOptions = base.options ?? {}
-  const baseSubcommands = base.subcommands ?? []
-  const baseDescription = base.description
-  const baseVersion = base.version
-
-  const camelKey = kebabToCamel(stripPrefix(opt.long))
-
-  return makeSet({
-    name: baseName,
-    description: baseDescription,
-    version: baseVersion,
-    options: { ...baseOptions, [camelKey]: opt },
-    subcommands: baseSubcommands,
-  })
-}
-
-export const optionHelp = function (
-  ) {
-  const base = (this && typeof this === "object" ? this : {})
-  const baseName = base.name ?? ""
-  const baseOptions = base.options ?? {}
-  const baseSubcommands = base.subcommands ?? []
-  const baseDescription = base.description
-  const baseVersion = base.version
-
-  const helpOption = {
-    _tag: "OptionBuilder",
-    name: "--help",
-    long: "--help",
-    short: "h",
-    description: "Show help information",
-    defaultValue: false,
-  }
-
-  return makeSet({
-    name: baseName,
-    description: baseDescription,
-    version: baseVersion,
-    options: { ...baseOptions, help: helpOption },
-    subcommands: baseSubcommands,
-  })
-}
-
-export const optionVersion = function (
-  ) {
-  const base = (this && typeof this === "object" ? this : {})
-  const baseName = base.name ?? ""
-  const baseOptions = base.options ?? {}
-  const baseSubcommands = base.subcommands ?? []
-  const baseDescription = base.description
-  const baseVersion = base.version
-
-  const versionOption = {
-    _tag: "OptionBuilder",
-    name: "--version",
-    long: "--version",
-    short: "V",
-    description: "Show version information",
-    defaultValue: false,
-  }
-
-  return makeSet({
-    name: baseName,
-    description: baseDescription,
-    version: baseVersion,
-    options: { ...baseOptions, version: versionOption },
-    subcommands: baseSubcommands,
-  })
-}
-
-export const subcommand = function (
-  cmd,
-) {
-  const base = (this && typeof this === "object" ? this : {})
-  const baseName = base.name ?? ""
-  const baseOptions = base.options ?? {}
-  const baseSubcommands = base.subcommands ?? []
-  const baseDescription = base.description
-  const baseVersion = base.version
-
-  const subDef = {
-    _tag: "SubcommandDef",
-    command: cmd,
-  }
-
-  return makeSet({
-    name: baseName,
-    description: baseDescription,
-    version: baseVersion,
-    options: baseOptions,
-    subcommands: [...baseSubcommands, subDef],
-  })
-}
-
-export const handle = function (
-  handler,
-) {
-  const base = this
-
-  return makeSet({
-    name: base.name,
-    description: base.description,
-    version: base.version,
-    options: base.options,
-    subcommands: base.subcommands,
-    handler,
-  })
-}
-
-export const make = (config) =>
-  makeSet({
-    name: config.name,
-    description: config.description,
-    version: config.version,
-    options: {},
-    subcommands: [],
-  })
-
-const CommanderProto = {
-  [TypeId]: TypeId,
-
-  option: optionMethod,
-  optionHelp,
-  optionVersion,
-  subcommand,
-  handle,
-
-  pipe() {
-    return Pipeable.pipeArguments(this, arguments)
-  },
-}
-
-function makeSet(config) {
-  return Object.assign(Object.create(CommanderProto), config)
-}
-
-export function isCommanderSet(input) {
-  return Predicate.hasProperty(input, TypeId)
-}
-
-const kebabToCamel = (str) => {
-  return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase())
-}
-
-const stripPrefix = (str) => {
-  if (str.startsWith("--")) return str.slice(2)
-  if (str.startsWith("-")) return str.slice(1)
-  return str
-}
-
-const parseRawArgs = (args) =>
-  Effect.gen(function* () {
-    const flags = {}
-    const options = {}
-    const positional = []
-
-    let i = 0
-    while (i < args.length) {
-      const arg = args[i]
-
-      if (arg === "--") {
-        positional.push(...args.slice(i + 1))
-        break
-      }
-
-      if (arg.startsWith("--")) {
-        const equalIndex = arg.indexOf("=")
-        if (equalIndex !== -1) {
-          const key = arg.slice(2, equalIndex)
-          const value = arg.slice(equalIndex + 1)
-          options[key] = value
-        } else {
-          const key = arg.slice(2)
-          if (i + 1 < args.length && !args[i + 1].startsWith("-")) {
-            options[key] = args[i + 1]
-            i++
-          } else {
-            flags[key] = true
-          }
-        }
-      } else if (arg.startsWith("-") && arg.length > 1) {
-        const chars = arg.slice(1)
-        for (let j = 0; j < chars.length; j++) {
-          const char = chars[j]
-          if (j === chars.length - 1 && i + 1 < args.length && !args[i + 1].startsWith("-")) {
-            options[char] = args[i + 1]
-            i++
-          } else {
-            flags[char] = true
-          }
-        }
-      } else {
-        positional.push(arg)
-      }
-
-      i++
-    }
-
-    return { flags, options, positional }
-  })
-
-export const parse = (
-  cmd,
-  args,
-) =>
-  Effect.gen(function* () {
-    const parsed = yield* parseRawArgs(args)
-
-    const result = {}
-
-    for (const optBuilder of Object.values(cmd.options)) {
-      const longName = stripPrefix(optBuilder.long)
-      const shortName = optBuilder.short
-
-      const longMatch = parsed.options[longName] || parsed.flags[longName]
-      const shortMatch = shortName
-        ? parsed.options[shortName] || parsed.flags[shortName]
-        : undefined
-
-      const rawValue = longMatch ?? shortMatch
-
-      const camelKey = kebabToCamel(stripPrefix(optBuilder.long))
-
-      if (rawValue !== undefined) {
-        if (typeof rawValue === "boolean") {
-          result[camelKey] = rawValue
-        } else if (optBuilder.schema) {
-          const decoded = yield* Schema.decode(optBuilder.schema)(rawValue).pipe(
-            Effect.mapError(
-              (error) =>
-                new CommanderError({
-                  message: `Invalid value for option ${optBuilder.long}: ${error.message}`,
-                  cause: error,
-                }),
-            ),
-          )
-          result[camelKey] = decoded
-        } else {
-          result[camelKey] = rawValue
-        }
-      } else if (optBuilder.defaultValue !== undefined) {
-        result[camelKey] = optBuilder.defaultValue
-      }
-    }
-
-    return result
-  })
-
-export const runMain = (
-  cmd,
-) =>
-  Effect.gen(function* () {
-    const args = typeof process !== "undefined" ? process.argv.slice(2) : []
-
-    const parsedOptions = yield* parse(cmd, args)
-
-    if (Predicate.hasProperty(parsedOptions, "help") && parsedOptions.help) {
-      console.log(generateHelp(cmd))
-      return
-    }
-
-    if (Predicate.hasProperty(parsedOptions, "version") && parsedOptions.version && cmd.version) {
-      console.log(`${cmd.name} v${cmd.version}`)
-      return
-    }
-
-    if (cmd.handler) {
-      yield* cmd.handler(parsedOptions)
-    }
-  })
-
-const generateHelp = (
-  cmd,
-) => {
-  const lines = []
-
-  if (cmd.description) {
-    lines.push(cmd.description)
-    lines.push("")
-  }
-
-  lines.push(`Usage: ${cmd.name} [options]`)
-  lines.push("")
-
-  const optionsArray = Object.values(cmd.options)
-  if (optionsArray.length > 0) {
-    lines.push("Options:")
-
-    for (const opt of optionsArray) {
-      const short = opt.short ? `-${opt.short}, ` : "    "
-      const long = opt.long
-      const hasValue = opt.schema !== undefined
-      const name = hasValue ? `${long} <value>` : long
-      lines.push(`  ${short}${name.padEnd(20)} ${opt.description}`)
-    }
-
-    lines.push("")
-  }
-
-  if (cmd.subcommands.length > 0) {
-    lines.push("Commands:")
-    for (const sub of cmd.subcommands) {
-      const subCmd = sub.command
-      lines.push(`  ${subCmd.name.padEnd(20)} ${subCmd.description || ""}`)
-    }
-    lines.push("")
-  }
-
-  return lines.join("\n")
-}
-
-export const help = (
-  cmd,
-) => generateHelp(cmd)
-
-export const NumberFromString = Schema.NumberFromString
-
-export const choice = (
-  choices,
-) => Schema.Literal(...choices)
-
-export const repeatable = (
-  schema,
-) =>
-  Schema.transform(Schema.String, Schema.Array(Schema.String), {
-    strict: true,
-    decode: (s) => s.split(",").map((part) => part.trim()),
-    encode: (arr) => arr.join(","),
-  }).pipe(Schema.compose(Schema.Array(schema)))