effect-start 0.23.1 → 0.26.0

package/dist/Commander.d.ts

@@ -1,100 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Pipeable from "effect/Pipeable";
-import * as Schema from "effect/Schema";
-declare const CommanderError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
-    readonly _tag: "CommanderError";
-} & Readonly<A>;
-export declare class CommanderError extends CommanderError_base<{
-    message: string;
-    cause?: unknown;
-}> {
-}
-declare const TypeId: unique symbol;
-type KebabToCamel<S extends string> = S extends `${infer First}-${infer Rest}` ? `${First}${KebabToCamel<Capitalize<Rest>>}` : S;
-type StripPrefix<S extends string> = S extends `--${infer Name}` ? Name : S extends `-${infer Name}` ? Name : S;
-type OptionNameToCamelCase<S extends string> = KebabToCamel<StripPrefix<S>>;
-export interface OptionBuilder<A = any, Name extends string = string> {
-    readonly _tag: "OptionBuilder";
-    readonly name: Name;
-    readonly long: Name;
-    readonly short?: string;
-    readonly description: string;
-    readonly schema?: Schema.Schema<A, any>;
-    readonly defaultValue?: A;
-}
-type OptionBuilderWithSchema<A, Name extends string> = Omit<OptionBuilder<A, Name>, "schema" | "defaultValue"> & {
-    readonly schema: Schema.Schema<A, any>;
-    readonly defaultValue?: A;
-};
-export declare const option: <const Long extends `--${string}`, const Short extends `-${string}` | undefined = undefined>(long: Long, short?: Short) => {
-    schema<A, I extends string = string>(schema: Schema.Schema<A, I>): OptionBuilderWithSchema<A, Long>;
-    description(desc: string): {
-        schema<A, I_1 extends string = string>(schema: Schema.Schema<A, I_1>): OptionBuilderWithSchema<A, Long>;
-        default<A>(value: A): {
-            schema<A2 extends A, I_2 extends string = string>(schema: Schema.Schema<A2, I_2>): OptionBuilderWithSchema<A2, Long>;
-        };
-    };
-    default<A>(value: A): {
-        schema<A2 extends A, I_3 extends string = string>(schema: Schema.Schema<A2, I_3>): OptionBuilderWithSchema<A2, Long>;
-        description(desc: string): {
-            schema<A2 extends A, I_4 extends string = string>(schema: Schema.Schema<A2, I_4>): OptionBuilderWithSchema<A2, Long>;
-        };
-    };
-};
-export type OptionsMap = Record<string, OptionBuilder<any, any>>;
-type ExtractOptionsFromBuilders<Opts extends OptionsMap> = {
-    [K in keyof Opts as Opts[K] extends OptionBuilder<any, infer Name> ? OptionNameToCamelCase<Name> : never]: Opts[K] extends OptionBuilder<infer A, any> ? A : never;
-};
-export type ExtractOptionValues<Opts extends OptionsMap> = ExtractOptionsFromBuilders<Opts>;
-export interface SubcommandDef<Handled extends boolean = boolean> {
-    readonly _tag: "SubcommandDef";
-    readonly command: CommanderSet<any, any, Handled>;
-}
-type Extend<S, NewOpts extends OptionsMap, NewSubs extends ReadonlyArray<SubcommandDef> = [], Handled extends boolean = false> = S extends CommanderSet<infer Opts, infer Subs, infer _H> ? CommanderSet<Opts & NewOpts, [...Subs, ...NewSubs], Handled> : CommanderSet<NewOpts, NewSubs, Handled>;
-type CommanderBuilder = {
-    option: typeof optionMethod;
-    optionHelp: typeof optionHelp;
-    optionVersion: typeof optionVersion;
-    subcommand: typeof subcommand;
-    handle: typeof handle;
-};
-export type CommanderSet<Opts extends OptionsMap = {}, Subcommands extends ReadonlyArray<SubcommandDef> = [], Handled extends boolean = false> = Pipeable.Pipeable & CommanderSet.Instance<Opts, Subcommands, Handled> & {
-    [TypeId]: typeof TypeId;
-} & CommanderBuilder;
-export declare namespace CommanderSet {
-    type Instance<Opts extends OptionsMap = {}, Subcommands extends ReadonlyArray<SubcommandDef> = [], Handled extends boolean = false> = {
-        readonly name: string;
-        readonly description?: string;
-        readonly version?: string;
-        readonly options: Opts;
-        readonly subcommands: Subcommands;
-        readonly handler?: Handled extends true ? (args: ExtractOptionValues<Opts>) => Effect.Effect<void> : never;
-    };
-    type Default = CommanderSet<{}, [], false>;
-    type Proto = {
-        [TypeId]: typeof TypeId;
-        pipe(): any;
-    } & CommanderBuilder;
-}
-declare const optionMethod: <S, Opt extends OptionBuilder<any, any>>(this: S, opt: Opt) => Extend<S, { [K in Opt["name"] as OptionNameToCamelCase<K>]: Opt; }>;
-export declare const optionHelp: <S>(this: S) => Extend<S, {
-    help: OptionBuilder<boolean, "--help">;
-}>;
-export declare const optionVersion: <S>(this: S) => Extend<S, {
-    version: OptionBuilder<boolean, "--version">;
-}>;
-export declare const subcommand: <S, SubOpts extends OptionsMap, SubSubs extends ReadonlyArray<SubcommandDef>, SubHandled extends boolean>(this: S, cmd: CommanderSet<SubOpts, SubSubs, SubHandled>) => Extend<S, {}, [SubcommandDef<SubHandled>]>;
-export declare const handle: <Opts extends OptionsMap, Subs extends ReadonlyArray<SubcommandDef>>(this: CommanderSet<Opts, Subs, false>, handler: (args: ExtractOptionValues<Opts>) => Effect.Effect<void>) => CommanderSet<Opts, Subs, true>;
-export declare const make: <const Name extends string>(config: {
-    readonly name: Name;
-    readonly description?: string;
-    readonly version?: string;
-}) => CommanderSet<{}, [], false>;
-export declare function isCommanderSet(input: unknown): input is CommanderSet<any, any, any>;
-export declare const parse: <Opts extends OptionsMap, Subs extends ReadonlyArray<SubcommandDef>, Handled extends boolean>(cmd: CommanderSet<Opts, Subs, Handled>, args: ReadonlyArray<string>) => Effect.Effect<ExtractOptionValues<Opts>, CommanderError>;
-export declare const runMain: <Opts extends OptionsMap, Subs extends ReadonlyArray<SubcommandDef>>(cmd: CommanderSet<Opts, Subs, true>) => Effect.Effect<void, CommanderError>;
-export declare const help: <Opts extends OptionsMap, Subs extends ReadonlyArray<SubcommandDef>, Handled extends boolean>(cmd: CommanderSet<Opts, Subs, Handled>) => string;
-export declare const NumberFromString: typeof Schema.NumberFromString;
-export declare const choice: <const Choices extends ReadonlyArray<string>>(choices: Choices) => Schema.Schema<Choices[number], string>;
-export declare const repeatable: <A>(schema: Schema.Schema<A, string>) => Schema.Schema<ReadonlyArray<A>, string>;
-export {};

