@planet-matrix/mobius-model 0.4.0 → 0.6.0

package/src/basic/is.ts

@@ -13,81 +13,140 @@ import type {
 
 /**
  * 进行类型检测的常用手段包括：
- *   - typeof: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof
+ *  - typeof: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof
  *             https://tc39.es/ecma262/#sec-typeof-operator
- *   - instanceof: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof
- *   - toString: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString
+ *  - instanceof: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof
+ *  - toString: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString
  *
- * - `typeof` operator can operate on non-exist variable.
+ * 检测可能不存在的变量：
+ *  - typeof value === "undefined"
+ *  - globalThis.value === undefined
  */
 
 /**
- *
+ * 判断目标值是否为原始值（primitive）。
  */
 export const isPrimitive = (target: unknown): target is Primitive => {
   return isString(target) || isNumber(target) || isBoolean(target) || isBigInt(target) || isSymbol(target) || isNull(target) || isUndefined(target)
 }
+
+/**
+ * 判断目标值是否为非原始值（non-primitive）。
+ */
 export const isNonPrimitive = (target: unknown): target is NonPrimitive => {
   return isPrimitive(target) === false
 }
+
+/**
+ * 判断目标值是否为字符串。
+ */
 export const isString = (target: unknown): target is string => {
   return Object.prototype.toString.call(target) === "[object String]"
 }
+
+/**
+ * 判断目标值是否为数字。
+ */
 export const isNumber = (target: unknown): target is number => {
   return Object.prototype.toString.call(target) === "[object Number]" && isNaN(Number.parseFloat(String(target)))
 }
+
+/**
+ * 判断目标值是否为 `NaN`。
+ */
 export const isNaN = (target: unknown): boolean => {
   return Number.isNaN(target)
 }
+
+/**
+ * 判断目标值是否为有限数字。
+ */
 export const isFiniteNumber = (target: unknown): target is number => {
   return isNumber(target) && Number.isFinite(target)
 }
+
+/**
+ * 判断目标值是否为无限数字。
+ */
 export const isInfiniteNumber = (target: unknown): target is number => {
   return isNumber(target) && !Number.isFinite(target)
 }
+
+/**
+ * 判断目标值是否为布尔值。
+ */
 export const isBoolean = (target: unknown): target is boolean => {
   return Object.prototype.toString.call(target) === "[object Boolean]"
 }
+
+/**
+ * 判断目标值是否为 `true`。
+ */
 export const isTrue = (target: unknown): target is true => {
   return isBoolean(target) && target === true
 }
+
+/**
+ * 判断目标值是否为 `false`。
+ */
 export const isFalse = (target: unknown): target is false => {
   return isBoolean(target) && target === false
 }
+
+/**
+ * 判断目标值是否为大整数（BigInt）。
+ */
 export const isBigInt = (target: unknown): target is bigint => {
   return Object.prototype.toString.call(target) === "[object BigInt]"
 }
+
+/**
+ * 判断目标值是否为符号（Symbol）。
+ */
 export const isSymbol = (target: unknown): target is symbol => {
   return Object.prototype.toString.call(target) === "[object Symbol]"
 }
+
+/**
+ * 判断目标值是否为 `null`。
+ */
 export const isNull = (target: unknown): target is null => {
   return Object.prototype.toString.call((target)) === "[object Null]"
 }
+
+/**
+ * 判断目标值是否为 `undefined`。
+ */
 export const isUndefined = (target: unknown): target is undefined => {
   return Object.prototype.toString.call(target) === "[object Undefined]"
 }
 /**
+ * 判断目标值是否不是 `undefined`。
+ *
  * @see {@link https://stackoverflow.com/a/52097700}
  */
 export const isDefined = <T>(target: T | undefined): target is T => {
   return isUndefined(target) === false
 }
+
+/**
+ * 判断目标值是否为 `null` 或 `undefined`。
+ */
 export const isNil = (target: unknown): target is (null | undefined) => {
   return target === null || target === undefined
 }
 
 /**
- * Predicate whether the target is an Object, use `instanceof` operator to check.
+ * 使用 `instanceof` 判断目标值是否为对象。
  *
  * @see {@link isGeneralObject}, {@link isPlainObject}
  */
 // oxlint-disable-next-line no-wrapper-object-types
 export const isObject = (target: unknown): target is Object => {
-  // oxlint-disable-next-line no-instanceof-builtins
   return target instanceof Object
 }
 /**
- * Predicate whether the target is a general object, use `typeof` operator to check.
+ * 使用 `typeof` 判断目标值是否为广义对象。
  *
  * A general object is an object that is:
  *  - not `null`, not a `function`, not a `primitive`.
@@ -97,17 +156,12 @@ export const isObject = (target: unknown): target is Object => {
  *
  * @example
  * ```
- * typeof null // => 'object'
- * typeof [] // => 'object'
- * typeof {} // => 'object'
- * typeof { a: 1 } // => 'object'
- * typeof (new Map()) // => 'object'
- * typeof (new WeakMap()) // => 'object'
- * typeof (new Set()) // => 'object'
- * typeof (new WeakSet()) // => 'object'
- * typeof (new Date()) // => 'object'
- * typeof window // => 'object'
- * typeof document // => 'object'
+ * // Expect: true
+ * const example1 = isGeneralObject([])
+ * // Expect: true
+ * const example2 = isGeneralObject(new Map())
+ * // Expect: false
+ * const example3 = isGeneralObject(null)
  * ```
  *
  * @see {@link isObject}, {@link isPlainObject}
@@ -141,88 +195,151 @@ export const isPlainObject = (target: unknown): target is PlainObject => {
   const proto = Object.getPrototypeOf(target)
   return proto === Object.prototype || proto === null
 }
+
+/**
+ * 判断目标值是否为空普通对象。
+ */
 export const isEmptyPlainObject = (target: unknown): target is PlainObject => {
   return isPlainObject(target) && Reflect.ownKeys(target).length === 0
 }
 
+/**
+ * 判断目标值是否为数组。
+ */
 export function isArray<T>(target: T[]): target is T[]
 export function isArray<T>(target: unknown): target is T[]
 export function isArray<T>(target: unknown): target is T[] {
   return Array.isArray(target)
 }
+
+/**
+ * 判断目标值是否为空数组。
+ */
 export const isEmptyArray = (target: unknown): target is [] => {
   return isArray(target) && target.length === 0
 }
 
+/**
+ * 判断目标值是否为类数组对象（array-like）。
+ */
 export function isArrayLike<T>(target: ArrayLike<T>): target is ArrayLike<T>
 export function isArrayLike<T>(target: unknown): target is ArrayLike<T>
 export function isArrayLike<T>(target: unknown): target is ArrayLike<T> {
   return isGeneralObject(target) && ("length" in target) && isNumber(target.length)
 }
 
+/**
+ * 判断目标值是否为 `Map`。
+ */
 export function isMap<K, V>(target: Map<K, V>): target is Map<K, V>
 export function isMap<K, V>(target: unknown): target is Map<K, V>
 export function isMap<K, V>(target: unknown): target is Map<K, V> {
   return Object.prototype.toString.call(target) === "[object Map]"
 }
 
+/**
+ * 判断目标值是否为 `WeakMap`。
+ */
 export function isWeakMap<K extends object, V>(target: WeakMap<K, V>): target is WeakMap<K, V>
 export function isWeakMap<K extends object, V>(target: unknown): target is WeakMap<K, V>
 export function isWeakMap<K extends object, V>(target: unknown): target is WeakMap<K, V> {
   return Object.prototype.toString.call(target) === "[object WeakMap]"
 }
 
+/**
+ * 判断目标值是否为 `Set`。
+ */
 export function isSet<T>(target: Set<T>): target is Set<T>
 export function isSet<T>(target: unknown): target is Set<T>
 export function isSet<T>(target: unknown): target is Set<T> {
   return Object.prototype.toString.call(target) === "[object Set]"
 }
 
+/**
+ * 判断目标值是否为 `WeakSet`。
+ */
 export function isWeakSet<T extends object>(target: WeakSet<T>): target is WeakSet<T>
 export function isWeakSet<T extends object>(target: unknown): target is WeakSet<T>
 export function isWeakSet<T extends object>(target: unknown): target is WeakSet<T> {
   return Object.prototype.toString.call(target) === "[object WeakSet]"
 }
 
+/**
+ * 判断目标值是否为 `Date`。
+ */
 export const isDate = (target: unknown): target is Date => {
   return Object.prototype.toString.call(target) === "[object Date]"
 }
 
+/**
+ * 判断目标值是否为 `RegExp`。
+ */
 export const isRegExp = (target: unknown): target is RegExp => {
   return Object.prototype.toString.call(target) === "[object RegExp]"
 }
 
+/**
+ * 判断目标值是否为 `Error`。
+ */
 export const isError = (target: unknown): target is Error => {
   return Object.prototype.toString.call(target) === "[object Error]"
 }
 
+/**
+ * 判断目标值是否为 `Promise`。
+ */
 export function isPromise<T>(target: Promise<T>): target is Promise<T>
 export function isPromise<T>(target: unknown): target is Promise<T>
 export function isPromise<T>(target: unknown): target is Promise<T> {
   return Object.prototype.toString.call(target) === "[object Promise]"
 }
 
+/**
+ * 判断目标值是否为任意函数。
+*/
 // oxlint-disable-next-line no-unsafe-function-type
 export const isFunction = (target: unknown): target is Function => {
   return typeof target === "function"
 }
+
+/**
+ * 判断目标值是否为任意同步或异步函数类型。
+ */
 export const isAnyFunction = (target: unknown): target is AnyFunction => {
   return isFunction(target)
 }
+
+/**
+ * 判断目标值是否为同步函数。
+ */
 export const isSyncFunction = (target: unknown): target is AnySyncFunction => {
   return Object.prototype.toString.call(target) === "[object Function]"
 }
+
+/**
+ * 判断目标值是否为异步函数。
+ */
 export const isAsyncFunction = (target: unknown): target is AnyAsyncFunction => {
   return Object.prototype.toString.call(target) === "[object AsyncFunction]"
 }
+
+/**
+ * 判断目标值是否为生成器函数。
+ */
 export const isGeneratorFunction = (target: unknown): target is AnyGeneratorFunction => {
   return Object.prototype.toString.call((target)) === "[object GeneratorFunction]"
 }
+
+/**
+ * 判断目标值是否为异步生成器函数。
+ */
 export const isAsyncGeneratorFunction = (target: unknown): target is AnyAsyncGeneratorFunction => {
   return Object.prototype.toString.call(target) === "[object AsyncGeneratorFunction]"
 }
 
 /**
+ * 判断目标值是否实现可迭代协议（iterable protocol）。
+ *
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#the_iterable_protocol}
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/iterator}
  */
@@ -233,6 +350,8 @@ export function isIterable<T>(target: unknown): target is Iterable<T> {
   return isGeneralObject(target) && typeof (target as any)[Symbol.iterator] === "function"
 }
 /**
+ * 判断目标值是否实现异步可迭代协议。
+ *
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/asyncIterator}
  */
 export function isAsyncIterable<T>(target: AsyncIterable<T>): target is AsyncIterable<T>
@@ -242,6 +361,8 @@ export function isAsyncIterable<T>(target: unknown): target is AsyncIterable<T>
   return isGeneralObject(target) && typeof (target as any)[Symbol.asyncIterator] === "function"
 }
 /**
+ * 判断目标值是否实现迭代器协议（iterator protocol）。
+ *
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#the_iterator_protocol}
  */
 export function isIterator<T, TReturn = unknown, TNext = undefined>(target: Iterator<T, TReturn, TNext>): target is Iterator<T, TReturn, TNext>
