@buley/dash 0.0.30 → 2.1.4

package/tests/utilities/isArray.spec.ts

@@ -1,21 +0,0 @@
-import { isArray } from '../../src/utilities';
-
-describe('isArray', () => {
-    it('should return true for arrays', () => {
-        expect(isArray([1, 2, 3])).toBe(true);     // Simple array
-        expect(isArray([])).toBe(true);            // Empty array
-    });
-
-    it('should return false for non-array types', () => {
-        expect(isArray('hello')).toBe(false);      // String
-        expect(isArray(42)).toBe(false);           // Number
-        expect(isArray({ foo: 'bar' })).toBe(false); // Object
-        expect(isArray(null)).toBe(false);         // null
-        expect(isArray(undefined)).toBe(false);    // undefined
-    });
-
-    it('should return false for array-like objects', () => {
-        const arrayLike = { length: 2, 0: 'a', 1: 'b' };
-        expect(isArray(arrayLike)).toBe(false);    // Array-like object but not an actual array
-    });
-});

package/tests/utilities/isBoolean.spec.ts

@@ -1,23 +0,0 @@
-import { isBoolean } from '../../src/utilities';
-
-describe('isBoolean', () => {
-    it('should return true for boolean values', () => {
-        expect(isBoolean(true)).toBe(true);   // Boolean true
-        expect(isBoolean(false)).toBe(true);  // Boolean false
-    });
-
-    it('should return false for non-boolean values', () => {
-        expect(isBoolean('true')).toBe(false);  // String
-        expect(isBoolean(0)).toBe(false);       // Number
-        expect(isBoolean(1)).toBe(false);       // Number
-        expect(isBoolean([])).toBe(false);      // Array
-        expect(isBoolean({})).toBe(false);      // Object
-        expect(isBoolean(null)).toBe(false);    // null
-        expect(isBoolean(undefined)).toBe(false); // undefined
-    });
-
-    it('should return false for boolean-like strings', () => {
-        expect(isBoolean('false')).toBe(false);  // String "false"
-        expect(isBoolean('true')).toBe(false);   // String "true"
-    });
-});

package/tests/utilities/isEmpty.spec.ts

@@ -1,45 +0,0 @@
-import { isEmpty } from '../../src/utilities';
-
-describe('isEmpty', () => {
-    it('should return true for empty arrays', () => {
-        expect(isEmpty([])).toBe(true);  // Empty array
-    });
-
-    it('should return false for non-empty arrays', () => {
-        expect(isEmpty([1, 2, 3])).toBe(false);  // Non-empty array
-    });
-
-    it('should return true for empty objects', () => {
-        expect(isEmpty({})).toBe(true);  // Empty object
-    });
-
-    it('should return false for non-empty objects', () => {
-        expect(isEmpty({ foo: 'bar' })).toBe(false);  // Non-empty object
-    });
-
-    it('should return true for empty strings', () => {
-        expect(isEmpty('')).toBe(true);  // Empty string
-    });
-
-    it('should return false for non-empty strings', () => {
-        expect(isEmpty('hello')).toBe(false);  // Non-empty string
-    });
-
-    it('should return true for null', () => {
-        expect(isEmpty(null)).toBe(true);  // Null value
-    });
-
-    it('should return true for undefined', () => {
-        expect(isEmpty(undefined)).toBe(true);  // Undefined value
-    });
-
-    it('should return true for numbers (as they are not considered collections)', () => {
-        expect(isEmpty(0)).toBe(true);    // Number 0
-        expect(isEmpty(42)).toBe(true);   // Non-zero number
-    });
-
-    it('should return true for booleans (as they are not considered collections)', () => {
-        expect(isEmpty(true)).toBe(true);   // Boolean true
-        expect(isEmpty(false)).toBe(true);  // Boolean false
-    });
-});

package/tests/utilities/isFunction.spec.ts

