querier-ts 2.1.0 → 2.2.0

package/lib/core/validation/__tests__/query-row-validator.spec.js

@@ -1,195 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const query_row_validator_1 = require("../query-row-validator");
-describe('QueryRowValidator', () => {
-    describe('primitive comparisons', () => {
-        it('should validate equality for primitive values', () => {
-            const row = { id: 1, name: 'Alice' };
-            const result = query_row_validator_1.QueryRowValidator.validate(row, {
-                conditionsObject: {
-                    id: 1,
-                    name: 'Alice',
-                },
-                ignoreNullValues: false,
-            });
-            expect(result).toBe(true);
-        });
-        it('should return false when primitive values differ', () => {
-            const row = { id: 1 };
-            const result = query_row_validator_1.QueryRowValidator.validate(row, {
-                conditionsObject: {
-                    id: 2,
-                },
-                ignoreNullValues: false,
-            });
-            expect(result).toBe(false);
-        });
-    });
-    describe('function conditions', () => {
-        it('should validate using a function condition', () => {
-            const row = { age: 30 };
-            const result = query_row_validator_1.QueryRowValidator.validate(row, {
-                conditionsObject: {
-                    age: (value) => value > 18,
-                },
-                ignoreNullValues: false,
-            });
-            expect(result).toBe(true);
-        });
-        it('should return false when function condition fails', () => {
-            const row = { age: 15 };
-            const result = query_row_validator_1.QueryRowValidator.validate(row, {
-                conditionsObject: {
-                    age: (value) => value > 18,
-                },
-                ignoreNullValues: false,
-            });
-            expect(result).toBe(false);
-        });
-    });
-    describe('array conditions', () => {
-        it('should validate arrays using strict comparison', () => {
-            const row = { tags: ['a', 'b'] };
-            const result = query_row_validator_1.QueryRowValidator.validate(row, {
-                conditionsObject: {
-                    tags: ['a', 'b'],
-                },
-                ignoreNullValues: false,
-            });
-            expect(result).toBe(true);
-        });
-        it('should return false for arrays with different values', () => {
-            const row = { tags: ['a', 'b'] };
-            const result = query_row_validator_1.QueryRowValidator.validate(row, {
-                conditionsObject: {
-                    tags: ['a', 'c'],
-                },
-                ignoreNullValues: false,
-            });
-            expect(result).toBe(false);
-        });
-        it('should return false if condition is array but value is not', () => {
-            const row = { tags: 'a,b' };
-            const result = query_row_validator_1.QueryRowValidator.validate(row, {
-                conditionsObject: {
-                    tags: ['a', 'b'],
-                },
-                ignoreNullValues: false,
-            });
-            expect(result).toBe(false);
-        });
-    });
-    describe('object conditions (nested validation)', () => {
-        it('should validate nested objects recursively', () => {
-            const row = {
-                user: {
-                    name: 'John',
-                    age: 25,
-                },
-            };
-            const result = query_row_validator_1.QueryRowValidator.validate(row, {
-                conditionsObject: {
-                    user: {
-                        name: 'John',
-                        age: (value) => value >= 18,
-                    },
-                },
-                ignoreNullValues: false,
-            });
-            expect(result).toBe(true);
-        });
-        it('should return false when nested validation fails', () => {
-            const row = {
-                user: {
-                    name: 'John',
-                    age: 15,
-                },
-            };
-            const result = query_row_validator_1.QueryRowValidator.validate(row, {
-                conditionsObject: {
-                    user: {
-                        age: (value) => value >= 18,
-                    },
-                },
-                ignoreNullValues: false,
-            });
-            expect(result).toBe(false);
-        });
-        it('should return false if condition is object but value is not', () => {
-            const row = {
-                user: 'John',
-            };
-            const result = query_row_validator_1.QueryRowValidator.validate(row, {
-                conditionsObject: {
-                    user: { name: 'John' },
-                },
-                ignoreNullValues: false,
-            });
-            expect(result).toBe(false);
-        });
-    });
-    describe('ignoreNullValues behavior', () => {
-        it('should ignore null conditions when ignoreNullValues is true', () => {
-            const row = { name: 'Alice' };
-            const result = query_row_validator_1.QueryRowValidator.validate(row, {
-                conditionsObject: {
-                    name: null,
-                },
-                ignoreNullValues: true,
-            });
-            expect(result).toBe(true);
-        });
-        it('should ignore undefined conditions when ignoreNullValues is true', () => {
-            const row = { name: 'Alice' };
-            const result = query_row_validator_1.QueryRowValidator.validate(row, {
-                conditionsObject: {
-                    name: undefined,
-                },
-                ignoreNullValues: true,
-            });
-            expect(result).toBe(true);
-        });
-        it('should NOT ignore null when ignoreNullValues is false', () => {
-            const row = { name: 'Alice' };
-            const result = query_row_validator_1.QueryRowValidator.validate(row, {
-                conditionsObject: {
-                    name: null,
-                },
-                ignoreNullValues: false,
-            });
-            expect(result).toBe(false);
-        });
-    });
-    describe('multiple conditions', () => {
-        it('should return true only if all conditions pass', () => {
-            const row = {
-                id: 1,
-                active: true,
-                roles: ['admin'],
-            };
-            const result = query_row_validator_1.QueryRowValidator.validate(row, {
-                conditionsObject: {
-                    id: 1,
-                    active: true,
-                    roles: ['admin'],
-                },
-                ignoreNullValues: false,
-            });
-            expect(result).toBe(true);
-        });
-        it('should return false if at least one condition fails', () => {
-            const row = {
-                id: 1,
-                active: false,
-            };
-            const result = query_row_validator_1.QueryRowValidator.validate(row, {
-                conditionsObject: {
-                    id: 1,
-                    active: true,
-                },
-                ignoreNullValues: false,
-            });
-            expect(result).toBe(false);
-        });
-    });
-});