@@ -250,71 +371,31 @@ export function isIterator<T, TReturn = unknown, TNext = undefined>(target: unkn
   // oxlint-disable-next-line no-unsafe-type-assertion no-unsafe-member-access
   return isGeneralObject(target) && typeof (target as any).next === "function"
 }
+
+/**
+ * 判断目标值是否实现异步迭代器协议。
+ */
 export function isAsyncIterator<T, TReturn = unknown, TNext = undefined>(target: AsyncIterator<T, TReturn, TNext>): target is AsyncIterator<T, TReturn, TNext>
 export function isAsyncIterator<T, TReturn = unknown, TNext = undefined>(target: unknown): target is AsyncIterator<T, TReturn, TNext>
 export function isAsyncIterator<T, TReturn = unknown, TNext = undefined>(target: unknown): target is AsyncIterator<T, TReturn, TNext> {
   // oxlint-disable-next-line no-unsafe-type-assertion no-unsafe-member-access
   return isGeneralObject(target) && typeof (target as any).next === "function"
 }
+
+/**
+ * 判断目标值是否同时满足可迭代对象与迭代器的条件。
+ */
 export function isIterableIterator<T, TReturn = unknown, TNext = undefined>(target: IterableIterator<T>): target is IterableIterator<T, TReturn, TNext>
 export function isIterableIterator<T, TReturn = unknown, TNext = undefined>(target: unknown): target is IterableIterator<T, TReturn, TNext>
 export function isIterableIterator<T, TReturn = unknown, TNext = undefined>(target: unknown): target is IterableIterator<T> {
   return isIterator<T, TReturn, TNext>(target) && isIterable<T>(target)
 }