@@ -1,30 +0,0 @@
-import { isFunction } from '../../src/utilities';
-
-describe('isFunction', () => {
-    it('should return true for actual functions', () => {
-        expect(isFunction(function() {})).toBe(true);  // Regular function
-        expect(isFunction(() => {})).toBe(true);       // Arrow function
-        expect(isFunction(async () => {})).toBe(true); // Async function
-        expect(isFunction(function*() {})).toBe(true); // Generator function
-    });
-
-    it('should return false for class declarations', () => {
-        class MyClass {}
-        expect(isFunction(MyClass)).toBe(false);       // Class declaration should return false
-    });
-
-    it('should return false for function-like objects', () => {
-        const functionLike = { apply: () => {}, call: () => {} };
-        expect(isFunction(functionLike)).toBe(false);  // Function-like object
-    });
-
-    it('should return false for non-function values', () => {
-        expect(isFunction('string')).toBe(false);      // String
-        expect(isFunction(42)).toBe(false);            // Number
-        expect(isFunction({})).toBe(false);            // Object
-        expect(isFunction([])).toBe(false);            // Array
-        expect(isFunction(true)).toBe(false);          // Boolean
-        expect(isFunction(null)).toBe(false);          // Null
-        expect(isFunction(undefined)).toBe(false);     // Undefined
-    });
-});

package/tests/utilities/isNumber.spec.ts

@@ -1,29 +0,0 @@
-import { isNumber } from '../../src/utilities';
-
-describe('isNumber', () => {
-    it('should return true for valid numbers', () => {
-        expect(isNumber(42)).toBe(true);            // Integer
-        expect(isNumber(3.14)).toBe(true);          // Float
-        expect(isNumber(0)).toBe(true);             // Zero
-        expect(isNumber(-100)).toBe(true);          // Negative number
-    });
-
-    it('should return true for special number values', () => {
-        expect(isNumber(NaN)).toBe(true);           // NaN is technically a number in JavaScript
-        expect(isNumber(Infinity)).toBe(true);      // Positive infinity
-        expect(isNumber(-Infinity)).toBe(true);     // Negative infinity
-    });
-
-    it('should return false for non-number types', () => {
-        expect(isNumber('42')).toBe(false);         // String
-        expect(isNumber(true)).toBe(false);         // Boolean
-        expect(isNumber([])).toBe(false);           // Array
-        expect(isNumber({})).toBe(false);           // Object
-        expect(isNumber(null)).toBe(false);         // Null
-        expect(isNumber(undefined)).toBe(false);    // Undefined
-    });
-
-    it('should return false for number-like strings', () => {
-        expect(isNumber('123')).toBe(false);        // String that looks like a number
-    });
-});

package/tests/utilities/isObject.spec.ts

@@ -1,42 +0,0 @@
-import { isObject } from '../../src/utilities';
-
-describe('isObject', () => {
-    it('should return true for plain objects', () => {
-        expect(isObject({})).toBe(true);           // Plain object
-        expect(isObject({ foo: 'bar' })).toBe(true); // Object with properties
-    });
-
-    it('should return false for arrays', () => {
-        expect(isObject([1, 2, 3])).toBe(false);   // Array
-        expect(isObject([])).toBe(false);          // Empty array
-    });
-
-    it('should return false for functions', () => {
-        expect(isObject(function() {})).toBe(false);  // Regular function
-        expect(isObject(() => {})).toBe(false);       // Arrow function
-    });
-
-    it('should return false for special objects like Date', () => {
-        expect(isObject(new Date())).toBe(false);   // Date object
-    });
-
-    it('should return false for special objects like RegExp', () => {
-        expect(isObject(/regex/)).toBe(false);      // RegExp object
-    });
-
-    it('should return false for number objects', () => {
-        expect(isObject(new Number(42))).toBe(false); // Number object
-    });
-
-    it('should return false for string objects', () => {
-        expect(isObject(new String('hello'))).toBe(false); // String object
-    });
-
-    it('should return false for non-object types', () => {
-        expect(isObject(42)).toBe(false);           // Number
-        expect(isObject('hello')).toBe(false);      // String
-        expect(isObject(true)).toBe(false);         // Boolean
-        expect(isObject(null)).toBe(false);         // Null
-        expect(isObject(undefined)).toBe(false);    // Undefined
-    });
-});

