@clerc/utils 0.43.0 → 1.0.0-beta.1

package/dist/index.d.ts

@@ -1,25 +1,32 @@
-import * as _clerc_core from '@clerc/core';
-import { I18N, Commands, CommandType, TranslateFn, Command, RootType, Root } from '@clerc/core';
-
-type Equals<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
-type Dict<T> = Record<string, T>;
+//#region src/types/type-fest.d.ts
+type LiteralUnion<LiteralType, BaseType> = LiteralType | (BaseType & Record<never, never>);
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+type BuiltIns = Primitive | void | Date | RegExp;
+type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown) | Promise<unknown>;
+type UnknownArray = readonly unknown[];
+type MapsSetsOrArrays = ReadonlyMap<unknown, unknown> | WeakMap<WeakKey, unknown> | ReadonlySet<unknown> | WeakSet<WeakKey> | UnknownArray;
+type ConditionalDeepPrettify<T, E = never, I$1 = unknown> = T extends E ? T : T extends I$1 ? { [TypeKey in keyof T]: ConditionalDeepPrettify<T[TypeKey], E, I$1> } : T;
+type DeepPrettify<T, E = never> = ConditionalDeepPrettify<T, E | NonRecursiveType | MapsSetsOrArrays, object>;
+//#endregion
+//#region src/types/index.d.ts
 type ToArray<T> = T extends any[] ? T : [T];
 type MaybeArray<T> = T | T[];
+type PartialRequired<T, K$1 extends keyof T> = T & { [P in K$1]-?: T[P] };
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+//#endregion
+//#region src/index.d.ts
 declare const toArray: <T>(a: MaybeArray<T>) => T[];
-type AlphabetLowercase = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z";
-type Numeric = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
-type AlphaNumeric = AlphabetLowercase | Uppercase<AlphabetLowercase> | Numeric;
-type CamelCase<Word extends string> = Word extends `${infer FirstCharacter}${infer Rest}` ? FirstCharacter extends AlphaNumeric ? `${FirstCharacter}${CamelCase<Rest>}` : Capitalize<CamelCase<Rest>> : Word;
-declare const camelCase: (word: string) => string;
-type KebabCase<T extends string, A extends string = ""> = T extends `${infer Prefix}${infer Suffix}` ? KebabCase<Suffix, `${A}${Prefix extends Lowercase<Prefix> ? "" : "-"}${Lowercase<Prefix>}`> : A;
-declare const kebabCase: <T extends string>(s: T) => KebabCase<T, "">;
-declare const gracefulFlagName: (n: string) => string;
-declare const gracefulVersion: (v: string) => string;
-declare function arrayEquals<T>(arr1: T[], arr2: T[]): boolean;
-declare function arrayStartsWith<T>(arr: T[], start: T[]): boolean;
-declare function semanticArray(arr: string[], { add, t }: I18N): string;
-declare function resolveCommandStrict(commands: Commands, name: CommandType | string[], t: TranslateFn): [Command<string | RootType> | undefined, string[] | RootType | undefined];
-declare function resolveSubcommandsByParent(commands: Commands, parent: string | string[], depth?: number): Command<string, _clerc_core.CommandOptions<string[], MaybeArray<string | typeof Root>, _clerc_core.Flags>>[];
-declare const resolveRootCommands: (commands: Commands) => Command<string, _clerc_core.CommandOptions<string[], MaybeArray<string | typeof Root>, _clerc_core.Flags>>[];
-
-export { CamelCase, Dict, Equals, KebabCase, MaybeArray, ToArray, arrayEquals, arrayStartsWith, camelCase, gracefulFlagName, gracefulVersion, kebabCase, resolveCommandStrict, resolveRootCommands, resolveSubcommandsByParent, semanticArray, toArray };
+/**
+* Converts a dash-separated string to camelCase.
+* Not using regexp for better performance, because this function is used in parser.
+*/
+declare function camelCase(str: string): string;
+declare function joinWithAnd(values: string[]): string;
+declare const kebabCase: <T extends string>(s: T) => string;
+declare const formatFlagName: (n: string) => string;
+declare const formatVersion: (v: string) => string;
+declare const isTruthy: <T>(item: T) => item is Exclude<T, false | null | undefined>;
+declare const objectIsEmpty: (obj: Record<string, any>) => boolean;
+//#endregion
+export { DeepPrettify, LiteralUnion, MaybeArray, PartialRequired, Prettify, ToArray, UnionToIntersection, camelCase, formatFlagName, formatVersion, isTruthy, joinWithAnd, kebabCase, objectIsEmpty, toArray };

package/dist/index.js

@@ -1,64 +1,36 @@
-import { Root, resolveFlattenCommands } from '@clerc/core';
-
-const locales = {
-  "en": {
-    "utils.and": "%s and %s"
-  },
-  "zh-CN": {
-    "utils.and": "%s \u548C %s"
-  }
-};
-
+//#region src/index.ts
 const toArray = (a) => Array.isArray(a) ? a : [a];