+
+/**
+ * 判断目标值是否同时满足异步可迭代对象与异步迭代器的条件。
+ */
 export function isAsyncIterableIterator<T, TReturn = unknown, TNext = undefined>(target: AsyncIterableIterator<T>): target is AsyncIterableIterator<T, TReturn, TNext>
 export function isAsyncIterableIterator<T, TReturn = unknown, TNext = undefined>(target: unknown): target is AsyncIterableIterator<T, TReturn, TNext>
 export function isAsyncIterableIterator<T, TReturn = unknown, TNext = undefined>(target: unknown): target is AsyncIterableIterator<T> {
   return isAsyncIterator<T, TReturn, TNext>(target) && isAsyncIterable<T>(target)
 }
-
-/**
- * Check `target` and `Window` is both defined
- * before use the `instanceof` operator to check `target` is instanceof `Window`.
- */
-export const isWindow = (target: unknown): target is Window => {
-  return isGeneralObject(target) && isDefined(Window) && target instanceof Window
-}
-/**
- * Check `target` and `Element` is both defined
- * before use the `instanceof` operator to check `target` is instanceof `Element`.
- */
-export const isElement = (target: unknown): target is Element => {
-  return isGeneralObject(target) && isDefined(Element) && target instanceof Element
-}
-/**
- * Check `target` and `Node` is both defined
- * before use the `instanceof` operator to check `target` is instanceof `Node`.
- */
-export const isNode = (target: unknown): target is Node => {
-  return isGeneralObject(target) && isDefined(Node) && target instanceof Node
-}
-/**
- * Check `target` and `HTMLElement` is both defined
- * before use the `instanceof` operator to check `target` is instanceof `HTMLElement`.
- */
-export const isHTMLElement = (target: unknown): target is HTMLElement => {
-  return isGeneralObject(target) && isDefined(HTMLElement) && target instanceof HTMLElement
-}
-/**
- * Check `target` and `HTMLCollection` is both defined
- * before use the `instanceof` operator to check `target` is instanceof `HTMLCollection`.
- */
-export const isHTMLCollection = (target: unknown): target is HTMLCollection => {
-  return isGeneralObject(target) && isDefined(HTMLCollection) && target instanceof HTMLCollection
-}
-/**
- * Check `target` and `Document` is both defined
- * before use the `instanceof` operator to check `target` is instanceof `Document`.
- */
-export const isDocument = (target: unknown): target is Document => {
-  return isGeneralObject(target) && isDefined(Document) && target instanceof Document
-}
-/**
- * Check `target` and `EventTarget` is both defined
- * before use the `instanceof` operator to check `target` is instanceof `EventTarget`.
- *
- * @see {@link https://developer.mozilla.org/zh-CN/docs/Web/API/Event}
- */
-export const isEventTarget = (target: unknown): target is EventTarget => {
-  return isGeneralObject(target) && isDefined(EventTarget) && target instanceof EventTarget
-}