package/tests/utilities/isRegEx.spec.ts

@@ -1,33 +0,0 @@
-import { isRegEx } from '../../src/utilities';
-
-describe('isRegEx', () => {
-    it('should return true for regular expressions', () => {
-        expect(isRegEx(/abc/)).toBe(true);             // Regular expression literal
-        expect(isRegEx(new RegExp('abc'))).toBe(true); // RegExp object
-    });
-
-    it('should return false for strings', () => {
-        expect(isRegEx('abc')).toBe(false);            // String
-    });
-
-    it('should return false for objects', () => {
-        expect(isRegEx({ foo: 'bar' })).toBe(false);   // Object
-    });
-
-    it('should return false for arrays', () => {
-        expect(isRegEx([1, 2, 3])).toBe(false);        // Array
-    });
-
-    it('should return false for numbers', () => {
-        expect(isRegEx(123)).toBe(false);              // Number
-    });
-
-    it('should return false for functions', () => {
-        expect(isRegEx(() => {})).toBe(false);         // Function
-    });
-
-    it('should return false for null and undefined', () => {
-        expect(isRegEx(null)).toBe(false);             // Null
-        expect(isRegEx(undefined)).toBe(false);        // Undefined
-    });
-});

package/tests/utilities/isString.spec.ts

@@ -1,25 +0,0 @@
-import { isString } from '../../src/utilities';
-
-describe('isString', () => {
-    it('should return true for string literals', () => {
-        expect(isString('hello')).toBe(true);      // String literal
-        expect(isString('')).toBe(true);           // Empty string
-    });
-
-    it('should return true for string objects', () => {
-        expect(isString(new String('hello'))).toBe(true);  // String object
-    });
-
-    it('should return false for non-string values', () => {
-        expect(isString(123)).toBe(false);         // Number
-        expect(isString(true)).toBe(false);        // Boolean
-        expect(isString([])).toBe(false);          // Array
-        expect(isString({})).toBe(false);          // Object
-        expect(isString(null)).toBe(false);        // Null
-        expect(isString(undefined)).toBe(false);   // Undefined
-    });
-
-    it('should return false for functions', () => {
-        expect(isString(() => {})).toBe(false);    // Function
-    });
-});

package/tests/utilities/isnt.spec.ts

@@ -1,50 +0,0 @@
-import { isnt } from '../../src/utilities';
-
-describe('isnt', () => {
-    it('should return true for different primitive values', () => {
-        expect(isnt(42, '42')).toBe(true);         // Number vs string
-        expect(isnt(42, 43)).toBe(true);           // Different numbers
-        expect(isnt('hello', 'world')).toBe(true); // Different strings
-        expect(isnt(true, false)).toBe(true);      // Different booleans
-    });
-
-    it('should return false for identical primitive values', () => {
-        expect(isnt(42, 42)).toBe(false);          // Same numbers
-        expect(isnt('hello', 'hello')).toBe(false); // Same strings
-        expect(isnt(true, true)).toBe(false);      // Same booleans
-    });
-
-    it('should return true for different objects (reference equality)', () => {
-        const obj1 = { foo: 'bar' };
-        const obj2 = { foo: 'bar' };
-        expect(isnt(obj1, obj2)).toBe(true);       // Different references, even if the structure is the same
-    });
-
-    it('should return false for the same object reference', () => {
-        const obj = { foo: 'bar' };
-        expect(isnt(obj, obj)).toBe(false);        // Same object reference
-    });
-
-    it('should return true for different arrays (reference equality)', () => {
-        const arr1 = [1, 2, 3];
-        const arr2 = [1, 2, 3];
-        expect(isnt(arr1, arr2)).toBe(true);       // Different array instances
-    });
-
-    it('should return false for the same array reference', () => {
-        const arr = [1, 2, 3];
-        expect(isnt(arr, arr)).toBe(false);        // Same array reference
-    });
-
-    it('should return true for null vs undefined', () => {
-        expect(isnt(null, undefined)).toBe(true);  // Null vs undefined
-    });
-
-    it('should return false for two null values', () => {
-        expect(isnt(null, null)).toBe(false);      // Both are null
-    });
-
-    it('should return true for defined vs undefined values', () => {
-        expect(isnt(42, undefined)).toBe(true);    // Defined number vs undefined
-    });
-});

