@leexi/shared 0.3.9 → 0.4.0

package/README.md

@@ -64,18 +64,43 @@ export default defineNuxtConfig({
 - [Composables](#composables)
    - [useLocalStorage](#uselocalstorage)
 - [Utils](#utils)
+   - [Array](#array)
+      - [castArray](#castarray)
+      - [groupBy](#groupby)
+      - [joinBy](#joinby)
+      - [partition](#partition)
+      - [removeRecord](#removerecord)
+      - [replaceRecord](#replacerecord)
+      - [sortBy](#sortby)
+      - [sum](#sum)
+      - [sumBy](#sumby)
+      - [uniq](#uniq)
+      - [uniqBy](#uniqby)
+   - [Function](#function)
+      - [debounce](#debounce)
+   - [Number](#number)
+      - [toPadStart](#topadstart)
+   - [Objects](#objects)
+      - [deepDup](#deepdup)
+      - [isSame](#issame)
+   - [Promise](#promise)
+      - [singleFlight](#singleflight)
+      - [sleep](#sleep)
+      - [throttle](#throttle)
    - [Records](#records)
-      - [set](#set)
-      - [pick](#pick)
+      - [get](#get)
+      - [merge](#merge)
       - [omit](#omit)
+      - [pick](#pick)
+      - [set](#set)
    - [Strings](#strings)
       - [camelcase](#camelcase)
       - [capitalize](#capitalize)
       - [kebabcase](#kebabcase)
       - [snakecase](#snakecase)
-   - [Objects](#objects)
-      - [isSame](#issame)
-      - [deepDup](#deepdup)
+      - [strContains](#strcontains)
+      - [truncate](#truncate)
+      - [urlify](#urlify)
 
 ## Composables
 ### useLocalStorage
@@ -100,20 +125,168 @@ console.log(localStorage.userSetting); // Output: '{"theme":"dark","notification
 ```
 
 ## Utils
+### Array
+#### castArray
+- Type
+```ts
+
+```
+
+#### groupBy
+- Type
+```ts
+
+```
+
+#### joinBy
+- Type
+```ts
+
+```
+
+#### partition
+- Type
+```ts
+
+```
+
+#### removeRecord
+- Type
+```ts
+
+```
+
+#### replaceRecord
+- Type
+```ts
+
+```
+
+#### sortBy
+- Type
+```ts
+const sortBy: <T, C extends (_: T) => Primitive, K extends Extract<FilteredAttrs<T, Primitive>, string>>(items: T[], attrsOrCallbacks: C | K | `-${K}` | (C | K | `-${K}`)[]) => T[];
+```
+
+#### sum
+- Type
+```ts
+
+```
+
+#### sumBy
+- Type
+```ts
+
+```
+
+#### uniq
+- Type
+```ts
+
+```
+
+#### uniqBy
+- Type
+```ts
+
+```
+
+### Function
+#### debounce
+- Type
+```ts
+
+```
+
+### Number
+#### toPadStart
+- Type
+```ts
+
+```
+
+### Objects
+#### deepDup
+Creates a deep duplicate of an object, array, or Set.
+It handles nested objects, arrays, and Sets but does not handle functions, Dates, or circular references.
+- Type
+```ts
+const deepDup: <T extends object>(object: T) => T;
+```
+- Example
+```ts
+const originalObject = { a: 1, b: { c: 2, d: [3, 4] }, e: new Set([5, 6]) };
+const duplicatedObject = deepDup(originalObject);
+
+console.log(duplicatedObject); // Output: { a: 1, b: { c: 2, d: [3, 4] }, e: Set { 5, 6 } }
+console.log(originalObject === duplicatedObject); // Output: false
+console.log(originalObject.b === duplicatedObject.b); // Output: false
+console.log(originalObject.b.d === duplicatedObject.b.d); // Output: false
+console.log(originalObject.e === duplicatedObject.e); // Output: false
+```
+
+#### isSame
+Checks if two objects are the same by comparing their JSON stringified representations.
+Note: This method has limitations and may not accurately compare objects with different key orders, non-primitive values like functions or Dates, or circular references.
+- Type
+```ts
+const isSame: (a: object, b: object) => boolean;
+```
+- Example
+```ts
+const obj1 = { a: 1, b: 2 };
+const obj2 = { a: 1, b: 2 };
+const obj3 = { b: 2, a: 1 };
+
+console.log(isSame(obj1, obj2)); // Output: true
+console.log(isSame(obj1, obj3)); // Output: false (due to key order difference in JSON stringification)
+```
+
+### Promise
+#### singleFlight
+- Type
+```ts
+
+```
+
+#### sleep
+- Type
+```ts
+
+```
+
+#### throttle
+- Type
+```ts
+
+```
+
 ### Records
-#### set
-Sets a value within a nested object structure based on a provided path.
-It mutates the original object and creates nested objects if they don't exist along the path.
+#### get
 - Type
 ```ts
-const set: <T extends Record<string, unknown>, const P extends string[], V>(record: T, path: P, value: V) => SetRecord<T, P, V>;
+
+```
+
+#### merge
+- Type
+```ts
+
+```
+
+#### omit
+Creates a new object by omitting the specified keys from the input record.
+- Type
+```ts
+const omit: <T extends Record<string, unknown>, K extends (keyof T)[]>(record: T, keys: K) => Omit<T, K[number]>;
 ```
 - Example
 ```ts
-const myObject = { a: { b: { c: 1 } } };
-set(myObject, ['a', 'b', 'd'], 2);
+const myObject = { a: 1, b: 2, c: 3, d: 4 };
+const omittedObject = omit(myObject, ['b', 'd']);
 
-console.log(myObject); // Output: { a: { b: { c: 1, d: 2 } } }
+console.log(omittedObject); // Output: { a: 1, c: 3 }
 ```
 
 #### pick
@@ -130,18 +303,19 @@ const pickedObject = pick(myObject, ['a', 'c']);
 console.log(pickedObject); // Output: { a: 1, c: 3 }
 ```
 
-#### omit
-Creates a new object by omitting the specified keys from the input record.
+#### set
+Sets a value within a nested object structure based on a provided path.
+It mutates the original object and creates nested objects if they don't exist along the path.
 - Type
 ```ts
-const omit: <T extends Record<string, unknown>, K extends (keyof T)[]>(record: T, keys: K) => Omit<T, K[number]>;
+const set: <T extends Record<string, unknown>, const P extends string[], V>(record: T, path: P, value: V) => SetRecord<T, P, V>;
 ```
 - Example
 ```ts
-const myObject = { a: 1, b: 2, c: 3, d: 4 };
-const omittedObject = omit(myObject, ['b', 'd']);
+const myObject = { a: { b: { c: 1 } } };
+set(myObject, ['a', 'b', 'd'], 2);
 
-console.log(omittedObject); // Output: { a: 1, c: 3 }
+console.log(myObject); // Output: { a: { b: { c: 1, d: 2 } } }
 ```
 
 ### Strings
@@ -196,39 +370,20 @@ console.log(snakecase('my-variable-name')); // Output: my_variable_name
 console.log(snakecase('my_variable_name')); // Output: my_variable_name
 ```
 
-### Objects
-#### isSame
-Checks if two objects are the same by comparing their JSON stringified representations.
-Note: This method has limitations and may not accurately compare objects with different key orders, non-primitive values like functions or Dates, or circular references.
+#### strContains
 - Type
 ```ts
-const isSame: (a: object, b: object) => boolean;
-```
-- Example
-```ts
-const obj1 = { a: 1, b: 2 };
-const obj2 = { a: 1, b: 2 };
-const obj3 = { b: 2, a: 1 };
 
-console.log(isSame(obj1, obj2)); // Output: true
-console.log(isSame(obj1, obj3)); // Output: false (due to key order difference in JSON stringification)
 ```
 
-#### deepDup
-Creates a deep duplicate of an object, array, or Set.
-It handles nested objects, arrays, and Sets but does not handle functions, Dates, or circular references.
+#### truncate
 - Type
 ```ts
-const deepDup: <T extends object>(object: T) => T;
+
 ```
-- Example
+
+#### urlify
+- Type
 ```ts
-const originalObject = { a: 1, b: { c: 2, d: [3, 4] }, e: new Set([5, 6]) };
-const duplicatedObject = deepDup(originalObject);
 
-console.log(duplicatedObject); // Output: { a: 1, b: { c: 2, d: [3, 4] }, e: Set { 5, 6 } }
-console.log(originalObject === duplicatedObject); // Output: false
-console.log(originalObject.b === duplicatedObject.b); // Output: false
-console.log(originalObject.b.d === duplicatedObject.b.d); // Output: false
-console.log(originalObject.e === duplicatedObject.e); // Output: false
 ```