package/src/basic/object.ts

@@ -1,4 +1,5 @@
 import type { AnyRecord } from "../type/index.ts"
+import { isDate } from "./is.ts"
 
 /**
  * Return a new object that includes only the specified keys from the source object.
@@ -56,3 +57,84 @@ export const excludeFields = <T extends AnyRecord, K extends keyof T>(
   // oxlint-disable-next-line no-unsafe-type-assertion
   return newObject as Omit<T, K> // 使用Omit类型确保返回的类型反映了被排除的键
 }
+
+/**
+ * Convert all Date fields in an object to number.
+ *
+ * @example
+ * ```before
+ * type Obj = {
+ *   createdAt: Date,
+ * }
+ * ```
+ * ```after
+ * type Obj = {
+ *   createdAt: number,
+ * }
+ * ```
+ *
+ * @example
+ * ```before
+ * type Obj = {
+ *   createdAt: Date | undefined,
+ * }
+ * ```
+ * ```after
+ * type Obj = {
+ *   createdAt: number | undefined,
+ * }
+ * ```
+ *
+ * @example
+ * ```before
+ * type Obj = {
+ *   createdAt: Date | null,
+ * }
+ * ```
+ * ```after
+ * type Obj = {
+ *   createdAt: number | null,
+ * }
+ * ```
+ */
+export type ObjectDateFieldsToNumber<O extends object> = {
+  [K in keyof O]: O[K] extends Date
+  ? number
+  : (
+    O[K] extends Date | undefined
+    ? number | undefined
+    :
+    (O[K] extends Date | null
+      ? number | null
+      : (
+        O[K] extends object
+        ? ObjectDateFieldsToNumber<O[K]>
+        : O[K]
+      )
+    )
+  )
+}
+/**
+ * Convert all Date fields in an object to number.
+ *
+ * @example
+ * ```
+ * const obj = { createdAt: new Date() };
+ * const result = objectDateFieldsToNumber(obj);
+ * // Expect: { createdAt: 1712345678901 }
+ * ```
+ */
+export const objectDateFieldsToNumber = <O extends Record<string | number | symbol, unknown>>(
+  obj: O
+): ObjectDateFieldsToNumber<O> => {
+  // oxlint-disable-next-line guard-for-in
+  for (const key in obj) {
+    const value = obj[key];
+    if (isDate(value)) {
+      // oxlint-disable-next-line no-unsafe-type-assertion
+      obj[key] = value.getTime() as O[Extract<keyof O, string>]
+    }
+  }
+  // oxlint-disable-next-line no-unsafe-type-assertion
+  return obj as ObjectDateFieldsToNumber<O>
+}