package/lib/core/validation/decorators/__tests__/number-validation.spec.d.ts

@@ -1 +0,0 @@
-import 'reflect-metadata';

package/lib/core/validation/decorators/__tests__/number-validation.spec.js

@@ -1,114 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-require("reflect-metadata");
-const errors_1 = require("../../../errors");
-const number_validaton_1 = require("../number-validaton");
-class TestService {
-    sum(a, b, c) {
-        return a + b + c;
-    }
-    onlyInteger(value) {
-        return value;
-    }
-    ranged(value) {
-        return value;
-    }
-}
-__decorate([
-    number_validaton_1.validateNumbers,
-    __param(0, (0, number_validaton_1.min)(0)),
-    __param(1, (0, number_validaton_1.max)(10)),
-    __param(2, number_validaton_1.integer)
-], TestService.prototype, "sum", null);
-__decorate([
-    number_validaton_1.validateNumbers,
-    __param(0, number_validaton_1.integer)
-], TestService.prototype, "onlyInteger", null);
-__decorate([
-    number_validaton_1.validateNumbers,
-    __param(0, (0, number_validaton_1.min)(5)),
-    __param(0, (0, number_validaton_1.max)(10))
-], TestService.prototype, "ranged", null);
-describe('number decorators', () => {
-    let service;
-    beforeEach(() => {
-        service = new TestService();
-    });
-    describe('valid scenarios', () => {
-        it('should allow valid arguments', () => {
-            expect(service.sum(1, 5, 3)).toBe(9);
-        });
-        it('should allow integer values', () => {
-            expect(service.onlyInteger(10)).toBe(10);
-        });
-        it('should allow values within min/max range', () => {
-            expect(service.ranged(5)).toBe(5);
-            expect(service.ranged(10)).toBe(10);
-        });
-    });
-    describe('min decorator', () => {
-        it('should throw if value is less than min', () => {
-            expect(() => service.sum(-1, 5, 3)).toThrow(errors_1.InvalidArgumentError);
-        });
-        it('should throw with correct error message', () => {
-            try {
-                service.sum(-1, 5, 3);
-            }
-            catch (e) {
-                expect(e).toBeInstanceOf(errors_1.InvalidArgumentError);
-                expect(e.message).toContain('equal or greater than 0');
-            }
-        });
-    });
-    describe('max decorator', () => {
-        it('should throw if value is greater than max', () => {
-            expect(() => service.sum(1, 20, 3)).toThrow(errors_1.InvalidArgumentError);
-        });
-        it('should throw with correct error message', () => {
-            try {
-                service.sum(1, 20, 3);
-            }
-            catch (e) {
-                expect(e).toBeInstanceOf(errors_1.InvalidArgumentError);
-                expect(e.message).toContain('equal or less than 10');
-            }
-        });
-    });
-    describe('integer decorator', () => {
-        it('should throw if value is not an integer', () => {
-            expect(() => service.onlyInteger(1.5)).toThrow(errors_1.InvalidArgumentError);
-        });
-        it('should accept safe integers', () => {
-            expect(service.onlyInteger(Number.MAX_SAFE_INTEGER)).toBe(Number.MAX_SAFE_INTEGER);
-        });
-        it('should throw if value is NaN', () => {
-            expect(() => service.onlyInteger(NaN)).toThrow(errors_1.InvalidArgumentError);
-        });
-    });
-    describe('combined decorators', () => {
-        it('should validate min and max together', () => {
-            expect(() => service.ranged(4)).toThrow(errors_1.InvalidArgumentError);
-            expect(() => service.ranged(11)).toThrow(errors_1.InvalidArgumentError);
-        });
-        it('should pass when all constraints are satisfied', () => {
-            expect(service.ranged(7)).toBe(7);
-        });
-    });
-    describe('type validation', () => {
-        it('should throw if value is not a number for min', () => {
-            expect(() => service.sum('1', 5, 3)).toThrow(errors_1.InvalidArgumentError);
-        });
-        it('should throw if value is not a number for max', () => {
-            expect(() => service.sum(1, '5', 3)).toThrow(errors_1.InvalidArgumentError);
-        });
-    });
-});

