@giveback007/util-lib 0.25.4 → 1.0.0

package/src/iterate.ts

@@ -1,86 +1,86 @@
-import { arrDivide } from './array';
-
-type x = { x: number };
-type xy = { x: number, y: number };
-type xyz = { x: number, y: number, z: number };
-
-/**
- * Iterate over a function like nested for loops
- * each cycle would return an object eg:
- *
- * xLength 3, yLength: 3, zLength: 3
- * ```ts
- * { 0, 0, 0 } ... { 0, 0, 1 } ... { 0, 0, 2 }
- *
- * { 0, 1, 0 } ... { 0, 1, 1 } ... { 0, 1, 2 }
- * ```
- * ...
- * ```ts
- * { 2, 2, 0 } ... { 2, 2, 1 } ... { 2, 2, 2 } <- last object
- * ```
- * Starting index is 0
- */
-export function iterate(xLength: number): {
-    for: (fct: ({ x }: x) => any) => void;
-    map: <T>(fct: ({ x }: x) => T) => T[];
-    nestedMap: <T>(fct: ({ x }: x) => T) => T[];
-};
-
-export function iterate(xLength: number, yLength?: number): {
-    for: (fct: ({ x, y }: xy) => any) => void;
-    map: <T>(fct: ({ x, y }: xy) => T) => T[];
-    nestedMap: <T>(fct: ({ x, y }: xy) => T) => T[][];
-};
-
-export function iterate(
-    xLength: number, yLength?: number, zLength?: number
-): {
-    for: (fct: ({ x, y, z }: xyz) => any) => void;
-    map: <T>(fct: ({ x, y, z }: xyz) => T) => T[];
-    nestedMap: <T>(fct: ({ x, y, z }: xyz) => T) => T[][][];
-};
-
-export function iterate(
-    xLength: number, yLength?: number, zLength?: number
-) {
-    const iterator = <T>(fct: (
-        idxs: x | xy | xyz) => T, nested = false
-    ) => {
-        const arr: T[] = [];
-
-        // xLength ->
-        // tslint:disable-next-line: no-shadowed-variable
-        for (let x = 0; x < xLength; x++) {
-            if (!yLength) arr.push(fct({ x }));
-
-            // yLength ->
-            else for (let y = 0; y < yLength; y++) {
-                if (!zLength) arr.push(fct({ x, y }));
-
-                // zLength ->
-                else for (let z = 0; z < zLength; z++) {
-                    arr.push(fct({ x, y, z }));
-                }
-            }
-        }
-
-        if (!nested) return arr;
-
-        if (zLength && yLength) {
-            const newArr =  arrDivide(arr, yLength * zLength);
-            return newArr.map((yArr) => arrDivide(yArr, zLength))
-        } else if (yLength) {
-            return arrDivide(arr, yLength);
-        } else {
-            return arr;
-        }
-    };
-
-    return {
-        for: (fct: (idxs: any) => any) => { iterator(fct); },
-
-        map: <T>(fct: (idxs: any) => T) => iterator(fct) as T[],
-
-        nestedMap: <T>(fct: (idxs: any) => T) => iterator(fct, true),
-    };
-}
+import { arrDivide } from './array';
+
+type x = { x: number };
+type xy = { x: number, y: number };
+type xyz = { x: number, y: number, z: number };
+
+/**
+ * Iterate over a function like nested for loops
+ * each cycle would return an object eg:
+ *
+ * xLength 3, yLength: 3, zLength: 3
+ * ```ts
+ * { 0, 0, 0 } ... { 0, 0, 1 } ... { 0, 0, 2 }
+ *
+ * { 0, 1, 0 } ... { 0, 1, 1 } ... { 0, 1, 2 }
+ * ```
+ * ...
+ * ```ts
+ * { 2, 2, 0 } ... { 2, 2, 1 } ... { 2, 2, 2 } <- last object
+ * ```
+ * Starting index is 0
+ */
+export function iterate(xLength: number): {
+    for: (fct: ({ x }: x) => any) => void;
+    map: <T>(fct: ({ x }: x) => T) => T[];
+    nestedMap: <T>(fct: ({ x }: x) => T) => T[];
+};
+
+export function iterate(xLength: number, yLength?: number): {
+    for: (fct: ({ x, y }: xy) => any) => void;
+    map: <T>(fct: ({ x, y }: xy) => T) => T[];
+    nestedMap: <T>(fct: ({ x, y }: xy) => T) => T[][];
+};
+
+export function iterate(
+    xLength: number, yLength?: number, zLength?: number
+): {
+    for: (fct: ({ x, y, z }: xyz) => any) => void;
+    map: <T>(fct: ({ x, y, z }: xyz) => T) => T[];
+    nestedMap: <T>(fct: ({ x, y, z }: xyz) => T) => T[][][];
+};
+
+export function iterate(
+    xLength: number, yLength?: number, zLength?: number
+) {
+    const iterator = <T>(fct: (
+        idxs: x | xy | xyz) => T, nested = false
+    ) => {
+        const arr: T[] = [];
+
+        // xLength ->
+        // tslint:disable-next-line: no-shadowed-variable
+        for (let x = 0; x < xLength; x++) {
+            if (!yLength) arr.push(fct({ x }));
+
+            // yLength ->
+            else for (let y = 0; y < yLength; y++) {
+                if (!zLength) arr.push(fct({ x, y }));
+
+                // zLength ->
+                else for (let z = 0; z < zLength; z++) {
+                    arr.push(fct({ x, y, z }));
+                }
+            }
+        }
+
+        if (!nested) return arr;
+
+        if (zLength && yLength) {
+            const newArr =  arrDivide(arr, yLength * zLength);
+            return newArr.map((yArr) => arrDivide(yArr, zLength))
+        } else if (yLength) {
+            return arrDivide(arr, yLength);
+        } else {
+            return arr;
+        }
+    };
+
+    return {
+        for: (fct: (idxs: any) => any) => { iterator(fct); },
+
+        map: <T>(fct: (idxs: any) => T) => iterator(fct) as T[],
+
+        nestedMap: <T>(fct: (idxs: any) => T) => iterator(fct, true),
+    };
+}

