@superutils/core 1.0.4 → 1.0.5

package/dist/index.d.ts

@@ -27,7 +27,7 @@ type Curry<TData, TParams extends unknown[]> = <TArgs extends unknown[]>(...args
 /**
  * Deferred function config
  */
-interface DeferredConfig<ThisArg = unknown> {
+interface DeferredOptions<ThisArg = unknown> {
     leading?: boolean | 'global';
     onError?: (err: unknown) => ValueOrPromise<unknown>;
     thisArg?: ThisArg;
@@ -283,7 +283,7 @@ type CurriedArgs<TArgs extends unknown[], TArgsIsFinite extends boolean, TFunc e
  *
  */
 declare const deferred: {
-    <TArgs extends unknown[], ThisArg>(callback: (this: ThisArg, ...args: TArgs) => ValueOrPromise<unknown>, delay?: number, config?: DeferredConfig<ThisArg>): (...args: TArgs) => void;
+    <TArgs extends unknown[], ThisArg>(callback: (this: ThisArg, ...args: TArgs) => ValueOrPromise<unknown>, delay?: number, config?: DeferredOptions<ThisArg>): (...args: TArgs) => void;
     defaults: {
         /**
          * Set the default value of argument `leading` for the `deferred` function.
@@ -400,7 +400,7 @@ declare const isArrLike: (x: any) => x is typeof x extends (infer Value)[] ? Val
  * Check if value is convertible to an array by using `Array.from(x)` even if it comes from a different realm
  * (eg: iframe, iframes, worker contexts, node vm contexts, browser extensions).
  *
- * Caution: much slower than {@link isArrLike()} due to use of `Object.prototype.toString.call()`
+ * Caution: much slower than {@link isArrLike} due to use of `Object.prototype.toString.call()`
  */
 declare const isArrLikeSafe: <T = unknown, MapKey = unknown>(x: unknown) => x is Set<T> | Map<MapKey, T> | T[];
 /** Check if all values in the array are unique */
@@ -644,7 +644,7 @@ declare const is: {
 declare function noop(): void;
 declare function noopAsync(): Promise<void>;
 
-type ThrottleConfig<ThisArg = unknown> = {
+type ThrottleOptions<ThisArg = unknown> = {
     onError?: (err: unknown) => ValueOrPromise<unknown>;
     thisArg?: ThisArg;
     trailing?: boolean;
@@ -662,7 +662,7 @@ type ThrottleConfig<ThisArg = unknown> = {
  * @param   config.trailing (optional) whether to enable trailing edge execution. Default: `true`
  */
 declare const throttled: {
-    <TArgs extends unknown[], ThisArg>(callback: (this: ThisArg, ...args: TArgs) => ValueOrPromise<unknown>, delay?: number, config?: ThrottleConfig<ThisArg>): (...args: TArgs) => void;
+    <TArgs extends unknown[], ThisArg>(callback: (this: ThisArg, ...args: TArgs) => ValueOrPromise<unknown>, delay?: number, config?: ThrottleOptions<ThisArg>): (...args: TArgs) => void;
     /**
      * Set the default values
      * This change is applicable application-wide and only applies to any new invocation of `throttle()`.
@@ -712,25 +712,34 @@ declare const objClean: <T extends Record<PropertyKey, unknown>, Key extends key
  * Deep-copy an object to another object
  *
  * @param input input object
+ * @param _output (optional) output object
  * @param ignoreKeys (optional) input peroperties to be ignored. Prevents output's property to be overriden.
  *
  * For child object properties use "." (dot) separated path.
  *
  * Eg: `"child.grandchild1"` where input is `{ child: { grandchild1: 1, grandchild2: 2 }}`
  *
- * @param output (optional) output object
- * @param override (optional) whether to allow override output (if provided) properties.
+ * @param override (optional) whether to allow override output properties.
+ * This will only be used if `output` object is provided and has own property.
  * Accepted values:
- * `true`: input property will override output property
- * `false`: no overriding if output contains the property. Even if the property value is `undefined`.
- * `"empty"`: only allow overriding output property if it's value is empty by using {@link isEmpty}.
+ * - `true`: input property will override output property
+ * - `false`: no overriding if output contains the property. Even if the property value is `undefined`.
+ * - `"empty"`: only allow overriding output property if it's value is empty by using {@link isEmpty}.
+ * - `function`: decide whether to override on a per property basis.
+ *
+ * Function Arguments:
+ *     1. key: current property name/key
+ *     2. outputValue: `output` property value
+ *     3. inputValue: `input` property value
  *
  * Default: `false`
  *
+ * @param reverse (optional) whether to reverse sort object properties. Default: `false`
+ *
  *
  * @returns copied and/or merged object
  */
-declare const objCopy: <Key extends string | symbol, T extends Record<Key, unknown>, IgnoredKey extends Key | string>(input: T, output?: Record<PropertyKey, unknown>, ignoreKeys?: IgnoredKey[] | Set<IgnoredKey>, override?: boolean | "empty", recursive?: boolean) => Record<PropertyKey, unknown>;
+declare const objCopy: <Key extends PropertyKey, InValue, OutValue, IgnoredKey extends Key | string>(input: Record<Key, InValue>, output?: Record<PropertyKey, OutValue>, ignoreKeys?: IgnoredKey[] | Set<IgnoredKey>, override?: boolean | "empty" | ((key: Key, outputValue: OutValue, inputValue: InValue) => boolean), recursive?: boolean) => Record<PropertyKey, unknown>;
 
 /**
  * Creates an object from an array of keys and a corresponding array of values.
@@ -760,6 +769,15 @@ declare const objCopy: <Key extends string | symbol, T extends Record<Key, unkno
  */
 declare const objCreate: <V, K extends PropertyKey, RV, RK extends PropertyKey, Result extends Record<K | RK, V | RV>>(keys?: K[], values?: V[], result?: Result) => Result;
 
+/**
+ * Checks if all the supplied keys exist in an object
+ *
+ * @param input
+ * @param keys
+ * @param equireValue (optional) whether each property should have some value.
+ */
+declare function objHasKeys(input?: object | unknown[], keys?: PropertyKey[], requireValue?: boolean): boolean;
+
 /**
  * Get object property names/keys
  *
@@ -837,10 +855,11 @@ declare const objWithoutKeys: (input: unknown, keys: string[], output?: Record<P
 declare const arrReadOnly: <T>(arr: T[], config?: Omit<ReadOnlyConfig<T[]>, "revoke">) => T[];
 
 /**
+ * @ignore exclude from documentation
  * Helper class for creating read-only arrays.
  *
  * Caution: This class can by itself only make the array partially read-only.
- * Use {@link arrReadOnly()} instead.
+ * Use {@link arrReadOnly} instead.
  */
 declare class ReadOnlyArrayHelper<T> extends Array<T> {
     readonly config: Omit<ReadOnlyConfig<T[]>, 'revoke'>;
@@ -852,16 +871,6 @@ declare class ReadOnlyArrayHelper<T> extends Array<T> {
     shift: () => T;
     splice: (..._ignoredArgs: unknown[]) => never[];
     unshift: (..._ignoredArgs: T[]) => number;
-    reduce: {
-        (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
-        (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
-        <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
-    };
-    reduceRight: {
-        (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
-        (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
-        <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
-    };
 }
 
 /**
@@ -905,9 +914,9 @@ declare const arrReverse: <T = unknown>(arr: T[], reverse?: boolean, newArray?:
  * const map = arrToMap(arr, (item: Item) => item.key, 1) // Map<number, Item>
  * ```
  */
+declare function arrToMap<T extends unknown[], FlatDepth extends number = 0, MapItem = FlatArray<T, FlatDepth>, KeyProp extends keyof MapItem = keyof MapItem>(arr: T, key: KeyProp, flatDepth?: FlatDepth): Map<MapItem[KeyProp], MapItem>;
 declare function arrToMap<T extends unknown[], FlatDepth extends number = 0>(arr: T, flatDepth?: FlatDepth): Map<number, FlatArray<T, FlatDepth>>;
 declare function arrToMap<T extends unknown[], FlatDepth extends number = 0, MapItem = FlatArray<T, FlatDepth>, MapKey = unknown>(arr: T, key: (item: MapItem, index: number, flatArr: MapItem[]) => MapKey, flatDepth?: FlatDepth): Map<MapKey, MapItem>;
-declare function arrToMap<T extends unknown[], FlatDepth extends number = 0, MapItem = FlatArray<T, FlatDepth>, KeyProp extends keyof MapItem = keyof MapItem>(arr: T, key: KeyProp, flatDepth?: FlatDepth): Map<MapItem[KeyProp], MapItem>;
 
 /**
  * @function	arrUnique
@@ -987,6 +996,12 @@ type SearchOptions<K, V, AsMap extends boolean = false> = {
  *
  * @param data
  * @param predicate callback function to filter values
+ * Parameters:
+ * 1. `item`: current item
+ * 2. `key`: index/key
+ * 3. `data`: value provided in the first argument (`data`)
+ * @param limit	(optional) limit number of results
+ * @param arArray
  *
  * @returns new Map with filtered items
  *
@@ -1007,7 +1022,7 @@ type SearchOptions<K, V, AsMap extends boolean = false> = {
  * // }
  * ```
  */
-declare const filter: <K, V, AsArray extends boolean = false, Result = AsArray extends true ? V[] : Map<K, V>>(data: IterableList<K, V>, predicate: (value: V, key: K, data: IterableList<K, V>) => boolean, limit?: number, asArray?: AsArray, result?: Map<K, V>) => Result;
+declare const filter: <K, V, AsArray extends boolean = false, Result = AsArray extends true ? V[] : Map<K, V>>(data: IterableList<K, V>, predicate: (item: V, key: K, data: IterableList<K, V>) => boolean, limit?: number, asArray?: AsArray, result?: Map<K, V>) => Result;
 
 /**
  * Finds a first item matching criteria in an {@link IterableList}.
@@ -1119,16 +1134,16 @@ declare const search: {
     <K, V, AsMap extends boolean = true, Result = AsMap extends true ? Map<K, V> : V[]>(data: IterableList<K, V>, options: SearchOptions<K, V, AsMap>): Result;
     defaultOptions: Pick<Required<SearchOptions<unknown, unknown, true>>, "matchAll" | "limit" | "asMap" | "ignoreCase" | "matchExact">;
 };
-/** Utility for use with {@link search()} function */
+/** Utility for use with {@link search} function */
 declare function matchItemOrProp<K, V>(// extends Record<string, unknown>
 { query, ignoreCase, matchExact, transform, }: Pick<SearchOptions<K, V, boolean>, 'transform' | 'query' | 'ignoreCase' | 'matchExact'>, item: V, propertyName?: string): boolean;
 
-type SliceMapCallback<Data, Value, Key> = (item: Value, key: Key, data: Data) => Value;
+type SliceMapTransform<Data, Value, Key> = (item: Value, key: Key, data: Data) => Value;
 type SliceMapOptions<Data, Value, Key, AsMap extends boolean = false> = {
     /** Whether to return the result as a Map (preserving original keys) or an Array */
     asMap?: AsMap;
-    /** callback to transform each item */
-    transform?: SliceMapCallback<Data, Value, Key>;
+    /** Callback to transform each item from the selected range */
+    transform?: SliceMapTransform<Data, Value, Key>;
     /** End index (exclusive). Default: `undefined` (end of the list) */
     end?: number;
     /** Whether to exclude item if value is `undefined | null` */
@@ -1140,9 +1155,14 @@ type SliceMapOptions<Data, Value, Key, AsMap extends boolean = false> = {
  * Slice an iterable list and map the values into an Array/Map
  *
  * @param data		Array, Map, Set...
- * @param start		Default: `0`
- * @param end		(optional) last index - exclusive. Default: index of the last item
- * @param callback	to be executed on each item within the set range.
+ * @param options	One of the following is required to create a new list:
+ * 1. A callback function {@link SliceMapTransform} to transform all items.
+ * 2. Advanced options {@link SliceMapOptions}.
+ * @param options.asMap	(optional) whether return a Map or Array.
+ * @param options.end	(optional) End index (exclusive). Default: `undefined` (end of the list)
+ * @param options.ignoreEmpty (optional) Whether to exclude item if value is `undefined | null`
+ * @param options.start	(optional) Default: `0`
+ * @param options.transform	(optional)
  *
  * If callback throws error or returnes `undefined`, the item will be ignored.
  *
@@ -1153,7 +1173,7 @@ type SliceMapOptions<Data, Value, Key, AsMap extends boolean = false> = {
  *
  * @returns Array/Map
  */
-declare const sliceMap: <Data extends IterableList, Key = Data extends IterableList<infer Key_1, unknown> ? Key_1 : never, Value = Data extends IterableList<unknown, infer Value_1> ? Value_1 : never, AsMap extends boolean = false>(data: Data, options?: SliceMapOptions<Data, Value, Key, AsMap> | SliceMapCallback<Data, Value, Key>) => AsMap extends false ? Value[] : Map<Key, Value>;
+declare const sliceMap: <Data extends IterableList, Key = Data extends IterableList<infer Key_1, unknown> ? Key_1 : never, Value = Data extends IterableList<unknown, infer Value_1> ? Value_1 : never, AsMap extends boolean = false, Result = AsMap extends false ? Value[] : Map<Key, Value>>(data: Data, options?: SliceMapOptions<Data, Value, Key, AsMap> | SliceMapTransform<Data, Value, Key>) => Result;
 
 type EntryComparator<K, V> = (a: [K, V], b: [K, V]) => number;
 type ArrayComparator<V> = (a: V, b: V) => number;
@@ -1267,6 +1287,13 @@ declare const mapJoin: <K, V>(...inputs: (Map<K, V> | [K, V][])[]) => Map<K, V>;
  */
 declare const randomInt: (min?: number, max?: number) => number;
 
+/** Describes a number type with negative values only */
+type NegativeNumber<N extends number = number> = `${N}` extends `-${string}` ? N : never;
+/** Describes a number type with positive values excluding `0`  */
+type PositiveNumber<N extends number = number> = `${N}` extends `-${string}` | '0' ? never : N;
+/** Describes a number type with positive values and `0`  */
+type PositiveNumberWithZero<N extends number = number> = `${N}` extends `-${string}` ? never : N;
+
 /**
  * Clears clutter from strings
  *
@@ -1319,4 +1346,14 @@ declare const EMAIL_REGEX: RegExp;
 declare const HEX_REGEX: RegExp;
 declare const HASH_REGEX: RegExp;
 
-export { type ArrayComparator, type AsyncFn, type CreateTuple, type CurriedArgs, type Curry, type DeferredConfig, type DropFirst, type DropFirstN, type DropLast, EMAIL_REGEX, type EntryComparator, type FindOptions, HASH_REGEX, HEX_REGEX, type IfPromiseAddValue, type IsFiniteTuple, type IsOptional, type IterableList, type KeepFirst, type KeepFirstN, type KeepOptionals, type KeepRequired, type MakeOptional, type MinLength, type OptionalIf, type ReadOnlyAllowAddFn, ReadOnlyArrayHelper, type ReadOnlyConfig, type SearchOptions, type Slice, type SliceMapCallback, type SliceMapOptions, type SortOptions, type ThrottleConfig, type TimeoutId, type TupleMaxLength, type TupleWithAlt, type ValueOrFunc, type ValueOrPromise, arrReadOnly, arrReverse, arrToMap, arrUnique, asAny, clearClutter, copyToClipboard, curry, debounce, deferred, fallbackIfFails, filter, find, forceCast, getEntries, getKeys, getSize, getUrlParam, getValues, is, isArr, isArr2D, isArrLike, isArrLikeSafe, isArrObj, isArrUnique, isAsyncFn, isBool, isDate, isDateValid, isDefined, isEmpty, isEmptySafe, isEnvBrowser, isEnvNode, isEnvTouchable, isError, isFn, isInteger, isMap, isMapObj, isNumber, isObj, isPositiveInteger, isPositiveNumber, isPromise, isRegExp, isSet, isStr, isSymbol, isUint8Arr, isUrl, isUrlValid, mapJoin, matchItemOrProp, noop, noopAsync, objClean, objCopy, objCreate, objKeys, objReadOnly, objSetProp, objSetPropUndefined, objSort, objWithoutKeys, randomInt, reverse, search, sliceMap, sort, throttled, toDatetimeLocal };
+/**
+ * Convert comma separated strings to array
+ *
+ * @param value value to convert
+ * @param seperator (optional) only used when value is a string. Default: `","`
+ *
+ * @returns Array
+ */
+declare const strToArr: (value: unknown, seperator?: string) => string[];
+
+export { type ArrayComparator, type AsyncFn, type CreateTuple, type CurriedArgs, type Curry, type DeferredOptions, type DropFirst, type DropFirstN, type DropLast, EMAIL_REGEX, type EntryComparator, type FindOptions, HASH_REGEX, HEX_REGEX, type IfPromiseAddValue, type IsFiniteTuple, type IsOptional, type IterableList, type KeepFirst, type KeepFirstN, type KeepOptionals, type KeepRequired, type MakeOptional, type MinLength, type NegativeNumber, type OptionalIf, type PositiveNumber, type PositiveNumberWithZero, type ReadOnlyAllowAddFn, ReadOnlyArrayHelper, type ReadOnlyConfig, type SearchOptions, type Slice, type SliceMapOptions, type SliceMapTransform, type SortOptions, type ThrottleOptions, type TimeoutId, type TupleMaxLength, type TupleWithAlt, type ValueOrFunc, type ValueOrPromise, arrReadOnly, arrReverse, arrToMap, arrUnique, asAny, clearClutter, copyToClipboard, curry, debounce, deferred, fallbackIfFails, filter, find, forceCast, getEntries, getKeys, getSize, getUrlParam, getValues, is, isArr, isArr2D, isArrLike, isArrLikeSafe, isArrObj, isArrUnique, isAsyncFn, isBool, isDate, isDateValid, isDefined, isEmpty, isEmptySafe, isEnvBrowser, isEnvNode, isEnvTouchable, isError, isFn, isInteger, isMap, isMapObj, isNumber, isObj, isPositiveInteger, isPositiveNumber, isPromise, isRegExp, isSet, isStr, isSymbol, isUint8Arr, isUrl, isUrlValid, mapJoin, matchItemOrProp, noop, noopAsync, objClean, objCopy, objCreate, objHasKeys, objKeys, objReadOnly, objSetProp, objSetPropUndefined, objSort, objWithoutKeys, randomInt, reverse, search, sliceMap, sort, strToArr, throttled, toDatetimeLocal };

package/dist/index.js

@@ -195,15 +195,12 @@ var is = {
 // src/fallbackIfFails.ts
 var fallbackIfFails = (target, args, fallbackValue) => {
   let result;
-  let asPromise = false;
   try {
     result = !isFn(target) ? target : target(...isFn(args) ? args() : args);
     if (!isPromise(result)) return result;
-    asPromise = true;
     return result.catch((err) => getAltValCb(err, fallbackValue));
   } catch (error) {
-    result = getAltValCb(error, fallbackValue);
-    return asPromise && !isPromise(result) ? Promise.resolve(result) : result;
+    return getAltValCb(error, fallbackValue);
   }
 };
 var fallbackIfFails_default = fallbackIfFails;
@@ -298,7 +295,7 @@ var objClean = (obj, keys, ignoreIfNotExist = true) => {
   const result = {};
   if (!isObj(obj) || !isArr(keys)) return result;
   const uniqKeys = arrUnique(
-    keys.map((x) => isStr(x) ? `${x}`.split(".")[0] : x)
+    keys.map((x) => String(x).split(".")[0])
   ).sort();
   for (const key of uniqKeys) {
     if (ignoreIfNotExist && !obj.hasOwnProperty(key)) continue;
@@ -338,8 +335,8 @@ var objKeys_default = objKeys;
 // src/obj/objCopy.ts
 var clone = (value, fallback = "null") => JSON.parse(fallbackIfFails_default(JSON.stringify, [value], fallback));
 var objCopy = (input, output, ignoreKeys, override = false, recursive = true) => {
-  if (!isObj(output)) output = {};
-  if (!isObj(input)) return output;
+  const _output = isObj(output) ? output : {};
+  if (!isObj(input)) return _output;
   const _ignoreKeys = new Set(ignoreKeys != null ? ignoreKeys : []);
   const inKeys = objKeys_default(input, true, true).filter(
     (x) => !_ignoreKeys.has(x)
@@ -347,14 +344,14 @@ var objCopy = (input, output, ignoreKeys, override = false, recursive = true) =>
   for (const _key of inKeys) {
     const key = _key;
     const value = input[key];
-    const skip = output.hasOwnProperty(key) && (!override || override === "empty" && !isEmpty(output[key]));
+    const skip = _output.hasOwnProperty(key) && (override === "empty" ? !isEmpty(_output[key]) : isFn(override) ? !override(key, _output[key], value) : true);
     if (skip) continue;
     const isPrimitive = [void 0, null, Infinity, NaN].includes(asAny(value)) || !isObj(value, false);
     if (isPrimitive) {
-      output[key] = value;
+      _output[key] = value;
       continue;
     }
-    output[key] = (() => {
+    _output[key] = (() => {
       switch (Object.getPrototypeOf(value)) {
         case Array.prototype:
           return clone(value, "[]");
@@ -384,19 +381,19 @@ var objCopy = (input, output, ignoreKeys, override = false, recursive = true) =>
       }
       if (isSymbol(key) || !recursive) return clone(value);
       const ignoreChildKeys = [..._ignoreKeys].map(
-        (x) => !isSymbol(x) && x.startsWith(key.concat(".")) && x.split(key.concat("."))[1]
+        (x) => String(x).startsWith(String(key).concat(".")) && String(x).split(String(key).concat("."))[1]
       ).filter(Boolean);
       if (!ignoreChildKeys.length) return clone(value);
       return objCopy(
         value,
-        output[key],
+        _output[key],
         ignoreChildKeys,
         override,
         recursive
       );
     })();
   }
-  return output;
+  return _output;
 };
 
 // src/obj/objCreate.ts
@@ -409,6 +406,16 @@ var objCreate = (keys = [], values = [], result) => {
   return result;
 };
 
+// src/obj/objHasKeys.ts
+function objHasKeys(input = {}, keys = [], requireValue = false) {
+  if (!isObj(input) || !isArr(keys)) return false;
+  for (const key of keys) {
+    if (!input.hasOwnProperty(key)) return false;
+    if (requireValue && isEmpty(input[key])) return false;
+  }
+  return true;
+}
+
 // src/obj/objReadOnly.ts
 var objReadOnly = (obj, config) => {
   if (!isObj(obj, false)) obj = {};
@@ -501,10 +508,10 @@ var ReadOnlyArrayHelper = class extends Array {
     this.shift = () => this.ignoreOrThrow(this[0]);
     this.splice = (..._ignoredArgs) => this.ignoreOrThrow([]);
     this.unshift = (..._ignoredArgs) => this.ignoreOrThrow(this.length);
-    // fromAsync = super.fromAsync
-    this.reduce = super.reduce;
-    this.reduceRight = super.reduceRight;
   }
+  // fromAsync = super.fromAsync
+  // reduce = super.reduce
+  // reduceRight = super.reduceRight
 };
 
 // src/arr/arrReverse.ts
@@ -532,9 +539,10 @@ function arrToMap(arr, key, flatDepth = 0) {
 var arrUnique = (arr, flatDepth = 0) => !isArr(arr) ? [] : Array.from(new Set(arr.flat(flatDepth)));
 
 // src/iterable/filter.ts
-var filter = (data, predicate, limit = Infinity, asArray = false, result = /* @__PURE__ */ new Map()) => {
+var filter = (data, predicate, limit, asArray, result) => {
   var _a;
   if (!isMap(result)) result = /* @__PURE__ */ new Map();
+  if (!isPositiveInteger(limit)) limit = Infinity;
   for (const [key, item] of ((_a = data == null ? void 0 : data.entries) == null ? void 0 : _a.call(data)) || []) {
     if (result.size >= limit) break;
     fallbackIfFails_default(predicate != null ? predicate : item, [item, key, data], false) && result.set(key, item);
@@ -611,20 +619,19 @@ function matchItemOrProp({
   matchExact,
   transform
 }, item, propertyName) {
-  var _a, _b;
   const fuzzy = isStr(query) || isRegExp(query) || propertyName === void 0;
   const keyword = fuzzy ? query : query[propertyName];
   const propVal = fuzzy || !isObj(item) ? item : item[propertyName];
   let value = fallbackIfFails_default(
     () => {
-      var _a2;
+      var _a;
       return isFn(transform) ? transform(
         item,
         fuzzy ? void 0 : propVal,
         propertyName
       ) : isObj(propVal, false) ? JSON.stringify(
         isArrLike(propVal) ? [...propVal.values()] : Object.values(propVal)
-      ) : (_a2 = propVal == null ? void 0 : propVal.toString) == null ? void 0 : _a2.call(propVal);
+      ) : (_a = propVal == null ? void 0 : propVal.toString) == null ? void 0 : _a.call(propVal);
     },
     [],
     ""
@@ -633,7 +640,7 @@ function matchItemOrProp({
   if (isRegExp(keyword)) return keyword.test(`${value}`);
   if (ignoreCase && !matchExact) value = value.toLowerCase();
   if (value === keyword) return true;
-  return !matchExact && `${value}`.includes((_b = (_a = keyword == null ? void 0 : keyword.toString) == null ? void 0 : _a.call(keyword)) != null ? _b : "");
+  return !matchExact && `${value}`.includes(String(keyword));
 }
 var search_default = search;
 
@@ -669,9 +676,13 @@ var reverse = (data, reverse2 = true, newInstance = false) => {
   if (!dataType) return [];
   const arr = dataType === 1 ? !newInstance ? data : [...data] : dataType === 2 ? [...data.entries()] : [...data.values()];
   if (reverse2) arr.reverse();
-  if (dataType === 1) return arr;
-  if (newInstance || !("clear" in data && isFn(data.clear))) {
-    return dataType === 2 ? new Map(arr) : dataType === 3 && new Set(arr) || [];
+  switch (dataType) {
+    case 1:
+      return arr;
+    case 2:
+    case 3:
+      if (newInstance || !("clear" in data && isFn(data.clear)))
+        return dataType === 2 ? new Map(arr) : new Set(arr);
   }
   (_a = data == null ? void 0 : data.clear) == null ? void 0 : _a.call(data);
   for (const item of arr)
@@ -782,7 +793,7 @@ var copyToClipboard = (str) => fallbackIfFails(
   () => navigator.clipboard.writeText(str).then(() => 1),
   [],
   // If clipboard API is not available or fails, use the fallback method
-  () => Promise.resolve(copyLegacy(str))
+  () => Promise.resolve(copyLegacy(str) ? 2 : 0)
 );
 var copyLegacy = (str) => fallbackIfFails(
   () => {
@@ -795,11 +806,11 @@ var copyLegacy = (str) => fallbackIfFails(
     el.select();
     const success = document.execCommand("copy");
     document.body.removeChild(el);
-    return success ? 2 : 0;
+    return success;
   },
   [],
-  0
-  // On error, resolve with 0
+  false
+  // On error, return false
 );
 
 // src/str/getUrlParam.ts
@@ -851,6 +862,9 @@ var EMAIL_REGEX = new RegExp(
 );
 var HEX_REGEX = /^0x[0-9a-f]+$/i;
 var HASH_REGEX = /^0x[0-9a-f]{64}$/i;
+
+// src/str/strToArr.ts
+var strToArr = (value, seperator = ",") => typeof value === "string" && value.split(seperator).filter(Boolean) || [];
 export {
   EMAIL_REGEX,
   HASH_REGEX,
@@ -916,6 +930,7 @@ export {
   objClean,
   objCopy,
   objCreate,
+  objHasKeys,
   objKeys,
   objReadOnly,
   objSetProp,
@@ -927,6 +942,7 @@ export {
   search,
   sliceMap,
   sort,
+  strToArr,
   throttled,
   toDatetimeLocal
 };

package/package.json

@@ -36,10 +36,11 @@
 		"_watch": "tsc -p tsconfig.json --watch",
 		"build": "tsup src/index.ts --format esm --dts --clean --config ../../tsup.config.js",
 		"dev": "npm run build -- --watch",
-		"test": "cd ../../ && npm run test promise"
+		"start": "npm run build -- --watch",
+		"test": "cd ../../ && npm run test core"
 	},
 	"sideEffects": false,
 	"type": "module",
 	"types": "dist/index.d.ts",
-	"version": "1.0.4"
+	"version": "1.0.5"
 }