package/lib/utils/functions/generic/__tests__/compare-arrays.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/utils/functions/generic/__tests__/compare-arrays.spec.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const compare_arrays_1 = require("../compare-arrays");
-describe('compareArrays', () => {
-    it('returns true for ly equal arrays', () => {
-        const a = [{ x: 1 }, { y: 2 }];
-        const b = [{ x: 1 }, { y: 2 }];
-        expect((0, compare_arrays_1.compareArrays)(a, b)).toBe(true);
-    });
-    it('returns false for ly different arrays', () => {
-        expect((0, compare_arrays_1.compareArrays)([{ x: 1 }], [{ x: 2 }])).toBe(false);
-    });
-    it('returns false when order differs', () => {
-        expect((0, compare_arrays_1.compareArrays)([{ a: 1 }, { b: 2 }], [{ b: 2 }, { a: 1 }])).toBe(false);
-    });
-    it('works with nested objects', () => {
-        const a = [{ x: { y: 1 } }];
-        const b = [{ x: { y: 1 } }];
-        expect((0, compare_arrays_1.compareArrays)(a, b)).toBe(true);
-    });
-});

package/lib/utils/functions/generic/__tests__/deep-equal.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/utils/functions/generic/__tests__/deep-equal.spec.js

@@ -1,82 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const deep_equal_1 = require("../deep-equal");
-describe('deepEqual', () => {
-    describe('primitive values', () => {
-        it('returns true for strictly equal primitives', () => {
-            expect((0, deep_equal_1.deepEqual)(1, 1)).toBe(true);
-            expect((0, deep_equal_1.deepEqual)('a', 'a')).toBe(true);
-            expect((0, deep_equal_1.deepEqual)(true, true)).toBe(true);
-            expect((0, deep_equal_1.deepEqual)(null, null)).toBe(true);
-            expect((0, deep_equal_1.deepEqual)(undefined, undefined)).toBe(true);
-        });
-        it('returns false for different primitive values', () => {
-            expect((0, deep_equal_1.deepEqual)(1, 2)).toBe(false);
-            expect((0, deep_equal_1.deepEqual)('a', 'b')).toBe(false);
-            expect((0, deep_equal_1.deepEqual)(true, false)).toBe(false);
-            expect((0, deep_equal_1.deepEqual)(null, undefined)).toBe(false);
-        });
-    });
-    describe('objects', () => {
-        it('returns true for deeply equal plain objects', () => {
-            const a = { x: 1, y: 2 };
-            const b = { x: 1, y: 2 };
-            expect((0, deep_equal_1.deepEqual)(a, b)).toBe(true);
-        });
-        it('returns false for objects with different keys', () => {
-            expect((0, deep_equal_1.deepEqual)({ x: 1 }, { y: 1 })).toBe(false);
-        });
-        it('returns false for objects with same keys but different values', () => {
-            expect((0, deep_equal_1.deepEqual)({ x: 1 }, { x: 2 })).toBe(false);
-        });
-        it('returns false when one object has extra keys', () => {
-            expect((0, deep_equal_1.deepEqual)({ x: 1 }, { x: 1, y: 2 })).toBe(false);
-        });
-    });
-    describe('nested structures', () => {
-        it('returns true for deeply nested objects', () => {
-            const a = { x: { y: { z: 1 } } };
-            const b = { x: { y: { z: 1 } } };
-            expect((0, deep_equal_1.deepEqual)(a, b)).toBe(true);
-        });
-        it('returns false for deeply nested differences', () => {
-            const a = { x: { y: { z: 1 } } };
-            const b = { x: { y: { z: 2 } } };
-            expect((0, deep_equal_1.deepEqual)(a, b)).toBe(false);
-        });
-    });
-    describe('arrays', () => {
-        it('returns true for deeply equal arrays', () => {
-            expect((0, deep_equal_1.deepEqual)([1, 2, 3], [1, 2, 3])).toBe(true);
-        });
-        it('returns false for arrays with different order', () => {
-            expect((0, deep_equal_1.deepEqual)([1, 2, 3], [3, 2, 1])).toBe(false);
-        });
-        it('returns true for arrays with nested objects', () => {
-            const a = [{ x: 1 }, { y: 2 }];
-            const b = [{ x: 1 }, { y: 2 }];
-            expect((0, deep_equal_1.deepEqual)(a, b)).toBe(true);
-        });
-        it('returns false for arrays with different lengths', () => {
-            expect((0, deep_equal_1.deepEqual)([1, 2], [1, 2, 3])).toBe(false);
-        });
-    });
-    describe('mixed and edge cases', () => {
-        it('returns false when comparing array and object', () => {
-            expect((0, deep_equal_1.deepEqual)([], {})).toBe(false);
-        });
-        it('returns false when one value is object and the other is primitive', () => {
-            expect((0, deep_equal_1.deepEqual)({ x: 1 }, 1)).toBe(false);
-        });
-        it('returns true for same object reference', () => {
-            const obj = { x: 1 };
-            expect((0, deep_equal_1.deepEqual)(obj, obj)).toBe(true);
-        });
-        it('returns false for Date objects with same value (by design)', () => {
-            const a = new Date(2020, 1, 1);
-            const b = new Date(2020, 1, 1);
-            // Date has no enumerable keys, so this documents the limitation
-            expect((0, deep_equal_1.deepEqual)(a, b)).toBe(true);
-        });
-    });
-});