package/src/basic/promise.ts

@@ -56,32 +56,43 @@ export const promiseFinally = async <V>(
 }
 
 const INTERNAL_PROMISE_FAIL_RESULT_TYPE: symbol = Symbol("fail")
+
+/**
+ * 表示标准化的 Promise 失败结果。
+ */
 export interface PromiseFailResult {
   __type__: typeof INTERNAL_PROMISE_FAIL_RESULT_TYPE
   reason: unknown
 }
+
+/**
+ * 表示带原始下标信息的 Promise 失败结果。
+ */
 export interface PromiseIndexedFailResult extends PromiseFailResult {
   index: number
 }
+
+/**
+ * 根据拒因构造标准化的 Promise 失败结果。
+ */
 export const promiseConstructFailResult = (reason: unknown): PromiseFailResult => {
   return { __type__: INTERNAL_PROMISE_FAIL_RESULT_TYPE, reason }
 }
 /**
- * Predicate whether the target is a promise fail result.
+ * 判断目标值是否为标准化的 Promise 失败结果。
  */
 export const isPromiseFailResult = (target: unknown): target is PromiseFailResult => {
   return isPlainObject(target) && target["__type__"] === INTERNAL_PROMISE_FAIL_RESULT_TYPE
 }
 /**
- * Designed to use as `onrejected` callback of `Promise.catch`
- * to return a standard `PromiseFailResult`.
+ * 用作 `Promise.catch` 的 `onrejected` 回调，并返回标准化失败结果。
  */
 export const promiseCatchToFailResult = (reason: unknown): PromiseFailResult => {
   return { __type__: INTERNAL_PROMISE_FAIL_RESULT_TYPE, reason }
 }
 
 /**
- * Giving an array, filter non-`PromiseFailResult` items.
+ * 从结果数组中过滤出非 `PromiseFailResult` 项。
  */
 export const promiseFilterSuccessResults = <V>(
   results: Array<V | PromiseFailResult>,
@@ -93,8 +104,7 @@ export const promiseFilterSuccessResults = <V>(
   return filtered as V[]
 }
 /**
- * Giving a array, filter `PromiseFailResult` items, with extra `index` property
- * which indicate the index of the item in the original array.
+ * 从结果数组中过滤出失败项，并补充其原始下标。
  */
 export const promiseFilterFailResults = <V>(
   results: Array<V | PromiseFailResult>,
@@ -125,8 +135,12 @@ type PromiseQueueFirstPromiseMaker<T, S = unknown> = (context: PromiseQueueFirst
 type PromiseQueueRestPromiseMaker<T, S = unknown> = (context: PromiseQueueRestPromiseMakerContext<T, S>) => Promise<T>
 type PromiseQueuePromiseMakers<T, S = unknown> = [
   PromiseQueueFirstPromiseMaker<T, S>,
-  ...PromiseQueueRestPromiseMaker<T, S>[]
+  ...Array<PromiseQueueRestPromiseMaker<T, S>>
 ]
+
+/**
+ * `promiseQueue` 的配置项。
+ */
 export interface PromiseQueueOptions {
   /**
    * @default 0
@@ -204,6 +218,10 @@ interface PromiseRetryRestPromiseMakerContext<T, S = unknown> {
 type PromiseRetryPromiseMaker<T, S = unknown> = (
   context: PromiseRetryFirstPromiseMakerContext<S> | PromiseRetryRestPromiseMakerContext<T, S>
 ) => Promise<T>
+
+/**
+ * `promiseRetryWhile` 与 `promiseRetryUntil` 的配置项。
+ */
 export interface PromiseRetryOptions {
   /**
    * @default 0
@@ -387,6 +405,10 @@ interface PromiseForeverRestPromiseMakerContext<T, S = unknown> {
 type PromiseForeverPromiseMaker<T, S = unknown> = (
   context: PromiseForeverFirstPromiseMakerContext<S> | PromiseForeverRestPromiseMakerContext<T, S>
 ) => Promise<T>
+
+/**
+ * `promiseForever` 的配置项。
+ */
 export interface PromiseForeverOptions {
   /**
    * @default 0
@@ -441,7 +463,6 @@ export const promiseForever = <T, S = unknown>(
     context: PromiseForeverFirstPromiseMakerContext<S> | PromiseForeverRestPromiseMakerContext<T, S>
   ): void => {
     void promiseMaker(context)
-      // oxlint-disable-next-line prefer-await-to-callbacks
       .catch((error: unknown) => {
         const failedResult = promiseCatchToFailResult(error)
         if (onRejected !== undefined) {

package/src/basic/string.ts

@@ -1,34 +1,3 @@
-const internalRandomPacket: Record<number, string[]> = {}
-/**
- * Generate a random string with a fixed length and optional character set.
- *
- * @example
- * ```
- * // Expect: 8
- * const example1 = stringRandom(8).length
- * // Expect: true
- * const example2 = stringRandom(4, "ab").split("").every(char => char === "a" || char === "b")
- * ```
- */
-export const stringRandom = (length: number, chars?: string | undefined): string => {
-  let result = ""
-  const preparedChars = chars ?? "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
-
-  Array.from({ length }).forEach(() => {
-    result = result + preparedChars[Math.floor(Math.random() * preparedChars.length)]!
-  })
-
-  internalRandomPacket[length] = internalRandomPacket[length] ?? []
-  const packet = internalRandomPacket[length]
-  if (packet.includes(result)) {
-    return stringRandom(length, preparedChars)
-  }
-  else {
-    packet.push(result)
-    return result
-  }
-}
-
 /**
  * Convert a camelCase string into kebab-case.
  *
@@ -177,8 +146,8 @@ export const stringSliceByUnits = (text: string, start: number, end: number): st
 
 export interface StringSplitOptions {
   input: string
-  chunkSize: number
-  chunkOverlap: number
+  chunkSize?: number | undefined
+  chunkOverlap?: number | undefined
 }
 
 /**