-const camelCase = (word) => word.replace(/[\W_]([a-z\d])?/gi, (_, c) => c ? c.toUpperCase() : "");
-const kebabCase = (s) => s.replace(/([A-Z])/g, (_, c) => `-${c.toLowerCase()}`);
-const gracefulFlagName = (n) => n.length <= 1 ? `-${n}` : `--${kebabCase(n)}`;
-const gracefulVersion = (v) => v.length === 0 ? "" : v.startsWith("v") ? v : `v${v}`;
-function arrayEquals(arr1, arr2) {
-  if (arr2.length !== arr1.length) {
-    return false;
-  }
-  return arr1.every((item, i) => item === arr2[i]);
-}
-function arrayStartsWith(arr, start) {
-  if (start.length > arr.length) {
-    return false;
-  }
-  return arrayEquals(arr.slice(0, start.length), start);
+/**
+* Converts a dash-separated string to camelCase.
+* Not using regexp for better performance, because this function is used in parser.
+*/
+function camelCase(str) {
+	const dashIdx = str.indexOf("-");
+	if (dashIdx === -1) return str;
+	let result = str.slice(0, dashIdx);
+	for (let i = dashIdx; i < str.length; i++) if (str[i] === "-" && i + 1 < str.length) {
+		const nextChar = str.charCodeAt(i + 1);
+		if (nextChar >= 97 && nextChar <= 122) {
+			result += String.fromCharCode(nextChar - 32);
+			i++;
+		} else {
+			result += str[i + 1];
+			i++;
+		}
+	} else if (str[i] !== "-") result += str[i];
+	return result;
 }
-function semanticArray(arr, { add, t }) {
-  add(locales);
-  if (arr.length <= 1) {
-    return arr[0];
-  }
-  return t("utils.and", arr.slice(0, -1).join(", "), arr[arr.length - 1]);
+function joinWithAnd(values) {
+	if (values.length === 0) return "";
+	if (values.length === 1) return values[0];
+	const last = values.pop();
+	return `${values.join(", ")} and ${last}`;
 }
-function resolveCommandStrict(commands, name, t) {
-  if (name === Root) {
-    return [commands[Root], Root];
-  }
-  const nameArr = toArray(name);
-  const commandsMap = resolveFlattenCommands(commands, t);
-  let current;
-  let currentName;
-  for (const [k, v] of commandsMap.entries()) {
-    if (k === Root || currentName === Root) {
-      continue;
-    }
-    if (arrayEquals(nameArr, k)) {
-      current = v;
-      currentName = k;
-    }
-  }
-  return [current, currentName];
-}
-function resolveSubcommandsByParent(commands, parent, depth = Infinity) {
-  const parentArr = parent === "" ? [] : Array.isArray(parent) ? parent : parent.split(" ");
-  return Object.values(commands).filter((c) => {
-    const commandNameArr = c.name.split(" ");
-    return arrayStartsWith(commandNameArr, parentArr) && commandNameArr.length - parentArr.length <= depth;
-  });
-}
-const resolveRootCommands = (commands) => resolveSubcommandsByParent(commands, "", 1);
+const kebabCase = (s) => s.replace(/([A-Z])/g, (_, c) => `-${c.toLowerCase()}`);
+const formatFlagName = (n) => n.length <= 1 ? `-${n}` : `--${kebabCase(n)}`;
+const formatVersion = (v) => v.length === 0 ? "" : v.startsWith("v") ? v : `v${v}`;
+const isTruthy = Boolean;
+const objectIsEmpty = (obj) => Object.keys(obj).length === 0;
 
-export { arrayEquals, arrayStartsWith, camelCase, gracefulFlagName, gracefulVersion, kebabCase, resolveCommandStrict, resolveRootCommands, resolveSubcommandsByParent, semanticArray, toArray };
+//#endregion
+export { camelCase, formatFlagName, formatVersion, isTruthy, joinWithAnd, kebabCase, objectIsEmpty, toArray };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clerc/utils",
-  "version": "0.43.0",
+  "version": "1.0.0-beta.1",
   "author": "Ray <i@mk1.io> (https://github.com/so1ve)",
   "type": "module",
   "description": "Clerc utils",
@@ -12,7 +12,6 @@
     "clerc-utils",
     "cli",
     "terminal",
-    "utils",
     "utils"
   ],
   "homepage": "https://github.com/clercjs/clerc/tree/main/packages/utils#readme",
@@ -27,28 +26,30 @@
   "license": "MIT",
   "sideEffects": false,
   "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
+    ".": "./dist/index.js"
   },
-  "main": "dist/index.js",
-  "module": "dist/index.js",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
   "types": "dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "*": [
+        "./dist/*",
+        "./dist/index.d.ts"
+      ]
+    }
+  },
   "files": [
     "dist"
   ],
   "publishConfig": {
     "access": "public"
   },
-  "devDependencies": {
-    "type-fest": "^4.3.1"
-  },
   "peerDependencies": {
     "@clerc/core": "*"
   },
   "scripts": {
-    "build": "pkgroll",
-    "watch": "pkgroll --watch"
+    "build": "tsdown",
+    "watch": "tsdown --watch"
   }
 }