@wxn0brp/db-core 0.11.5 → 0.12.0-alpha.0

package/dist/helpers/executor.js

@@ -12,9 +12,11 @@ export class Executor {
         return await new Promise((resolve, reject) => {
             this.queue.push({
                 func,
-                param: [query],
+                param: [
+                    query,
+                ],
                 resolve,
-                reject
+                reject,
             });
             this.execute();
         });
@@ -28,7 +30,10 @@ export class Executor {
         this.isExecuting = true;
         while (this.queue.length > 0) {
             const q = this.queue.shift();
-            await q.func(...q.param).then(q.resolve).catch(q.reject);
+            await q
+                .func(...q.param)
+                .then(q.resolve)
+                .catch(q.reject);
         }
         this.isExecuting = false;
     }
@@ -45,14 +50,14 @@ export class SmartExecutor {
         this.aware = aware;
     }
     async addOp(func, query, collection) {
-        const key = this.aware ?
-            collection ?? defaultCollection :
-            defaultCollection;
+        const key = this.aware
+            ? (collection ?? defaultCollection)
+            : defaultCollection;
         let entry = this.collections.get(key);
         if (!entry) {
             entry = {
                 executor: new Executor(),
-                interval: null
+                interval: null,
             };
             this.collections.set(key, entry);
         }

package/dist/helpers/forge.d.ts

@@ -2,12 +2,6 @@ import { Collection } from "./collection.js";
 import { Data } from "../types/data.js";
 import { ValtheraCompatible } from "../types/valthera.js";
 import { ValtheraClass } from "../db/valthera.js";
-export declare function forgeValthera<T extends string>(target: ValtheraClass): ValtheraClass & {
-    [K in T]: Collection;
-};
-export declare function forgeValthera<T extends string>(target: ValtheraCompatible): ValtheraCompatible & {
-    [K in T]: Collection;
-};
 export declare function forgeTypedValthera<T extends Record<string, Data>>(target: ValtheraClass): ValtheraClass & {
     [K in keyof T]: Collection<T[K]>;
 };

package/dist/helpers/forge.js

@@ -1,7 +1,4 @@
 import { Collection } from "./collection.js";
-export function forgeValthera(target) {
-    return forgeTypedValthera(target);
-}
 export function forgeTypedValthera(target) {
     return new Proxy(target, {
         get(target, prop, receiver) {
@@ -14,6 +11,6 @@ export function forgeTypedValthera(target) {
         },
         set(target, prop, value, receiver) {
             return Reflect.set(target, prop, value, receiver);
-        }
+        },
     });
 }

package/dist/helpers/gen.js

@@ -17,7 +17,10 @@ const defaultIdData = getIdData();
  */
 export function genId(parts = null, idData = defaultIdData) {
     if (parts === null)
-        parts = [1, 1];
+        parts = [
+            1,
+            1,
+        ];
     const time = getTime();
     const id = getUniqueRandom({
         time,
@@ -43,7 +46,10 @@ function getUniqueRandom(opts, idData) {
         const partsLengthSum = opts.partsSchema.reduce((acc, num) => acc + num, 0);
         const partsData = generateBase36InRange(minValue, partsLengthSum, idData);
         const parts = splitStringByArray(opts.partsSchema, partsData);
-        const id = [opts.time, ...parts].join("-");
+        const id = [
+            opts.time,
+            ...parts,
+        ].join("-");
         if (!idData.usedIds.has(id)) {
             idData.usedIds.set(id, true);
             setTimeout(() => idData.usedIds.delete(id), 1000);
@@ -130,11 +136,12 @@ function biasedRandomInRange(min, max) {
  */
 function splitStringByArray(arr, str) {
     let start = 0;
-    return arr.map(length => str.slice(start, start += length));
+    // biome-ignore lint/suspicious/noAssignInExpressions: false positive
+    return arr.map(length => str.slice(start, (start += length)));
 }
 /**
  * Gets the current time in a base36 string format.
  */
 function getTime() {
-    return new Date().getTime().toString(36);
+    return Date.now().toString(36);
 }

package/dist/helpers/relation.d.ts

@@ -2,7 +2,10 @@ import { Search } from "../types/arg.js";
 import { DbFindOpts } from "../types/options.js";
 import { RelationTypes } from "../types/relation.js";
 export declare function pickByPath(obj: any, paths: string[][]): any;
-export declare function autoSelect(rel: RelationTypes.RelationConfig, key: string): [string[] | undefined, boolean];
+export declare function autoSelect(rel: RelationTypes.RelationConfig, key: string): [
+    string[] | undefined,
+    boolean
+];
 export declare function convertSearchObjToSearchArray(obj: Record<string, any>, parentKeys?: string[]): string[][];
 export declare function processRelations(dbs: RelationTypes.DBS, cfg: RelationTypes.Relation, data: any, parentList?: any[] | null): Promise<void>;
 export declare class Relation {

package/dist/helpers/relation.js

@@ -20,23 +20,41 @@ export function pickByPath(obj, paths) {
     return result;
 }
 export function autoSelect(rel, key) {
-    const select = Array.isArray(rel.select) ? [...rel.select] : undefined;
+    const select = Array.isArray(rel.select)
+        ? [
+            ...rel.select,
+        ]
+        : undefined;
     const shouldDelete = select && !select.includes(key);
     if (shouldDelete)
         select.push(key);
-    return [select, shouldDelete];
+    return [
+        select,
+        shouldDelete,
+    ];
 }
 export function convertSearchObjToSearchArray(obj, parentKeys = []) {
     return Object.entries(obj).reduce((acc, [key, value]) => {
-        const currentPath = [...parentKeys, key];
+        const currentPath = [
+            ...parentKeys,
+            key,
+        ];
         if (!value) {
             return acc;
         }
-        else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-            return [...acc, ...convertSearchObjToSearchArray(value, currentPath)];
+        else if (typeof value === "object" &&
+            value !== null &&
+            !Array.isArray(value)) {
+            return [
+                ...acc,
+                ...convertSearchObjToSearchArray(value, currentPath),
+            ];
         }
         else {
-            return [...acc, currentPath];
+            return [
+                ...acc,
+                currentPath,
+            ];
         }
     }, []);
 }
@@ -44,23 +62,38 @@ export async function processRelations(dbs, cfg, data, parentList = null) {
     if (!data && !parentList)
         return;
     const batchMode = Array.isArray(parentList);
-    const targets = batchMode ? parentList : [data];
+    const targets = batchMode
+        ? parentList
+        : [
+            data,
+        ];
     for (const key in cfg) {
-        if (!cfg.hasOwnProperty(key))
+        if (!Object.hasOwn(cfg, key))
             continue;
         const rel = cfg[key];
-        const { pk = "_id", fk = "_id", type = "1", path, as = key, select, dbFindOpts = {}, through } = rel;
+        const { pk = "_id", fk = "_id", type = "1", path, as = key, select, dbFindOpts = {}, through, } = rel;
         const [dbKey, collection] = path;
         const db = dbs[dbKey];
         if (type === "1") {
-            const keys = [...new Set(targets.map(i => i[pk]))];
+            const keys = [
+                ...new Set(targets.map(i => i[pk])),
+            ];
             const [selectSafe, deleteSelect] = autoSelect(rel, fk);
             const results = await db.find({
                 collection,
-                search: { $in: { [fk]: keys } },
-                findOpts: { select: selectSafe }
+                search: {
+                    $in: {
+                        [fk]: keys,
+                    },
+                },
+                findOpts: {
+                    select: selectSafe,
+                },
             });
-            const map = new Map(results.map(row => [row[fk], row]));
+            const map = new Map(results.map(row => [
+                row[fk],
+                row,
+            ]));
             for (const item of targets) {
                 const result = map.get(item[pk]) || null;
                 if (result && rel.relations)
@@ -78,8 +111,12 @@ export async function processRelations(dbs, cfg, data, parentList = null) {
                 if (!cache.has(id))
                     cache.set(id, await db.findOne({
                         collection,
-                        search: { [fk]: id },
-                        findOpts: { select: selectSafe }
+                        search: {
+                            [fk]: id,
+                        },
+                        findOpts: {
+                            select: selectSafe,
+                        },
                     }));
                 const result = cache.get(id) || null;
                 if (result && rel.relations)
@@ -94,13 +131,20 @@ export async function processRelations(dbs, cfg, data, parentList = null) {
             const [selectSafe, deleteSelect] = autoSelect(rel, fk);
             const results = await db.find({
                 collection,
-                search: { $in: { [fk]: ids } },
+                search: {
+                    $in: {
+                        [fk]: ids,
+                    },
+                },
                 dbFindOpts,
-                findOpts: { select: selectSafe }
+                findOpts: {
+                    select: selectSafe,
+                },
             });
             const grouped = results.reduce((acc, row) => {
                 const id = row[fk];
-                (acc[id] ||= []).push(row);
+                acc[id] ||= [];
+                acc[id].push(row);
                 return acc;
             }, {});
             for (const item of targets)
@@ -118,13 +162,21 @@ export async function processRelations(dbs, cfg, data, parentList = null) {
                 const pivotDb = dbs[through.db || dbKey];
                 const pivots = await pivotDb.find({
                     collection: through.table,
-                    search: { [through.pk]: item[pk] }
+                    search: {
+                        [through.pk]: item[pk],
+                    },
                 });
                 const ids = pivots.map(p => p[through.fk]);
                 const related = await db.find({
                     collection,
-                    search: { $in: { [fk]: ids } },
-                    findOpts: { select }
+                    search: {
+                        $in: {
+                            [fk]: ids,
+                        },
+                    },
+                    findOpts: {
+                        select,
+                    },
                 });
                 item[as] = related;
                 if (rel.relations) {
@@ -145,7 +197,10 @@ export class Relation {
     async findOne(path, search, relations, select) {
         const [dbKey, collection] = path;
         const db = this.dbs[dbKey];
-        const data = await db.findOne({ collection, search });
+        const data = await db.findOne({
+            collection,
+            search,
+        });
         if (!data)
             return null;
         if (typeof select === "object" && !Array.isArray(select))
@@ -156,7 +211,11 @@ export class Relation {
     async find(path, search, relations, select, dbFindOpts = {}) {
         const [dbKey, collection] = path;
         const db = this.dbs[dbKey];
-        const data = await db.find({ collection, search, dbFindOpts });
+        const data = await db.find({
+            collection,
+            search,
+            dbFindOpts,
+        });
         if (relations)
             await processRelations(this.dbs, relations, null, data);
         if (typeof select === "object" && !Array.isArray(select))

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { CustomFileCpu } from "./customFileCpu.js";
 export { createMemoryValthera, ValtheraMemory } from "./db/memory.js";
 export { ValtheraClass } from "./db/valthera.js";
-export { forgeTypedValthera, forgeValthera } from "./helpers/forge.js";
+export { forgeTypedValthera } from "./helpers/forge.js";
 export { genId } from "./helpers/gen.js";
 export { Relation } from "./helpers/relation.js";
 export { convertIdToUnix, sortByIds } from "./utils/id.js";

package/dist/index.js

@@ -1,7 +1,7 @@
 export { CustomFileCpu } from "./customFileCpu.js";
 export { createMemoryValthera, ValtheraMemory } from "./db/memory.js";
 export { ValtheraClass } from "./db/valthera.js";
-export { forgeTypedValthera, forgeValthera } from "./helpers/forge.js";
+export { forgeTypedValthera } from "./helpers/forge.js";
 export { genId } from "./helpers/gen.js";
 export { Relation } from "./helpers/relation.js";
 export { convertIdToUnix, sortByIds } from "./utils/id.js";

package/dist/types/action.d.ts

@@ -1,8 +1,10 @@
 import { DataInternal } from "./data.js";
+import { AdapterOpts } from "./options.js";
 import { VQueryT } from "./query.js";
 export interface ActionsBaseInterface {
     _inited: boolean;
-    numberId: boolean;
+    adapterOpts: AdapterOpts;
+    smartExecutor: boolean;
     init(...args: any[]): Promise<void>;
     close(...args: any[]): Promise<void>;
     getCollections(): Promise<string[]>;

package/dist/types/export.d.ts

@@ -5,6 +5,7 @@ export declare namespace ValtheraTypes {
     type DbFindOpts = import("./options.js").DbFindOpts;
     type FindOpts = import("./options.js").FindOpts;
     type DbOpts = import("./options.js").DbOpts;
+    type AdapterOpts = import("./options.js").AdapterOpts;
     type Data = import("./data.js").Data;
     type SearchOptions = import("./searchOpts.js").SearchOptions;
     type Id = import("./Id.js").Id;

package/dist/types/fileCpu.d.ts

@@ -17,10 +17,10 @@ export interface FileCpu {
      */
     findOne(file: string, config: VQueryT.FindOne, opts?: any): Promise<DataInternal | false>;
     /**
-   * Asynchronously removes entries from a file based on search criteria.
-   * @param one If `true`, removes only the first matching entry.
-   * @returns A promise resolving to `true` if at least one entry was removed, otherwise `false`.
-   */
+     * Asynchronously removes entries from a file based on search criteria.
+     * @param one If `true`, removes only the first matching entry.
+     * @returns A promise resolving to `true` if at least one entry was removed, otherwise `false`.
+     */
     remove(file: string, config: VQueryT.Remove, one: boolean, opts?: any): Promise<DataInternal[]>;
     /**
      * Asynchronously updates entries in a file based on search criteria and an updater function or object.

package/dist/types/options.d.ts

@@ -2,29 +2,30 @@ import { ActionsBase } from "../base/actions.js";
 import { Executor } from "../helpers/executor.js";
 import { KeysMatching } from "./utils.js";
 export type AdapterValue = ActionsBase | (() => Promise<ActionsBase>);
-type AdapterOption = {
+export interface DbOpts {
     adapter: AdapterValue;
-    /** @deprecated use `adapter` */
-    dbAction?: AdapterValue;
-} | {
-    adapter?: AdapterValue;
-    /** @deprecated use `adapter` */
-    dbAction: AdapterValue;
-};
-export type DbOpts = AdapterOption & {
     executor?: Executor;
+    adapterOpts?: AdapterOpts;
+}
+export interface AdapterOpts {
     numberId?: boolean;
-};
+    idKey?: string;
+}
 export type FieldPath<T = any> = KeysMatching<T, any> | (string & {}) | string[];
 export interface DbFindOpts<T = any> {
     reverse?: boolean;
     limit?: number;
     offset?: number;
-    sortBy?: KeysMatching<T, any>;
+    sortBy?: KeysMatching<T, any> | {
+        field: KeysMatching<T, any>;
+        asc?: boolean;
+    }[];
     sortAsc?: boolean;
     min?: Record<string, KeysMatching<T, number>>;
     max?: Record<string, KeysMatching<T, number>>;
     avg?: Record<string, KeysMatching<T, number>>;
+    sum?: Record<string, KeysMatching<T, number>>;
+    distinct?: KeysMatching<T, any>;
     groupBy?: KeysMatching<T, any> | KeysMatching<T, any>[];
     count?: Record<string, string>;
 }
@@ -33,4 +34,3 @@ export interface FindOpts<T = any> {
     exclude?: FieldPath<T>[];
     transform?: Function;
 }
-export {};

package/dist/types/query.js

@@ -1,5 +1 @@
-export var VQueryT;
-(function (VQueryT) {
-    ;
-    ;
-})(VQueryT || (VQueryT = {}));
+export {};

package/dist/types/relation.d.ts

@@ -1,7 +1,10 @@
 import { DbFindOpts } from "./options.js";
 import { ValtheraCompatible } from "./valthera.js";
 export declare namespace RelationTypes {
-    type Path = [string, string];
+    type Path = [
+        string,
+        string
+    ];
     type FieldPath = string[];
     interface DBS {
         [key: string]: ValtheraCompatible;

package/dist/types/searchOpts.d.ts

@@ -20,6 +20,8 @@ export type LogicalOperators<T = any> = {
 };
 /** Comparison Operators with nested support */
 export type ComparisonOperators<T = any> = {
+    /** 5 != 4 */
+    $ne?: NestedValue<T, any>;
     /** 5 > 4 */
     $gt?: NestedValue<T, number, number>;
     /** 5 < 4 */
@@ -29,7 +31,10 @@ export type ComparisonOperators<T = any> = {
     /** 5 <= 4 */
     $lte?: NestedValue<T, number, number>;
     /** 5 between [min, max] */
-    $between?: NestedValue<T, [number, number], number>;
+    $between?: NestedValue<T, [
+        number,
+        number
+    ], number>;
     /** 2 in [1, 2, 3] */
     $in?: {
         [K in keyof T]?: T[K] extends any[] ? T[K] : T[K][];
@@ -60,22 +65,10 @@ export type ArrayOperators<T = any> = {
     $arrInc?: {
         [K in keyof T]?: T[K] extends any[] ? T[K][number][] : T[K][];
     };
-    /**
-     * @deprecated Use $arrInc instead.
-     */
-    $arrinc?: {
-        [K in keyof T]?: T[K] extends any[] ? T[K][number][] : T[K][];
-    };
     /** [1, 2, 3] array includes all elements e.g. [1, 2] */
     $arrIncAll?: {
         [K in keyof T]?: T[K] extends any[] ? T[K][number][] : T[K][];
     };
-    /**
-     * @deprecated Use $arrIncAll instead.
-     */
-    $arrincall?: {
-        [K in keyof T]?: T[K] extends any[] ? T[K][number][] : T[K][];
-    };
     /** [1, 2, 3] has size 3 */
     $size?: NestedValue<T, number>;
 };
@@ -87,6 +80,10 @@ export type StringOperators<T = any> = {
     $startsWith?: NestedValue<T, string, string>;
     /** "John" ends with "hn" */
     $endsWith?: NestedValue<T, string, string>;
+    /** "John" starts with "jo" (case-insensitive) */
+    $iStartsWith?: NestedValue<T, string, string>;
+    /** "John" ends with "HN" (case-insensitive) */
+    $iEndsWith?: NestedValue<T, string, string>;
 };
 /** Other Operators with nested support */
 export type OtherOperators<T = any> = {

package/dist/types/updater.d.ts

@@ -5,24 +5,12 @@ export type ArrayUpdater<T = any> = {
     $push?: NestedValue<T, any>;
     /** [1,2] -> $pushSet 2,3 -> [1,2,3] */
     $pushSet?: NestedValue<T, any>;
-    /**
-     * @deprecated Use $pushSet instead.
-     */
-    $pushset?: NestedValue<T, any>;
     /** [1,2,3] -> $pushAll [2,3] -> [1,2,3] */
     $pushAll?: NestedValue<T, any>;
-    /**
-     * @deprecated Use $pushAll instead.
-     */
-    $pushall?: NestedValue<T, any>;
     /** [1,2,3] -> $pull 2 -> [1,3] */
     $pull?: NestedValue<T, any>;
     /** [1,2,2,3] -> $pullAll [2] -> [1,3] */
     $pullAll?: NestedValue<T, any>;
-    /**
-     * @deprecated Use $pullAll instead.
-     */
-    $pullall?: NestedValue<T, any>;
 };
 /** Objects */
 export type ObjectUpdater<T = any> = {

package/dist/utils/action.js

@@ -1,12 +1,17 @@
 import { compareSafe } from "./compare.js";
 export async function findUtil(query, fileCpuOrData, files, fileCpuOpts) {
     const { dbFindOpts = {} } = query;
-    const { reverse = false, offset = 0, limit = -1, sortBy, sortAsc = true, min, max, avg, groupBy, count, } = dbFindOpts;
-    const needsAllData = min || max || avg || groupBy || count || sortBy;
+    const { reverse = false, offset = 0, sortBy, sortAsc = true, min, max, avg, sum, distinct, groupBy, count, } = dbFindOpts;
+    let limit = dbFindOpts.limit ?? -1;
+    if (limit === Infinity)
+        limit = -1;
+    const needsAllData = min || max || avg || sum || distinct || groupBy || count || sortBy;
     let datas = [];
     let skippedEntries = 0;
     if (Array.isArray(fileCpuOrData)) {
-        datas = [...fileCpuOrData];
+        datas = [
+            ...fileCpuOrData,
+        ];
         if (reverse && !sortBy)
             datas.reverse();
         if (!needsAllData) {
@@ -18,9 +23,13 @@ export async function findUtil(query, fileCpuOrData, files, fileCpuOpts) {
         }
     }
     else {
-        const filesToProcess = reverse && !sortBy ? [...files].reverse() : files;
+        const filesToProcess = reverse && !sortBy
+            ? [
+                ...files,
+            ].reverse()
+            : files;
         for (const f of filesToProcess) {
-            let entries = await fileCpuOrData.find(f, query, fileCpuOpts);
+            let entries = (await fileCpuOrData.find(f, query, fileCpuOpts));
             if (reverse && !sortBy)
                 entries.reverse();
             if (needsAllData) {
@@ -48,19 +57,30 @@ export async function findUtil(query, fileCpuOrData, files, fileCpuOpts) {
     }
     if (!needsAllData)
         return datas;
-    if (min || max || avg || groupBy || count) {
+    const hasAggregations = min || max || avg || sum || groupBy || count;
+    if (hasAggregations) {
         const groups = new Map();
-        const groupKeys = Array.isArray(groupBy) ? groupBy : groupBy ? [groupBy] : [];
+        const groupKeys = Array.isArray(groupBy)
+            ? groupBy
+            : groupBy
+                ? [
+                    groupBy,
+                ]
+                : [];
         if (groupKeys.length) {
             for (const data of datas) {
-                const key = groupKeys.map(k => String(data[k] ?? "")).join("|");
+                const key = groupKeys
+                    .map(k => String(data[k] ?? ""))
+                    .join("|");
                 if (!groups.has(key))
                     groups.set(key, []);
                 groups.get(key).push(data);
             }
         }
         else {
-            groups.set("all", [...datas]);
+            groups.set("all", [
+                ...datas,
+            ]);
         }
         const aggregated = [];
         for (const [, groupItems] of groups) {
@@ -76,25 +96,61 @@ export async function findUtil(query, fileCpuOrData, files, fileCpuOpts) {
                 }
             }
             for (const [outKey, srcField] of Object.entries(min ?? {})) {
-                const nums = groupItems.map(d => Number(d[srcField])).filter(n => !isNaN(n));
+                const nums = groupItems
+                    .map(d => Number(d[srcField]))
+                    .filter(n => !Number.isNaN(n));
                 result[outKey] = nums.length ? Math.min(...nums) : null;
             }
             for (const [outKey, srcField] of Object.entries(max ?? {})) {
-                const nums = groupItems.map(d => Number(d[srcField])).filter(n => !isNaN(n));
+                const nums = groupItems
+                    .map(d => Number(d[srcField]))
+                    .filter(n => !Number.isNaN(n));
                 result[outKey] = nums.length ? Math.max(...nums) : null;
             }
             for (const [outKey, srcField] of Object.entries(avg ?? {})) {
-                const nums = groupItems.map(d => Number(d[srcField])).filter(n => !isNaN(n));
-                result[outKey] = nums.length ? nums.reduce((a, b) => a + b, 0) / nums.length : null;
+                const nums = groupItems
+                    .map(d => Number(d[srcField]))
+                    .filter(n => !Number.isNaN(n));
+                result[outKey] = nums.length
+                    ? nums.reduce((a, b) => a + b, 0) / nums.length
+                    : null;
+            }
+            for (const [outKey, srcField] of Object.entries(sum ?? {})) {
+                const nums = groupItems
+                    .map(d => Number(d[srcField]))
+                    .filter(n => !Number.isNaN(n));
+                result[outKey] = nums.length ? nums.reduce((a, b) => a + b, 0) : null;
             }
             aggregated.push(result);
         }
         datas = aggregated;
     }
+    if (distinct) {
+        const seen = new Set();
+        datas = datas.filter(item => {
+            const val = item[distinct];
+            const key = JSON.stringify(val);
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+    }
     if (sortBy) {
         if (sortBy === "random()") {
             datas.sort(() => Math.random() - 0.5);
         }
+        else if (Array.isArray(sortBy)) {
+            datas.sort((a, b) => {
+                for (const { field, asc = true } of sortBy) {
+                    const dir = asc ? 1 : -1;
+                    const cmp = compareSafe(a[field], b[field]) * dir;
+                    if (cmp !== 0)
+                        return cmp;
+                }
+                return 0;
+            });
+        }
         else {
             const dir = sortAsc ? 1 : -1;
             datas.sort((a, b) => compareSafe(a[sortBy], b[sortBy]) * dir);

package/dist/utils/compare.js

@@ -12,11 +12,12 @@ export function compareSafe(a, b) {
     if (typeA === "string" && typeB === "string") {
         return a.localeCompare(b);
     }
-    if ((typeA === "number" || a instanceof Date) && (typeB === "number" || b instanceof Date)) {
-        return (a < b) ? -1 : (a > b) ? 1 : 0;
+    if ((typeA === "number" || a instanceof Date) &&
+        (typeB === "number" || b instanceof Date)) {
+        return a < b ? -1 : a > b ? 1 : 0;
     }
     if (typeA === "boolean" && typeB === "boolean") {
-        return (a === b) ? 0 : a ? 1 : -1;
+        return a === b ? 0 : a ? 1 : -1;
     }
     // fallback: if both are objects/arrays or different types, consider equal
     return 0;