package/tests/utilities/randomId.spec.ts

@@ -1,39 +0,0 @@
-import { randomId } from '../../src/utilities';
-
-describe('randomId', () => {
-    it('should return a string of default length (16)', () => {
-        const result = randomId();
-        expect(result).toBeDefined();
-        expect(typeof result).toBe('string');
-        expect(result.length).toBe(16);  // Default length is 16
-    });
-
-    it('should return a string of specified length', () => {
-        const result = randomId(8);
-        expect(result).toBeDefined();
-        expect(typeof result).toBe('string');
-        expect(result.length).toBe(8);  // Custom length
-    });
-
-    it('should generate different random strings for each call', () => {
-        const result1 = randomId();
-        const result2 = randomId();
-        expect(result1).not.toBe(result2);  // Each call should return a different string
-    });
-
-    it('should only contain characters from the specified character set', () => {
-        const charset = 'ABCDEF123456';
-        const result = randomId(12, charset);
-        expect(result.length).toBe(12);
-        
-        // Ensure every character in the result is part of the charset
-        for (const char of result) {
-            expect(charset.includes(char)).toBe(true);
-        }
-    });
-
-    it('should handle an empty charset by not generating any characters', () => {
-        const result = randomId(10, '');
-        expect(result.length).toBe(0);  // No characters should be generated when charset is empty
-    });
-});

package/tests/utilities/safeApply.spec.ts

@@ -1,49 +0,0 @@
-import { safeApply } from '../../src/utilities';
-
-describe('safeApply', () => {
-    it('should invoke the provided function with given arguments', () => {
-        const fn = jest.fn();
-        const args = [1, 2, 3];
-        const result = safeApply(fn, args);
-        expect(fn).toHaveBeenCalledWith(...args);  // The function should be called with the correct arguments
-        expect(result).toBeUndefined();            // No return value, so should be undefined
-    });
-
-
-    it('should apply the function with a specific context', () => {
-        interface Context {
-            value: number;
-        }
-
-        // Use explicit typing for `this`
-        const fn = function (this: Context) {
-            return this.value;
-        };
-
-        const context = { value: 42 };
-        const result = safeApply(fn, [], context);
-        expect(result).toBe(42);  // The function should use the provided context
-    });
-
-    it('should return undefined if no function is provided', () => {
-        const result = safeApply(undefined, [1, 2, 3]);
-        expect(result).toBeUndefined();            // Should safely return undefined when no function is provided
-    });
-
-    it('should call the error handler if the main function is undefined', () => {
-        const errorHandler = jest.fn();
-        safeApply(undefined, [], undefined, errorHandler);
-        expect(errorHandler).toHaveBeenCalled();   // Error handler should be invoked
-    });
-
-    it('should return undefined if both the main function and error handler are undefined', () => {
-        const result = safeApply(undefined, []);
-        expect(result).toBeUndefined();            // Should return undefined in absence of both main function and error handler
-    });
-
-    it('should pass arguments to the error handler', () => {
-        const errorHandler = jest.fn();
-        safeApply(undefined, [], undefined, errorHandler);
-        expect(errorHandler).toHaveBeenCalledWith();  // Error handler should be called with no arguments in this case
-    });
-});

package/tests/utilities/safeEach.spec.ts

