citty 0.1.5 → 0.2.0

package/LICENSE

@@ -19,18 +19,3 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
-
----
-
-Parser is based on https://github.com/lukeed/mri
-
-The MIT License (MIT)
-
-Copyright (c) Luke Edwards luke.edwards05@gmail.com (lukeed.com)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-

package/README.md

@@ -1,45 +1,35 @@
 # 🌆 citty
 
-[![npm version][npm-version-src]][npm-version-href]
-[![npm downloads][npm-downloads-src]][npm-downloads-href]
-[![bundle][bundle-src]][bundle-href]
-[![Codecov][codecov-src]][codecov-href]
-[![License][license-src]][license-href]
+<!-- automd:badges color=yellow bundlephobia -->
 
-> Elegant CLI Builder
+[![npm version](https://img.shields.io/npm/v/citty?color=yellow)](https://npmjs.com/package/citty)
+[![npm downloads](https://img.shields.io/npm/dm/citty?color=yellow)](https://npmjs.com/package/citty)
+[![bundle size](https://img.shields.io/bundlephobia/minzip/citty?color=yellow)](https://bundlephobia.com/package/citty)
 
-- Fast and lightweight argument parser based on [mri](https://github.com/lukeed/mri)
-- Smart value parsing with typecast, boolean shortcuts and unknown flag handling
+<!-- /automd -->
+
+Elegant CLI Builder
+
+- Zero dependency
+- Fast and lightweight argument parser (based on native [node utils](arg parser](https://nodejs.org/api/util.html#utilparseargsconfig))
+- Smart value parsing with typecast and boolean shortcuts
 - Nested sub-commands
 - Lazy and Async commands
-- Plugable and composable API
+- Pluggable and composable API
 - Auto generated usage and help
 
-🚧 This project is under heavy development. More features are coming soon!
-
 ## Usage
 
 Install package:
 
 ```sh
-# npm
-npm install citty
-
-# yarn
-yarn add citty
-
-# pnpm
-pnpm install citty
+npx nypm add -D citty
 ```
 
 Import:
 
 ```js
-// ESM
 import { defineCommand, runMain } from "citty";
-
-// CommonJS
-const { defineCommand, runMain } = require("citty");
 ```
 
 Define main command to run:
@@ -113,22 +103,3 @@ Renders usage and prints to the console
 ## License
 
 Made with 💛 Published under [MIT License](./LICENSE).
-
-Argument parser is based on [lukeed/mri](https://github.com/lukeed/mri) by Luke Edwards ([@lukeed](https://github.com/lukeed)).
-
-<!-- Badges -->
-
-<!-- Badges -->
-
-[npm-version-src]: https://img.shields.io/npm/v/citty?style=flat&colorA=18181B&colorB=F0DB4F
-[npm-version-href]: https://npmjs.com/package/citty
-[npm-downloads-src]: https://img.shields.io/npm/dm/citty?style=flat&colorA=18181B&colorB=F0DB4F
-[npm-downloads-href]: https://npmjs.com/package/citty
-[codecov-src]: https://img.shields.io/codecov/c/gh/unjs/citty/main?style=flat&colorA=18181B&colorB=F0DB4F
-[codecov-href]: https://codecov.io/gh/unjs/citty
-[bundle-src]: https://img.shields.io/bundlephobia/minzip/citty?style=flat&colorA=18181B&colorB=F0DB4F
-[bundle-href]: https://bundlephobia.com/result?p=citty
-[license-src]: https://img.shields.io/github/license/unjs/citty.svg?style=flat&colorA=18181B&colorB=F0DB4F
-[license-href]: https://github.com/unjs/citty/blob/main/LICENSE
-[jsdocs-src]: https://img.shields.io/badge/jsDocs.io-reference-18181B?style=flat&colorA=18181B&colorB=F0DB4F
-[jsdocs-href]: https://www.jsdocs.io/package/citty

package/dist/_chunks/libs/scule.mjs

@@ -0,0 +1,68 @@
+//#region node_modules/.pnpm/scule@1.3.0/node_modules/scule/dist/index.mjs
+const NUMBER_CHAR_RE = /\d/;
+const STR_SPLITTERS = [
+	"-",
+	"_",
+	"/",
+	"."
+];
+function isUppercase(char = "") {
+	if (NUMBER_CHAR_RE.test(char)) return;
+	return char !== char.toLowerCase();
+}
+function splitByCase(str, separators) {
+	const splitters = separators ?? STR_SPLITTERS;
+	const parts = [];
+	if (!str || typeof str !== "string") return parts;
+	let buff = "";
+	let previousUpper;
+	let previousSplitter;
+	for (const char of str) {
+		const isSplitter = splitters.includes(char);
+		if (isSplitter === true) {
+			parts.push(buff);
+			buff = "";
+			previousUpper = void 0;
+			continue;
+		}
+		const isUpper = isUppercase(char);
+		if (previousSplitter === false) {
+			if (previousUpper === false && isUpper === true) {
+				parts.push(buff);
+				buff = char;
+				previousUpper = isUpper;
+				continue;
+			}
+			if (previousUpper === true && isUpper === false && buff.length > 1) {
+				const lastChar = buff.at(-1);
+				parts.push(buff.slice(0, Math.max(0, buff.length - 1)));
+				buff = lastChar + char;
+				previousUpper = isUpper;
+				continue;
+			}
+		}
+		buff += char;
+		previousUpper = isUpper;
+		previousSplitter = isSplitter;
+	}
+	parts.push(buff);
+	return parts;
+}
+function upperFirst(str) {
+	return str ? str[0].toUpperCase() + str.slice(1) : "";
+}
+function lowerFirst(str) {
+	return str ? str[0].toLowerCase() + str.slice(1) : "";
+}
+function pascalCase(str, opts) {
+	return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => upperFirst(opts?.normalize ? p.toLowerCase() : p)).join("") : "";
+}
+function camelCase(str, opts) {
+	return lowerFirst(pascalCase(str || "", opts));
+}
+function kebabCase(str, joiner) {
+	return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => p.toLowerCase()).join(joiner ?? "-") : "";
+}
+
+//#endregion
+export { kebabCase as n, camelCase as t };

package/dist/index.d.mts

@@ -1,80 +1,101 @@
-type ArgType = "boolean" | "string" | "positional" | undefined;
-type _ArgDef<T extends ArgType, VT extends boolean | string> = {
-    type?: T;
-    description?: string;
-    valueHint?: string;
-    alias?: string | string[];
-    default?: VT;
-    required?: boolean;
+//#region src/types.d.ts
+type ArgType = "boolean" | "string" | "enum" | "positional" | undefined;
+type _ArgDef<T extends ArgType, VT extends boolean | number | string> = {
+  type?: T;
+  description?: string;
+  valueHint?: string;
+  alias?: string | string[];
+  default?: VT;
+  required?: boolean;
+  options?: string[];
 };
-type BooleanArgDef = _ArgDef<"boolean", boolean>;
-type StringArgDef = _ArgDef<"string", string>;
-type PositionalArgDef = Omit<_ArgDef<"positional", string>, "alias">;
-type ArgDef = BooleanArgDef | StringArgDef | PositionalArgDef;
+type BooleanArgDef = Omit<_ArgDef<"boolean", boolean>, "options"> & {
+  negativeDescription?: string;
+};
+type StringArgDef = Omit<_ArgDef<"string", string>, "options">;
+type EnumArgDef = _ArgDef<"enum", string>;
+type PositionalArgDef = Omit<_ArgDef<"positional", string>, "alias" | "options">;
+type ArgDef = BooleanArgDef | StringArgDef | PositionalArgDef | EnumArgDef;
 type ArgsDef = Record<string, ArgDef>;
 type Arg = ArgDef & {
-    name: string;
-    alias: string[];
+  name: string;
+  alias: string[];
+};
+type ResolveParsedArgType<T extends ArgDef, VT> = T extends {
+  default?: any;
+  required?: boolean;
+} ? T["default"] extends NonNullable<VT> ? VT : T["required"] extends true ? VT : VT | undefined : VT | undefined;
+type ParsedPositionalArg<T extends ArgDef> = T extends {
+  type: "positional";
+} ? ResolveParsedArgType<T, string> : never;
+type ParsedStringArg<T extends ArgDef> = T extends {
+  type: "string";
+} ? ResolveParsedArgType<T, string> : never;
+type ParsedBooleanArg<T extends ArgDef> = T extends {
+  type: "boolean";
+} ? ResolveParsedArgType<T, boolean> : never;
+type ParsedEnumArg<T extends ArgDef> = T extends {
+  type: "enum";
+  options: infer U;
+} ? U extends Array<any> ? ResolveParsedArgType<T, U[number]> : never : never;
+type RawArgs = {
+  _: string[];
 };
-type ParsedArgs<T extends ArgsDef = ArgsDef> = {
-    _: string[];
-} & Record<{
-    [K in keyof T]: T[K] extends {
-        type: "positional";
-    } ? K : never;
-}[keyof T], string> & Record<{
-    [K in keyof T]: T[K] extends {
-        type: "string";
-    } ? K : never;
-}[keyof T], string> & Record<{
-    [K in keyof T]: T[K] extends {
-        type: "boolean";
-    } ? K : never;
-}[keyof T], boolean> & Record<string, string | boolean | string[]>;
+type ParsedArg<T extends ArgDef> = T["type"] extends "positional" ? ParsedPositionalArg<T> : T["type"] extends "boolean" ? ParsedBooleanArg<T> : T["type"] extends "string" ? ParsedStringArg<T> : T["type"] extends "enum" ? ParsedEnumArg<T> : never;
+type ParsedArgs<T extends ArgsDef = ArgsDef> = RawArgs & { [K in keyof T]: ParsedArg<T[K]> } & { [K in keyof T as T[K] extends {
+  alias: string;
+} ? T[K]["alias"] : never]: ParsedArg<T[K]> } & { [K in keyof T as T[K] extends {
+  alias: string[];
+} ? T[K]["alias"][number] : never]: ParsedArg<T[K]> } & Record<string, string | number | boolean | string[]>;
 interface CommandMeta {
-    name?: string;
-    version?: string;
-    description?: string;
+  name?: string;
+  version?: string;
+  description?: string;
+  hidden?: boolean;
 }
 type SubCommandsDef = Record<string, Resolvable<CommandDef<any>>>;
 type CommandDef<T extends ArgsDef = ArgsDef> = {
-    meta?: Resolvable<CommandMeta>;
-    args?: Resolvable<T>;
-    subCommands?: Resolvable<SubCommandsDef>;
-    setup?: (context: CommandContext<T>) => any | Promise<any>;
-    cleanup?: (context: CommandContext<T>) => any | Promise<any>;
-    run?: (context: CommandContext<T>) => any | Promise<any>;
+  meta?: Resolvable<CommandMeta>;
+  args?: Resolvable<T>;
+  subCommands?: Resolvable<SubCommandsDef>;
+  setup?: (context: CommandContext<T>) => any | Promise<any>;
+  cleanup?: (context: CommandContext<T>) => any | Promise<any>;
+  run?: (context: CommandContext<T>) => any | Promise<any>;
 };
 type CommandContext<T extends ArgsDef = ArgsDef> = {
-    rawArgs: string[];
-    args: ParsedArgs<T>;
-    cmd: CommandDef<T>;
-    subCommand?: CommandDef<T>;
-    data?: any;
+  rawArgs: string[];
+  args: ParsedArgs<T>;
+  cmd: CommandDef<T>;
+  subCommand?: CommandDef<T>;
+  data?: any;
 };
 type Awaitable<T> = () => T | Promise<T>;
 type Resolvable<T> = T | Promise<T> | (() => T) | (() => Promise<T>);
-
-declare function defineCommand<T extends ArgsDef = ArgsDef>(def: CommandDef<T>): CommandDef<T>;
+//#endregion
+//#region src/command.d.ts
+declare function defineCommand<const T extends ArgsDef = ArgsDef>(def: CommandDef<T>): CommandDef<T>;
 interface RunCommandOptions {
-    rawArgs: string[];
-    data?: any;
-    showUsage?: boolean;
+  rawArgs: string[];
+  data?: any;
+  showUsage?: boolean;
 }
 declare function runCommand<T extends ArgsDef = ArgsDef>(cmd: CommandDef<T>, opts: RunCommandOptions): Promise<{
-    result: unknown;
+  result: unknown;
 }>;
-
+//#endregion
+//#region src/usage.d.ts
 declare function showUsage<T extends ArgsDef = ArgsDef>(cmd: CommandDef<T>, parent?: CommandDef<T>): Promise<void>;
 declare function renderUsage<T extends ArgsDef = ArgsDef>(cmd: CommandDef<T>, parent?: CommandDef<T>): Promise<string>;
-
+//#endregion
+//#region src/main.d.ts
 interface RunMainOptions {
-    rawArgs?: string[];
-    showUsage?: typeof showUsage;
+  rawArgs?: string[];
+  showUsage?: typeof showUsage;
 }
 declare function runMain<T extends ArgsDef = ArgsDef>(cmd: CommandDef<T>, opts?: RunMainOptions): Promise<void>;
 declare function createMain<T extends ArgsDef = ArgsDef>(cmd: CommandDef<T>): (opts?: RunMainOptions) => Promise<void>;
-
+//#endregion
+//#region src/args.d.ts
 declare function parseArgs<T extends ArgsDef = ArgsDef>(rawArgs: string[], argsDef: ArgsDef): ParsedArgs<T>;
-
-export { type Arg, type ArgDef, type ArgType, type ArgsDef, type Awaitable, type BooleanArgDef, type CommandContext, type CommandDef, type CommandMeta, type ParsedArgs, type PositionalArgDef, type Resolvable, type RunCommandOptions, type RunMainOptions, type StringArgDef, type SubCommandsDef, type _ArgDef, createMain, defineCommand, parseArgs, renderUsage, runCommand, runMain, showUsage };
+//#endregion
+export { Arg, ArgDef, ArgType, ArgsDef, Awaitable, BooleanArgDef, CommandContext, CommandDef, CommandMeta, EnumArgDef, ParsedArgs, PositionalArgDef, Resolvable, type RunCommandOptions, type RunMainOptions, StringArgDef, SubCommandsDef, _ArgDef, createMain, defineCommand, parseArgs, renderUsage, runCommand, runMain, showUsage };