package/dist/Commander.js

@@ -1,326 +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: "OptionBuilder",
-            name: longName,
-            long: longName,
-            short: shortName,
-            description: "",
-            schema,
-        }),
-        description: (desc) => ({
-            schema: (schema) => ({
-                _tag: "OptionBuilder",
-                name: longName,
-                long: longName,
-                short: shortName,
-                description: desc,
-                schema,
-            }),
-            default: (value) => ({
-                schema: (schema) => ({
-                    _tag: "OptionBuilder",
-                    name: longName,
-                    long: longName,
-                    short: shortName,
-                    description: desc,
-                    schema,
-                    defaultValue: value,
-                }),
-            }),
-        }),
-        default: (value) => ({
-            schema: (schema) => ({
-                _tag: "OptionBuilder",
-                name: longName,
-                long: longName,
-                short: shortName,
-                description: "",
-                schema,
-                defaultValue: value,
-            }),
-            description: (desc) => ({
-                schema: (schema) => ({
-                    _tag: "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)));

package/dist/ContentNegotiation.d.ts

@@ -1,12 +0,0 @@
-/**
- * RFC 7231 Content Negotiation compatible with Express/Node.js ecosystem.
- * Based on {@link https://github.com/jshttp/negotiator}
- */
-export declare function media(accept: string, available?: Array<string>): Array<string>;
-export declare function language(accept: string, available?: Array<string>): Array<string>;
-export declare function encoding(accept: string, available?: Array<string>): Array<string>;
-export declare function charset(accept: string, available?: Array<string>): Array<string>;
-export declare function headerMedia(headers: Headers, available?: Array<string>): Array<string>;
-export declare function headerLanguage(headers: Headers, available?: Array<string>): Array<string>;
-export declare function headerEncoding(headers: Headers, available?: Array<string>): Array<string>;
-export declare function headerCharset(headers: Headers, available?: Array<string>): Array<string>;