package/lib/utils/functions/generic/__tests__/get-entries.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/utils/functions/generic/__tests__/get-entries.spec.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const get_entries_1 = require("../get-entries");
-describe('getEntries', () => {
-    it('should return entries for a simple object', () => {
-        const obj = {
-            a: 1,
-            b: 2,
-        };
-        const entries = (0, get_entries_1.getEntries)(obj);
-        expect(entries).toEqual([
-            ['a', 1],
-            ['b', 2],
-        ]);
-    });
-    it('should return an empty array for an empty object', () => {
-        const obj = {};
-        const entries = (0, get_entries_1.getEntries)(obj);
-        expect(entries).toEqual([]);
-    });
-    it('should work with different value types', () => {
-        const obj = {
-            name: 'Alice',
-            age: 30,
-            active: true,
-        };
-        const entries = (0, get_entries_1.getEntries)(obj);
-        expect(entries).toEqual([
-            ['name', 'Alice'],
-            ['age', 30],
-            ['active', true],
-        ]);
-    });
-    it('should preserve key-value association', () => {
-        const obj = {
-            x: 10,
-            y: 20,
-        };
-        const entries = (0, get_entries_1.getEntries)(obj);
-        for (const [key, value] of entries) {
-            expect(obj[key]).toBe(value);
-        }
-    });
-    it('should provide correct typing for keys and values (type-level test)', () => {
-        const obj = {
-            id: 1,
-            title: 'Post',
-        };
-        const entries = (0, get_entries_1.getEntries)(obj);
-        const key = 'id';
-        const value = obj[key];
-        expect(key).toBe('id');
-        expect(value).toBe(1);
-    });
-});