@@ -1,38 +0,0 @@
-import { safeEach } from '../../src/utilities';
-
-describe('safeEach', () => {
-    it('should iterate over each element of the array and apply the callback', () => {
-        const callback = jest.fn();
-        const items = [1, 2, 3];
-        safeEach(items, callback);
-        expect(callback).toHaveBeenCalledTimes(3);  // Callback should be called 3 times
-        expect(callback).toHaveBeenCalledWith(1, 0);  // First call with first element and index 0
-        expect(callback).toHaveBeenCalledWith(2, 1);  // Second call with second element and index 1
-        expect(callback).toHaveBeenCalledWith(3, 2);  // Third call with third element and index 2
-    });
-
-    it('should do nothing if the array is empty', () => {
-        const callback = jest.fn();
-        safeEach([], callback);
-        expect(callback).not.toHaveBeenCalled();  // Callback should not be called for an empty array
-    });
-
-    it('should iterate using a custom increment value', () => {
-        const callback = jest.fn();
-        const items = [1, 2, 3, 4, 5, 6];
-        safeEach(items, callback, 2);  // Custom increment value of 2
-        expect(callback).toHaveBeenCalledTimes(3);  // Only 3 calls: [1, 3, 5]
-        expect(callback).toHaveBeenCalledWith(1, 0);  // First element and index 0
-        expect(callback).toHaveBeenCalledWith(3, 2);  // Third element and index 2
-        expect(callback).toHaveBeenCalledWith(5, 4);  // Fifth element and index 4
-    });
-
-    it('should apply the callback to every nth element based on custom increment', () => {
-        const callback = jest.fn();
-        const items = [10, 20, 30, 40, 50];
-        safeEach(items, callback, 3);  // Custom increment of 3
-        expect(callback).toHaveBeenCalledTimes(2);  // Callback should be called twice: [10, 40]
-        expect(callback).toHaveBeenCalledWith(10, 0);  // First element
-        expect(callback).toHaveBeenCalledWith(40, 3);  // Fourth element
-    });
-});

package/tests/utilities/safeIterate.spec.ts

@@ -1,47 +0,0 @@
-import { safeIterate } from '../../src/utilities';
-
-describe('safeIterate', () => {
-    it('should iterate over an object’s properties and apply the callback', () => {
-        const callback = jest.fn();
-        const obj = { foo: 'bar', baz: 42 };
-        safeIterate(obj, callback);
-
-        expect(callback).toHaveBeenCalledTimes(2);  // Callback should be called twice
-        expect(callback).toHaveBeenCalledWith('foo', 'bar');  // First key-value pair
-        expect(callback).toHaveBeenCalledWith('baz', 42);     // Second key-value pair
-    });
-
-    it('should not call the callback for an empty object', () => {
-        const callback = jest.fn();
-        safeIterate({}, callback);
-
-        expect(callback).not.toHaveBeenCalled();  // Callback should not be called for an empty object
-    });
-
-    it('should not iterate over properties in the prototype chain', () => {
-        const callback = jest.fn();
-        const proto = { inheritedProp: 'should not iterate' };
-        const obj = Object.create(proto);
-        obj.ownProp = 'should iterate';
-
-        safeIterate(obj, callback);
-        
-        expect(callback).toHaveBeenCalledTimes(1);  // Only own property should be iterated over
-        expect(callback).toHaveBeenCalledWith('ownProp', 'should iterate');
-        expect(callback).not.toHaveBeenCalledWith('inheritedProp', 'should not iterate');  // Inherited property should not be iterated over
-    });
-
-    it('should iterate over non-enumerable properties if they are explicitly defined as enumerable', () => {
-        const callback = jest.fn();
-        const obj = {};
-        Object.defineProperty(obj, 'foo', {
-            value: 'bar',
-            enumerable: true,
-        });
-
-        safeIterate(obj, callback);
-
-        expect(callback).toHaveBeenCalledTimes(1);  // Non-enumerable properties should be skipped unless explicitly enumerable
-        expect(callback).toHaveBeenCalledWith('foo', 'bar');
-    });
-});

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es6",
-    "module": "commonjs",
-    "sourceMap": true,
-    "outDir": "./dist",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true
-  },
-  "include": [
-    "src/**/*.ts",
-    "test/**/*.ts"
-  ]
-}