@valkyriestudios/utils 12.15.0 → 12.17.0

package/README.md

@@ -184,7 +184,7 @@ const group = groupBy([
 **Take note**: any object without the key will be added to a fallback group called '_'
 
 
-- **dedupe(val:Array)**
+- **dedupe(val:Array, opts?:{filter_fn})**
 Remove all duplicates from an array, behind the scenes it uses the fnv 1A hash algorithm to performantly do comparisons.
 ```typescript
 dedupe(['a','a','b','c','c']); // ['a', 'b', 'c']
@@ -192,8 +192,11 @@ dedupe(['1',1,'2',2]); // ['1','2']
 dedupe([new RegExp(/ab+c/, 'i'), new RegExp(/ab+c/, 'i')]); // [new RegExp(/ab+c/, 'i')]
 dedupe([new Date('2012-02-02'), new Date('2012-02-02')]); // [new Date('2012-02-02')]
 dedupe(['hello', 'hello', 'world']); // ['hello', 'world']
+dedupe(['hello', 'hello', 'world', false, 'world'], {filter_fn: el => isNotEmptyString(el)}); // ['hello', 'world']
 ```
 
+Take Note: The filtering is applied while deduping, ensuring O(n) performance, as such this is faster than dedupe(arr.filter(...))
+
 - **join(val:Array, opts:object={delim:' ',trim:true,valtrim:true,innertrim:true,valround:false})**
 Concatenate the values within an array into a string, behind the scenes this will automatically filter out any value that is not a string or numerical value. For strings it will automatically trim (and remove if empty after trimming) before joining.
 
@@ -312,6 +315,15 @@ const out = sort(arr, el => el.test.toLowerCase(), 'desc', {nokey_hide: true});
 // [{test: 'Pony'}, {test: 'Peter'}, {test: 'JOHn'}, {test: 'Jack'}]
 ```
 
+- **split(val:any[], size:number, opts?:{filter_fn})**
+Splits an array into subarray of provided size with optional filter
+```typescript
+split([1,2,3,4,5], 2); // [[1,2],[3,4],[5]]
+split([1, 2, false, 4, 5], 2, {filter_fn: isInteger}); // [[1,2],[4,5]]
+```
+
+Take Note: The filtering is applied while splitting, ensuring O(n) performance, as such this is faster than split(arr.filter(...), ...)
+
 ### boolean
 - **isBoolean(val:any)**
 Check if a variable is of type Boolean

package/array/dedupe.d.ts

@@ -1,9 +1,13 @@
+type DedupeOptions<T> = {
+    filter_fn?: (el: T) => boolean;
+};
 /**
  * Dedupes the provided array
  *
- * @param val - Array to dedupe
+ * @param {Array} val - Array to dedupe
+ * @param {DedupeOptions?} opts - Dedupe options
  *
  * @returns Deduped array
  */
-declare function dedupe<T>(val: T[]): T[];
+declare function dedupe<T>(val: T[], opts?: DedupeOptions<T>): T[];
 export { dedupe, dedupe as default };

package/array/dedupe.js

@@ -3,18 +3,35 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.dedupe = dedupe;
 exports.default = dedupe;
 const fnv1A_1 = require("../hash/fnv1A");
-function dedupe(val) {
+function dedupe(val, opts) {
     if (!Array.isArray(val))
         return [];
+    const FILTER_FN = typeof opts?.filter_fn === 'function' ? opts?.filter_fn : false;
     const set = new Set();
     const acc = [];
-    for (let i = 0; i < val.length; i++) {
-        const el = val[i];
-        const hash = (0, fnv1A_1.fnv1A)(el);
-        if (set.has(hash))
-            continue;
-        set.add(hash);
-        acc.push(el);
+    let hash;
+    const len = val.length;
+    if (FILTER_FN) {
+        for (let i = 0; i < len; i++) {
+            const el = val[i];
+            if (FILTER_FN && !FILTER_FN(el))
+                continue;
+            hash = (0, fnv1A_1.fnv1A)(el);
+            if (!set.has(hash)) {
+                set.add(hash);
+                acc.push(el);
+            }
+        }
+    }
+    else {
+        for (let i = 0; i < len; i++) {
+            const el = val[i];
+            hash = (0, fnv1A_1.fnv1A)(el);
+            if (!set.has(hash)) {
+                set.add(hash);
+                acc.push(el);
+            }
+        }
     }
     return acc;
 }

package/array/index.d.ts

@@ -7,5 +7,6 @@ import { mapKey } from './mapKey';
 import { mapPrimitive } from './mapPrimitive';
 import { groupBy } from './groupBy';
 import { shuffle } from './shuffle';
+import { split } from './split';
 import { sort } from './sort';
-export { dedupe, isArray, isArray as is, isNotEmptyArray, isNotEmptyArray as isNotEmpty, isNotEmptyArray as isNeArray, isNotEmptyArray as isNe, join, mapFn, mapKey, mapPrimitive, groupBy, shuffle, sort };
+export { dedupe, isArray, isArray as is, isNotEmptyArray, isNotEmptyArray as isNotEmpty, isNotEmptyArray as isNeArray, isNotEmptyArray as isNe, join, mapFn, mapKey, mapPrimitive, groupBy, shuffle, split, sort };

package/array/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sort = exports.shuffle = exports.groupBy = exports.mapPrimitive = exports.mapKey = exports.mapFn = exports.join = exports.isNe = exports.isNeArray = exports.isNotEmpty = exports.isNotEmptyArray = exports.is = exports.isArray = exports.dedupe = void 0;
+exports.sort = exports.split = exports.shuffle = exports.groupBy = exports.mapPrimitive = exports.mapKey = exports.mapFn = exports.join = exports.isNe = exports.isNeArray = exports.isNotEmpty = exports.isNotEmptyArray = exports.is = exports.isArray = exports.dedupe = void 0;
 const dedupe_1 = require("./dedupe");
 Object.defineProperty(exports, "dedupe", { enumerable: true, get: function () { return dedupe_1.dedupe; } });
 const is_1 = require("./is");
@@ -23,5 +23,7 @@ const groupBy_1 = require("./groupBy");
 Object.defineProperty(exports, "groupBy", { enumerable: true, get: function () { return groupBy_1.groupBy; } });
 const shuffle_1 = require("./shuffle");
 Object.defineProperty(exports, "shuffle", { enumerable: true, get: function () { return shuffle_1.shuffle; } });
+const split_1 = require("./split");
+Object.defineProperty(exports, "split", { enumerable: true, get: function () { return split_1.split; } });
 const sort_1 = require("./sort");
 Object.defineProperty(exports, "sort", { enumerable: true, get: function () { return sort_1.sort; } });

package/array/shuffle.js

@@ -5,8 +5,9 @@ exports.default = shuffle;
 function shuffle(arr) {
     if (!Array.isArray(arr))
         return;
+    let j;
     for (let i = arr.length - 1; i > 0; i--) {
-        const j = Math.floor(Math.random() * (i + 1));
+        j = (Math.random() * (i + 1)) | 0;
         [arr[i], arr[j]] = [arr[j], arr[i]];
     }
 }

package/array/sort.js

@@ -5,7 +5,7 @@ exports.default = sort;
 const isNotEmpty_1 = require("../object/isNotEmpty");
 const INSERTION_SORT_THRESHOLD = 10;
 function partition(arr, low, high) {
-    const pivot = arr[Math.floor((low + high) / 2)][0];
+    const pivot = arr[(low + high) >> 1][0];
     let i = low;
     let j = high;
     while (i <= j) {

package/array/split.d.ts

@@ -0,0 +1,19 @@
+type SplitOptions<T> = {
+    filter_fn?: (el: T) => boolean;
+};
+/**
+ * Splits the provided array in a set of batches according to the provided size
+ * For Example:
+ *  split([1, 2, 3, 4, 5], 2) -> [[1,2],[3,4],[5]]
+ *
+ * For Example w/ filter
+ *  split([1, false, 3, 4, 5], 2, {filter_fn: el => isInteger(el)}) -> [[1, 3], [4, 5]]
+ *
+ * @param {Array} val - Array to split
+ * @param {number} size - Size of batches
+ * @param {SplitOptions?} opts - Split options
+ *
+ * @returns Split batches
+ */
+declare function split<T>(arr: T[], size: number, opts?: SplitOptions<T>): T[][];
+export { split, split as default };

package/array/split.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.split = split;
+exports.default = split;
+function split(arr, size, opts) {
+    if (!Array.isArray(arr) ||
+        !Number.isInteger(size) ||
+        size <= 0)
+        throw new Error('split requires an array and positive integer size');
+    const FILTER_FN = typeof opts?.filter_fn === 'function' ? opts?.filter_fn : false;
+    const result = [];
+    let cursor = [];
+    let ticker = 0;
+    const len = arr.length;
+    if (FILTER_FN) {
+        for (let i = 0; i < len; i++) {
+            const el = arr[i];
+            if (FILTER_FN && !FILTER_FN(el))
+                continue;
+            ticker++;
+            cursor.push(el);
+            if (ticker === size) {
+                result.push(cursor);
+                cursor = [];
+                ticker = 0;
+            }
+        }
+        if (ticker)
+            result.push(cursor);
+    }
+    else {
+        for (let i = 0; i < arr.length; i += size) {
+            result.push(arr.slice(i, i + size));
+        }
+    }
+    return result;
+}

package/date/format.js

@@ -19,7 +19,7 @@ const intl_formatters = new Map();
 const spec_cache = new Map();
 const zone_offset_cache = new Map();
 function DOY(d) {
-    return Math.floor((d - new Date(d.getFullYear(), 0, 0)) / 86400000);
+    return ((d - new Date(d.getFullYear(), 0, 0)) / 86400000) | 0;
 }
 function toZone(date, zone) {
     const ckey = `${zone}:${date.getUTCFullYear()}${DOY(date)}`;

package/date/nowUnix.js

@@ -3,5 +3,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.nowUnix = nowUnix;
 exports.default = nowUnix;
 function nowUnix() {
-    return Math.floor(Date.now() / 1000);
+    return (Date.now() / 1000) | 0;
 }

package/date/nowUnixMs.js

@@ -3,5 +3,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.nowUnixMs = nowUnixMs;
 exports.default = nowUnixMs;
 function nowUnixMs() {
-    return Math.floor(Date.now());
+    return Date.now();
 }

package/date/toUnix.js

@@ -6,5 +6,5 @@ const is_1 = require("./is");
 function toUnix(val) {
     if (!(0, is_1.isDate)(val))
         throw new TypeError('toUnix requires a date object');
-    return Math.floor(val.valueOf() / 1000);
+    return (val.valueOf() / 1000) | 0;
 }

package/hash/fnv1A.js

@@ -11,38 +11,38 @@ const REPL_NULL = 'null';
 function fnv1A(data, offset = FNV_32) {
     let hash = offset;
     let sanitized;
-    if (typeof data === 'string') {
-        sanitized = data;
-    }
-    else if (Number.isFinite(data)) {
-        sanitized = String(data);
-    }
-    else if (Array.isArray(data) || Object.prototype.toString.call(data) === '[object Object]') {
-        sanitized = JSON.stringify(data);
-    }
-    else if (data instanceof RegExp) {
-        sanitized = data.toString();
-    }
-    else if (data instanceof Date) {
-        sanitized = String(data.getTime());
-    }
-    else if (Number.isNaN(data) || data === Infinity) {
-        sanitized = REPL_NAN;
-    }
-    else if (data === false) {
-        sanitized = REPL_FALSE;
-    }
-    else if (data === true) {
-        sanitized = REPL_TRUE;
-    }
-    else if (data === null) {
-        sanitized = REPL_NULL;
-    }
-    else if (data === undefined) {
-        sanitized = REPL_UNDEF;
-    }
-    else {
-        throw new TypeError('An FNV1A Hash could not be calculated for this datatype');
+    switch (typeof data) {
+        case 'string':
+            sanitized = data;
+            break;
+        case 'number':
+            sanitized = Number.isNaN(data) || !Number.isFinite(data) ? REPL_NAN : String(data);
+            break;
+        case 'boolean':
+            sanitized = data ? REPL_TRUE : REPL_FALSE;
+            break;
+        case 'undefined':
+            sanitized = REPL_UNDEF;
+            break;
+        case 'object':
+            if (data === null) {
+                sanitized = REPL_NULL;
+            }
+            else if (Array.isArray(data) || data.toString() === '[object Object]') {
+                sanitized = JSON.stringify(data);
+            }
+            else if (data instanceof RegExp) {
+                sanitized = data.toString();
+            }
+            else if (data instanceof Date) {
+                sanitized = String(data.getTime());
+            }
+            else {
+                throw new TypeError('An FNV1A Hash could not be calculated for this datatype');
+            }
+            break;
+        default:
+            throw new TypeError('An FNV1A Hash could not be calculated for this datatype');
     }
     const len = sanitized.length;
     for (let i = 0; i < len; i++) {

package/index.d.ts

@@ -11,7 +11,10 @@ declare module "hash/fnv1A" {
     export { fnv1A, fnv1A as default };
 }
 declare module "array/dedupe" {
-    function dedupe<T>(val: T[]): T[];
+    type DedupeOptions<T> = {
+        filter_fn?: (el: T) => boolean;
+    };
+    function dedupe<T>(val: T[], opts?: DedupeOptions<T>): T[];
     export { dedupe, dedupe as default };
 }
 declare module "array/is" {
@@ -81,6 +84,13 @@ declare module "array/shuffle" {
     function shuffle(arr: unknown[]): void;
     export { shuffle, shuffle as default };
 }
+declare module "array/split" {
+    type SplitOptions<T> = {
+        filter_fn?: (el: T) => boolean;
+    };
+    function split<T>(arr: T[], size: number, opts?: SplitOptions<T>): T[][];
+    export { split, split as default };
+}
 declare module "array/sort" {
     type sortOptions<T> = {
         filter_fn?: (el: T) => boolean;
@@ -103,8 +113,9 @@ declare module "array/index" {
     import { mapPrimitive } from "array/mapPrimitive";
     import { groupBy } from "array/groupBy";
     import { shuffle } from "array/shuffle";
+    import { split } from "array/split";
     import { sort } from "array/sort";
-    export { dedupe, isArray, isArray as is, isNotEmptyArray, isNotEmptyArray as isNotEmpty, isNotEmptyArray as isNeArray, isNotEmptyArray as isNe, join, mapFn, mapKey, mapPrimitive, groupBy, shuffle, sort };
+    export { dedupe, isArray, isArray as is, isNotEmptyArray, isNotEmptyArray as isNotEmpty, isNotEmptyArray as isNeArray, isNotEmptyArray as isNe, join, mapFn, mapKey, mapPrimitive, groupBy, shuffle, split, sort };
 }
 declare module "boolean/is" {
     function isBoolean(val: unknown): val is boolean;

package/number/randomIntBetween.js

@@ -6,5 +6,5 @@ function randomIntBetween(min = 0, max = 10) {
     if (!Number.isFinite(min) ||
         !Number.isFinite(max))
         throw new TypeError('Min/Max should be numeric');
-    return Math.floor((Math.random() * (max - min)) + min);
+    return ((Math.random() * (max - min)) + min) | 0;
 }

package/package.json

@@ -1 +1 @@
-{ "name": "@valkyriestudios/utils", "version": "12.15.0", "description": "A collection of single-function utilities for common tasks", "author": { "name": "Peter Vermeulen", "url": "https://www.linkedin.com/in/petervermeulen1/" }, "keywords": [ "utility", "library", "javascript", "js", "node", "bun" ], "license": "MIT", "repository": { "type": "git", "url": "git+https://github.com/ValkyrieStudios/utils.git" }, "bugs": { "url": "https://github.com/ValkyrieStudios/utils/issues" }, "homepage": "https://github.com/ValkyrieStudios/utils#readme", "types": "index.d.ts" }
+{ "name": "@valkyriestudios/utils", "version": "12.17.0", "description": "A collection of single-function utilities for common tasks", "author": { "name": "Peter Vermeulen", "url": "https://www.linkedin.com/in/petervermeulen1/" }, "keywords": [ "utility", "library", "javascript", "js", "node", "bun" ], "license": "MIT", "repository": { "type": "git", "url": "git+https://github.com/ValkyrieStudios/utils.git" }, "bugs": { "url": "https://github.com/ValkyrieStudios/utils/issues" }, "homepage": "https://github.com/ValkyrieStudios/utils#readme", "types": "index.d.ts" }