package/src/number.ts

@@ -1,62 +1,64 @@
-import type { Dict } from '.';
-import { arrToBoolDict, isType } from '.';
-
-/**
- * Returns a random whole number between `min` and `max`,
- * `min` and `max` are inclusive.
- * `min` & `max` must be whole numbers
- * @param min - whole number & `< max`
- * @param max - whole number & `> min`
- */
-export const rand = (min: number, max: number) =>
-    Math.floor(Math.random() * ((max + 1) - min)) + min;
-
-/** Takes an array of numbers and finds and average */
-export const average = (nArr: number[]) =>
-    nArr.reduce((a = 0, b = 0) => a + b, 0) / nArr.length;
-
-/**
- * Takes a number `n` & fixes to decimal places `places`
- * @param n - the number to fix decimal places of
- * @param places - number of decimal places to round to
- * @example
- * ```js
- * decPlaces(1.1276, 2) //=> 1.13
- * ```
- */
-export const decPlace = (n: number, places: number) =>
-    parseFloat(n.toFixed(places));
-
-/**
- * @example
- * ```js
- * numberWithCommas(1000000) //=> '1,000,000'
- * ```
- */
-export const numberWithCommas = (n: number | string) =>
-    n.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
-
-/**
- * Takes a number || number[] and min & max, will generate a
- * new random number.
- */
-export function newNumFromRange(
-    prevNum: number | number[], min: number, max: number
-) {
-    let num;
-    let loop = 0;
-    const dict: Dict<boolean> = isType(prevNum, 'array') ?
-        arrToBoolDict(prevNum) : { [prevNum]: true };
-
-    do {
-        num = rand(min, max);
-        loop++;
-
-        if (loop > 1_000_000) {
-            console.error('Check for infinite loops');
-            throw new Error('Looped 1 million times');
-        }
-    } while (dict[num]);
-
-    return num;
-}
+import { arrToBoolDict, isType } from '.';
+
+/**
+ * Returns a random whole number between `min` and `max`,
+ * `min` and `max` are inclusive.
+ * `min` & `max` must be whole numbers
+ * @param min - whole number & `< max`
+ * @param max - whole number & `> min`
+ */
+export const randInt = (min: number, max: number) =>
+    Math.floor(Math.random() * ((max + 1) - min)) + min;
+
+export const rand = (min: number, max: number) =>
+    Math.random() * (max - min) + min;
+
+/** Takes an array of numbers and finds and average */
+export const average = (nArr: number[]) =>
+    nArr.reduce((a = 0, b = 0) => a + b, 0) / nArr.length;
+
+/**
+ * Takes a number `n` & fixes to decimal places `places`
+ * @param n - the number to fix decimal places of
+ * @param places - number of decimal places to round to
+ * @example
+ * ```js
+ * decPlaces(1.1276, 2) //=> 1.13
+ * ```
+ */
+export const decPlace = (n: number, places: number) =>
+    parseFloat(n.toFixed(places));
+
+/**
+ * @example
+ * ```js
+ * numberWithCommas(1000000) //=> '1,000,000'
+ * ```
+ */
+export const numberWithCommas = (n: number | string) =>
+    n.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+
+/**
+ * Takes a number || number[] and min & max, will generate a
+ * new random number.
+ */
+export function newNum(
+    prevNum: number | number[], min: number, max: number
+) {
+    let num;
+    let loop = 0;
+    const dict: Dict<boolean> = isType(prevNum, 'array') ?
+        arrToBoolDict(prevNum) : { [prevNum]: true };
+
+    do {
+        num = randInt(min, max);
+        loop++;
+
+        if (loop > 1_000_000) {
+            console.error('Check for infinite loops');
+            throw new Error('Looped 1 million times');
+        }
+    } while (dict[num]);
+
+    return num;
+}