package/lib/utils/functions/sort/__tests__/sort-by-properties.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/utils/functions/sort/__tests__/sort-by-properties.spec.js

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const sort_by_properties_1 = require("../sort-by-properties");
-describe('sortByProperties', () => {
-    it('sorts by a single property', () => {
-        const data = [
-            { id: 2, name: 'B' },
-            { id: 1, name: 'A' },
-        ];
-        data.sort((0, sort_by_properties_1.sortByProperties)('id'));
-        expect(data).toEqual([
-            { id: 1, name: 'A' },
-            { id: 2, name: 'B' },
-        ]);
-    });
-    it('sorts by multiple properties in order', () => {
-        const data = [
-            { id: 1, name: 'Bob', age: 30 },
-            { id: 2, name: 'Alice', age: 30 },
-            { id: 3, name: 'Alice', age: 25 },
-        ];
-        data.sort((0, sort_by_properties_1.sortByProperties)('name', 'age'));
-        expect(data).toEqual([
-            { id: 3, name: 'Alice', age: 25 },
-            { id: 2, name: 'Alice', age: 30 },
-            { id: 1, name: 'Bob', age: 30 },
-        ]);
-    });
-    it('supports descending order with "-" prefix', () => {
-        const data = [
-            { id: 1, name: 'Bob', age: 30 },
-            { id: 2, name: 'Alice', age: 30 },
-            { id: 3, name: 'Alice', age: 25 },
-        ];
-        data.sort((0, sort_by_properties_1.sortByProperties)('name', '-age'));
-        expect(data).toEqual([
-            { id: 2, name: 'Alice', age: 30 },
-            { id: 3, name: 'Alice', age: 25 },
-            { id: 1, name: 'Bob', age: 30 },
-        ]);
-    });
-    it('places undefined values last when used as secondary key', () => {
-        const data = [
-            { id: 1, name: 'Alice' },
-            { id: 2, name: 'Alice', age: 20 },
-            { id: 3, name: 'Alice', age: 10 },
-        ];
-        data.sort((0, sort_by_properties_1.sortByProperties)('name', 'age'));
-        expect(data).toEqual([
-            { id: 3, name: 'Alice', age: 10 },
-            { id: 2, name: 'Alice', age: 20 },
-            { id: 1, name: 'Alice' },
-        ]);
-    });
-    it('returns 0 when all compared properties are equal', () => {
-        const comparator = (0, sort_by_properties_1.sortByProperties)('name', 'age');
-        expect(comparator({ id: 1, name: 'Alice', age: 20 }, { id: 2, name: 'Alice', age: 20 })).toBe(0);
-    });
-    it('returns 0 when no properties are provided', () => {
-        const comparator = (0, sort_by_properties_1.sortByProperties)();
-        expect(comparator({ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' })).toBe(0);
-    });
-    it('enforces type safety at compile time', () => {
-        // @ts-expect-error
-        (0, sort_by_properties_1.sortByProperties)('invalid');
-        // @ts-expect-error
-        (0, sort_by_properties_1.sortByProperties)('-invalid');
-    });
-});

package/lib/utils/functions/sort/__tests__/sort-by-property.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/utils/functions/sort/__tests__/sort-by-property.spec.js

@@ -1,63 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const sort_by_property_1 = require("../sort-by-property");
-describe('sortByProperty (improved)', () => {
-    describe('ascending order', () => {
-        it('sorts by numeric property', () => {
-            const data = [{ id: 3 }, { id: 1 }, { id: 2 }];
-            data.sort((0, sort_by_property_1.sortByProperty)('id'));
-            expect(data).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
-        });
-        it('sorts by string property', () => {
-            const data = [{ name: 'Charlie' }, { name: 'Alice' }, { name: 'Bob' }];
-            data.sort((0, sort_by_property_1.sortByProperty)('name'));
-            expect(data).toEqual([
-                { name: 'Alice' },
-                { name: 'Bob' },
-                { name: 'Charlie' },
-            ]);
-        });
-    });
-    describe('descending order', () => {
-        it('sorts by numeric property descending', () => {
-            const data = [{ score: 10 }, { score: 30 }, { score: 20 }];
-            data.sort((0, sort_by_property_1.sortByProperty)('-score'));
-            expect(data).toEqual([{ score: 30 }, { score: 20 }, { score: 10 }]);
-        });
-        it('sorts by string property descending', () => {
-            const data = [{ name: 'Alice' }, { name: 'Charlie' }, { name: 'Bob' }];
-            data.sort((0, sort_by_property_1.sortByProperty)('-name'));
-            expect(data).toEqual([
-                { name: 'Charlie' },
-                { name: 'Bob' },
-                { name: 'Alice' },
-            ]);
-        });
-    });
-    describe('null and undefined handling', () => {
-        it('places undefined values last', () => {
-            const data = [{ value: 2 }, { value: undefined }, { value: 1 }];
-            data.sort((0, sort_by_property_1.sortByProperty)('value'));
-            expect(data).toEqual([{ value: 1 }, { value: 2 }, { value: undefined }]);
-        });
-        it('places null values last', () => {
-            const data = [{ value: 2 }, { value: null }, { value: 1 }];
-            data.sort((0, sort_by_property_1.sortByProperty)('value'));
-            expect(data).toEqual([{ value: 1 }, { value: 2 }, { value: null }]);
-        });
-    });
-    describe('equal values', () => {
-        it('returns 0 for equal property values', () => {
-            const comparator = (0, sort_by_property_1.sortByProperty)('id');
-            expect(comparator({ id: 1 }, { id: 1 })).toBe(0);
-        });
-    });
-    describe('type safety (compile-time)', () => {
-        it('does not allow invalid properties', () => {
-            // @ts-expect-error
-            (0, sort_by_property_1.sortByProperty)('invalid');
-            // @ts-expect-error
-            (0, sort_by_property_1.sortByProperty)('-invalid');
-        });
-    });
-});

package/lib/utils/functions/type-guards/__tests__/is-function.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/utils/functions/type-guards/__tests__/is-function.spec.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const is_function_1 = require("../is-function");
-describe('isFunction', () => {
-    it('should return true for regular functions', () => {
-        const fn = () => { };
-        expect((0, is_function_1.isFunction)(fn)).toBe(true);
-    });
-    it('should return true for async functions', () => {
-        const fn = async () => { };
-        expect((0, is_function_1.isFunction)(fn)).toBe(true);
-    });
-    it('should return true for class constructors', () => {
-        class Test {
-        }
-        expect((0, is_function_1.isFunction)(Test)).toBe(true);
-    });
-    it('should return false for non-function values', () => {
-        expect((0, is_function_1.isFunction)(123)).toBe(false);
-        expect((0, is_function_1.isFunction)('string')).toBe(false);
-        expect((0, is_function_1.isFunction)(null)).toBe(false);
-        expect((0, is_function_1.isFunction)(undefined)).toBe(false);
-        expect((0, is_function_1.isFunction)({})).toBe(false);
-        expect((0, is_function_1.isFunction)([])).toBe(false);
-        expect((0, is_function_1.isFunction)(true)).toBe(false);
-    });
-    it('should narrow the type when returning true (type guard)', () => {
-        const value = () => 'hello';
-        if ((0, is_function_1.isFunction)(value)) {
-            // If this compiles, the type guard works
-            const result = value();
-            expect(result).toBe('hello');
-        }
-        else {
-            fail('Expected value to be a function');
-        }
-    });
-});

package/lib/utils/functions/type-guards/__tests__/is-number.spec.d.ts

@@ -1 +0,0 @@
-export {};