package/src/object.ts

@@ -1,123 +1,109 @@
-import type { Omit, StrKeys, ResolvedValue, Dict, AnyObj } from '.';
-
-/** Maps over an object just as a [ ].map would on an array */
-export function objMap<
-    T, O extends {}
->(o: O, funct: (keyVal: { key: StrKeys<O>, val: O[StrKeys<O>] }) => T)
-{
-    const newObj = { } as { [P in StrKeys<O>]: T };
-
-    for (const key in o) {
-        newObj[key] = funct({ key, val: o[key] });
-    }
-
-    return newObj;
-}
-
-/** Filters out keys based on bool value returned by function */
-export function objFilter<O extends {}>(
-    o: O, funct: (keyVal: {
-        key: StrKeys<O>,
-        val: O[StrKeys<O>]
-    }) => boolean
-)
-{
-    const newObj = { ...o };
-
-    for (const key in o) {
-        if (!funct({ key, val: o[key] })) delete newObj[key];
-    }
-
-    return newObj as { [P in StrKeys<O>]?: O[P] };
-}
-
-/**
- * Removes all keys from object in the `filterOut` array.
- * The original object is not mutated.
- */
-export function objRemoveKeys<
-    T extends {}, K extends keyof T
->(obj: T, filterOut: K[])
-{
-    const newObj: T = { ...obj as any };
-    filterOut.forEach((key) => delete newObj[key]);
-
-    return newObj as Omit<T, K>;
-}
-
-export function objKeys<T extends {}>(o: T): StrKeys<T>[]
-{
-    if (Object.keys) return Object.keys(o) as StrKeys<T>[];
-
-    const keys: StrKeys<T>[] = [];
-    for (const k in o) keys.push(k);
-
-    return keys;
-}
-
-export const objVals = <T = any>(o: { [key: string]: T }): T[] =>
-    Object.values ? Object.values(o) : objKeys(o).map((key) => o[key]);
-
-export const objKeyVals = <T extends {}>(o: T) =>
-    objKeys(o).map((key) => ({ key, val: o[key] }));
-
-/**
- * Creates a new object from `extract` object and an array of `keys` to
- * transfer
- */
-export function objExtract<
-    T extends {},
-    K extends keyof T,
-    U extends { [P in K]: T[P] }
->(extract: T, keys: K[]): U
-{
-    const newObj = { } as U;
-    keys.forEach((key) => (newObj[key] as any as T[K]) = extract[key]);
-
-    return newObj;
-}
-
-/**
- * @param o the object that is to be resolved
- * @param path path to the desired value eg:
- * ```ts
- *  "first.second.stuff" => obj.first.second.stuff
- * ```
- */
-export const objResolve = (o: AnyObj, path: string): any =>
-    path.split('.').reduce((prev, key) => prev[key], o);
-
-/**
- * returns a new obj with the keys being sorted
- */
-export const objSortKeys = <T extends {}>(
-    o: T, compareFn?: (a: keyof T, b: keyof T) => number
-) => {
-    const newObj = {} as T;
-
-    const keys = objKeys(o).sort(compareFn);
-    keys.map((k) => newObj[k] = o[k]);
-
-    return newObj;
-}
-
-/**
- * Takes a dictionary/object made of Promises and Observables and
- * extracts all values. This function will return resolved values from all
- * Observable/Promise on the obj when all promises on object resolve.
- */
-export function objPromiseAll<T extends Dict<Promise<any>>>(obj: T) {
-    const keyValues = objKeyVals(obj);
-    const toEqual = keyValues.length;
-    const values = { } as { [P in keyof T]: ResolvedValue<T[P]> };
-
-    let total = 0;
-    return new Promise<typeof values>((resolve) =>
-        keyValues.forEach(({ key, val: x }) => x.then((data) => {
-            values[key] = data;
-            total++;
-
-            if (toEqual === total) resolve(values);
-        }))
-    );
-}
+import type { Omit, StrKeys, ResolvedValue, AnyObj } from '.';
+
+/** Maps over an object just as a [ ].map would on an array */
+export function objMap<
+    T, O extends {}
+>(o: O, funct: (keyVal: { key: StrKeys<O>, val: O[StrKeys<O>] }) => T)
+{
+    const newObj = { } as { [P in StrKeys<O>]: T };
+
+    for (const key in o) {
+        newObj[key] = funct({ key, val: o[key] });
+    }
+
+    return newObj;
+}
+
+/** Filters out keys based on bool value returned by function */
+export function objFilter<O extends {}>(
+    o: O, funct: (keyVal: {
+        key: StrKeys<O>,
+        val: O[StrKeys<O>]
+    }) => boolean
+)
+{
+    const newObj = { ...o };
+
+    for (const key in o) {
+        if (!funct({ key, val: o[key] })) delete newObj[key];
+    }
+
+    return newObj as { [P in StrKeys<O>]?: O[P] };
+}
+
+/**
+ * Removes all keys from object in the `filterOut` array.
+ * The original object is not mutated.
+ */
+export function objRemoveKeys<
+    T extends {}, K extends keyof T
+>(obj: T, filterOut: K[])
+{
+    const newObj: T = { ...obj as any };
+    filterOut.forEach((key) => delete newObj[key]);
+
+    return newObj as Omit<T, K>;
+}
+
+export function objKeys<T extends {}>(o: T): StrKeys<T>[]
+{
+    if (Object.keys) return Object.keys(o) as StrKeys<T>[];
+
+    const keys: StrKeys<T>[] = [];
+    for (const k in o) keys.push(k);
+
+    return keys;
+}
+
+export const objVals = <T = any>(o: { [key: string]: T }): T[] =>
+    Object.values(o)
+
+export const objKeyVals = <T extends {}>(o: T) =>
+    objKeys(o).map((key) => ({ key, val: o[key] }));
+
+/**
+ * Creates a new object from `extract` object and an array of `keys` to
+ * transfer
+ */
+export function objExtract<
+    T extends {},
+    K extends keyof T,
+    U extends { [P in K]: T[P] }
+>(extract: T, keys: K[]): U
+{
+    const newObj = { } as U;
+    keys.forEach((key) => (newObj[key] as any as T[K]) = extract[key]);
+
+    return newObj;
+}
+
+/**
+ * @param o the object that is to be resolved
+ * @param path path to the desired value eg:
+ * ```ts
+ *  "first.second.stuff" => obj.first.second.stuff
+ * ```
+ */
+export const objResolve = (o: AnyObj, path: string): any =>
+    path.split('.').reduce((prev, key) => prev[key], o);
+
+/**
+ * Takes a dictionary/object made of Promises and Observables and
+ * extracts all values. This function will return resolved values from all
+ * Observable/Promise on the obj when all promises on object resolve.
+ */
+export function objPromiseAll<T extends Dict<Promise<any>>>(obj: T) {
+    const keyValues = objKeyVals(obj);
+    const toEqual = keyValues.length;
+    const values = { } as { [P in keyof T]: ResolvedValue<T[P]> };
+
+    let total = 0;
+    return new Promise<typeof values>((resolve) =>
+        keyValues.forEach(({ key, val: x }) => x!.then((data) => {
+            values[key] = data;
+            total++;
+
+            if (toEqual === total) resolve(values);
+        }))
+    );
+}

package/src/string.ts

@@ -1,20 +1,6 @@
-/** Checks if string includes a substring */
-export const strIncludes = (str: string, subStr: string) =>
-    str.indexOf(subStr) !== -1;
-
-export const strRemove = (str: string, remove: string | RegExp) =>
-    str.replace(new RegExp(remove, 'g'), '');
-
-// export const minAppend = (
-//     item: string | number, length: number, append = '0'
-// ) => {
-//     item = item + '';
-//     if (length < 1) console.error(length, 'length can not be less than 1');
-//     if (item.length > length) console.error(item, 'item can not exceed length');
-
-//     return (append.repeat(length - 1) + item).slice(-(length))
-// }
-
-export const minAppend = (
-    item: string | number, length: number, append = '0'
-) => (append.repeat(length - 1) + item).slice(-(length));
+/** Checks if string includes a substring */
+export const strIncludes = (str: string, subStr: string) =>
+    str.indexOf(subStr) !== -1;
+
+export const strRemoveAll = (str: string, remove: string | RegExp) =>
+    str.replace(new RegExp(remove, 'g'), '');