loon-bulma-react 2026.0.39 → 2026.0.41

package/dist/lib/utils/JSDuration.class.d.ts

@@ -0,0 +1,184 @@
+import { JSDateTime } from './JSDateTime.class';
+export type DiffFnType = 'years' | 'months' | 'weeks' | 'days' | 'hours' | 'minutes' | 'seconds' | 'milliseconds';
+type DiffReturnType = {
+    /** Number of milliseconds in this difference */
+    milliseconds?: number;
+    /** Number of seconds in this difference */
+    seconds?: number;
+    /** Number of minutes in this difference */
+    minutes?: number;
+    /** Number of hours in this difference */
+    hours?: number;
+    /** Number of days in this difference */
+    days?: number;
+    /** Number of weeks in this difference */
+    weeks?: number;
+    /** Number of months in this difference */
+    months?: number;
+    /** Number of years in this difference */
+    years?: number;
+    /** Number of milliseconds left after subtracting all other wanted date-parts */
+    rest?: number;
+};
+export declare class JSDuration {
+    /** Een van de 2 JSDateTimes om te vergelijken */ private _jsd1;
+    /** Een van de 2 JSDateTimes om te vergelijken */ private _jsd2;
+    /**
+     * Constructor voor een JSDuration. Gebruik om het verschil in tijd tussen 2 JSDateTimes of Dates te berekenen.
+     *
+     * @param jsd1 de 1e JSDateTime/Date om het verschil mee uit te rekenen.
+     * @param jsd2 (optioneel) de andere JSDateTime/Date om het verschil mee te berekenen (default = Date.now())
+     *
+     * @example
+     * // verschil tussen 01-01-1970 & NU
+     * const dur = new JSDuration(JSDateTime.epoch());
+     * @example
+     * // verschil tussen nu en 1 dag, 30min later
+     * let dur = new JSDuration(JSDateTime.now(), JSDateTime.now().plus({ days: 1, minutes: 30 }));
+     * console.log(dur.inDays);                             // 1
+     * console.log(dur.differenceIn(['hours', 'minutes'])); // { hours: 24, minutes: 30 }
+     *
+     * let dur = new JSDuration(JSDateTime.now(), JSDateTime.now().plus({ days: 1, minutes: 30, seconds: 30 }));
+     * console.log(dur.differenceIn(['hours', 'minutes']))  // { hours: 24, minutes: 30, rest: 30_000 }
+     */
+    constructor(jsd1: Date | JSDateTime, jsd2?: Date | JSDateTime);
+    /**
+     * Factory method om een JSDuration te maken tussen twee datums. - zelfde als constructor.
+     * @param date1 de 1e JSDateTime/Date
+     * @param date2 de 2e JSDateTime/Date
+     * @returns een nieuwe JSDuration
+     * @example
+     * const dur = JSDuration.between(JSDateTime.epoch(), JSDateTime.now());
+     */
+    static between(date1: Date | JSDateTime, date2: Date | JSDateTime): JSDuration;
+    /**
+     * Statische methode om te controleren of twee JSDurations gelijk zijn (dezelfde magnitude hebben).
+     * @param dur1 de eerste JSDuration of number (milliseconds)
+     * @param dur2 de tweede JSDuration of number (milliseconds)
+     * @returns true als beide durations dezelfde magnitude hebben, anders false
+     * @example
+     * const dur1 = new JSDuration(now, now.plus({ hours: 1 }));
+     * const dur2 = new JSDuration(now, now.plus({ hours: 1 }));
+     * const dur3 = new JSDuration(now, now.plus({ hours: 2 }));
+     * console.log(JSDuration.isEqual(dur1, dur2)); // true
+     * console.log(JSDuration.isEqual(dur1, dur3)); // false
+     * console.log(JSDuration.isEqual(dur1, 3_600_000)); // true (1 hour in ms)
+     */
+    static isEqual(dur1: JSDuration | number, dur2: JSDuration | number): boolean;
+    /** @returns Aantal absolute milliseconden tussen de twee JSDateTimes van deze duration (altijd positief) */
+    private get ms();
+    /**
+     * Geeft de primitieve waarde van de duration terug (in milliseconden).
+     * Hierdoor kunnen durations vergeleken worden met < en > operators.
+     * @returns Aantal milliseconden tussen de twee datums
+     * @example
+     * const dur1 = new JSDuration(now, now.plus({ hours: 1 }));
+     * const dur2 = new JSDuration(now, now.plus({ hours: 2 }));
+     * console.log(dur1 < dur2); // true
+     * console.log(dur2 > dur1); // true
+     */
+    valueOf(): number;
+    /** @returns Aantal milliseconden tussen de twee datums. */
+    get inMillis(): number;
+    /** @returns Aantal HELE seconden tussen de twee datums. */
+    get inSeconds(): number;
+    /** @returns Aantal HELE minuten tussen de twee datums. */
+    get inMinutes(): number;
+    /** @returns Aantal HELE uren tussen de twee datums. */
+    get inHours(): number;
+    /** @returns Aantal HELE dagen tussen de twee datums. */
+    get inDays(): number;
+    /** @returns Aantal HELE weken tussen de twee datums. */
+    get inWeeks(): number;
+    /** @returns Aantal HELE maanden tussen de twee datums (calendar-based). */
+    get inMonths(): number;
+    /** @returns Aantal HELE jaren tussen de twee datums (calendar-based). */
+    get inYears(): number;
+    /** @returns Een overzicht van alle gehele waarden tussen de twee datums  @deprecated gebruik `breakdown` */
+    get inAllTypes(): {
+        milliseconds: number;
+        seconds: number;
+        minutes: number;
+        hours: number;
+        days: number;
+        weeks: number;
+        months: number;
+        years: number;
+    };
+    /** @returns Een overzicht van alle gehele waarden tussen de twee datums  */
+    get breakdown(): {
+        milliseconds: number;
+        seconds: number;
+        minutes: number;
+        hours: number;
+        days: number;
+        weeks: number;
+        months: number;
+        years: number;
+    };
+    /**
+     * Bereken het verschil tussen de twee datums in de gewenste types.
+     * Dat is het verschil tov de inXXX-get-functions, die geven alleen het verschil in gehele eenheden van dat type
+     * @param types een array van de gewenste types
+     * @returns {DiffReturnType}een object met daarin de waarden van de gewenste types
+     * @example
+     * const dur = new JSDuration(JSDateTime.now(), JSDateTime.now().plus({ days: 1, minutes: 30 }));
+     * dur.differenceIn(['hours', 'minutes']);  // { hours: 24, minutes: 30 }
+     * dur.differenceIn(['days', 'minutes']);   // { days: 1, minutes: 30 }
+     * dur.differenceIn(['hours']);             // { hours: 24, rest: 1_800_000 }
+     */
+    differenceIn(types: DiffFnType[]): DiffReturnType;
+    /**
+     * Geeft een menselijk leesbare string terug van de duration.
+     * @returns een string in het formaat "Xy Xmo Xd Xh Xm Xs"
+     * @example
+     * const dur = new JSDuration(JSDateTime.now(), JSDateTime.now().plus({ days: 2, hours: 3, minutes: 45, seconds: 30 }));
+     * console.log(dur.toString()); // "2d 3h 45m 30s"
+     * @example
+     * const dur2 = new JSDuration(JSDateTime.now(), JSDateTime.now().plus({ years: 1, months: 6, days: 15 }));
+     * console.log(dur2.toString()); // "1y 6mo 15d"
+     */
+    toString(): string;
+    /**
+     * Controleert of de duration gelijk is aan nul (beide datums zijn hetzelfde).
+     * @returns true als de duration 0 milliseconden is, anders false
+     * @example
+     * const dur1 = new JSDuration(JSDateTime.now(), JSDateTime.now());
+     * console.log(dur1.isZero()); // true
+     *
+     * const dur2 = new JSDuration(JSDateTime.now(), JSDateTime.now().plus({ seconds: 1 }));
+     * console.log(dur2.isZero()); // false
+     */
+    isZero(): boolean;
+    /**
+     * Controleert of de duration negatief is (tweede datum is eerder dan de eerste).
+     * Let op: intern gebruikt de class altijd absolute waarden, dus deze method kijkt naar de originele volgorde.
+     * @returns true als jsd2 < jsd1, anders false
+     * @example
+     * const dur = new JSDuration(JSDateTime.now(), JSDateTime.now().plus({ days: -1 }));
+     * console.log(dur.isNegative()); // true
+     */
+    isNegative(): boolean;
+    /**
+     * Geeft een nieuwe JSDuration terug waar de volgorde van de datums is omgedraaid.
+     * @returns een nieuwe JSDuration met omgedraaide datums
+     * @example
+     * const dur1 = new JSDuration(date1, date2);
+     * const dur2 = dur1.negate();
+     * console.log(dur1.isNegative() === !dur2.isNegative()); // true
+     */
+    negate(): JSDuration;
+    /**
+     * Controleert of deze duration gelijk is aan een andere duration of een numerieke waarde (in milliseconden).
+     * @param other de JSDuration of number (milliseconds) om mee te vergelijken
+     * @returns true als de durations dezelfde magnitude hebben, anders false
+     * @throws Error als het type ongeldig is
+     * @example
+     * const dur1 = new JSDuration(now, now.plus({ hours: 1 }));
+     * const dur2 = new JSDuration(now, now.plus({ hours: 1 }));
+     * console.log(dur1.equals(dur2)); // true
+     * console.log(dur1.equals(3_600_000)); // true (1 hour in milliseconds)
+     */
+    equals(other: JSDuration | number): boolean;
+}
+export {};

package/dist/lib/utils/colors.d.ts

@@ -0,0 +1,54 @@
+import type { HexColor, RGBColor, HSLColor, ColorProp, ColorSchemeType } from '..';
+/** Vaste (per jaar verschillende) kleuren die gebruikt worden binnen `loon-bulma-react` voor als we GEEN css kunnen gebruiken. */
+export declare const DefinedHexColors: Readonly<{
+    Primary: "#0089b6";
+    Info: "#3b59ec";
+    Link: "#2f47bc";
+    Success: "#519c43";
+    Danger: "#d91000";
+    Warning: "#eea720";
+    Light: "#f5f5f5";
+    Dark: "#363636";
+}>;
+export declare function setColorScheme(scheme?: ColorSchemeType): void;
+export declare function getCurrentColorScheme(): ColorSchemeType;
+/** bepaal het color scheme dat door het systeem wordt gebruikt */
+export declare function getSystemColorScheme(): ColorSchemeType;
+/**
+ * Bepaal op basis van de achtergrondkleur wat de kleur van de tekst moet zijn (zwart of wit).
+ * - alpha-channel wordt genegeerd.
+ * - gebaseerd op WCAG-guidelines
+ * @param bgColor de achtergrondkleur van de tekst. string? hex colors (#abc of #abcdef). tuple? [r, g, b] of [h, s, l]
+ * @returns zwart of wit (hex-color of rgb-tuple)
+ * @example
+ * calculateTxtColor('#ffffff');       // '#000000'
+ * calculateTxtColor('#000000');       // '#ffffff'
+ * calculateTxtColor([0, 0, 0]);       // [255, 255, 255]
+ * calculateTxtColor([255, 255, 255]); // [0, 0, 0]
+ */
+export declare function calculateTxtColor<T = HexColor | RGBColor | HSLColor>(bgColor: HexColor | RGBColor | HSLColor, type?: 'hex' | 'rgb' | 'hsl'): T;
+export declare function colorPropToHex(color: ColorProp | HexColor): HexColor;
+/** Converteer een r-g-b color naar een hex color */
+export declare function rgbToHex([r, g, b]: RGBColor | [r: number, g: number, b: number]): HexColor;
+/** Converteer een hex color naar een r-g-b color */
+export declare function hexToRGB(hex: HexColor | string): RGBColor;
+/** Converteer een h-s-l color naar een hex color */
+export declare function hslToHex([h, s, l]: HSLColor | [h: number, s: number, l: number]): HexColor;
+/** Converteer een hex color naar een h-s-l color */
+export declare function hexToHSL(hex: HexColor | string): HSLColor;
+/** Converteer een RGB-color naar een HSL-color
+ * @todo: HSL kleuren zijn experimenteel!
+ */
+export declare function rgbToHSL([r255, g255, b255]: RGBColor | [r: number, g: number, b: number]): HSLColor;
+/** converteer een hsl-color naar een rgb-color
+ * @todo: HSL kleuren zijn experimenteel!
+ */
+export declare function hslToRGB([h, s, l]: HSLColor | [h: number, s: number, l: number]): RGBColor;
+/** returns een random color van onze `ColorProp`s.  */
+export declare function randomColor(colors?: Array<HexColor> | undefined): HexColor;
+/** returns een random color van onze `ColorProp`s.  */
+export declare function randomColorProp(colors?: Array<ColorProp | HexColor>): ColorProp | HexColor;
+/** controleer of een object een hex color is */
+export declare function isHexColor(obj: any): obj is HexColor;
+export declare function isRGBColor(obj: any): obj is RGBColor;
+export declare function isHSLColor(obj: any): obj is HSLColor;

package/dist/lib/utils/compare.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Compares two objects recursively & deep.
+ * @param a
+ * @param b
+ * @returns
+ */
+export declare function areEqual(a: any, b: any): boolean;

package/dist/lib/utils/deserialize.function.d.ts

@@ -0,0 +1,2 @@
+/** Default deserializer met `JSON.parse` van een `string` naar de waarde `T` */
+export declare function deserializeJSON<T extends unknown = {}>(value: string): T;

package/dist/lib/utils/flattenChildren.function.d.ts

@@ -0,0 +1,49 @@
+import { ReactNode } from 'react';
+/**
+ * Zet React children om naar een array en verwijdert fragment-wrappers.
+ *
+ * @param children - De React children die geflattened moeten worden
+ * @param deep - Optioneel. Als `true`, worden geneste fragments recursief geflattened. Als `false` (default), wordt alleen het eerste niveau van fragments geflattened.
+ * @param keys - Optioneel. Interne parameter voor het bijhouden van keys (wordt automatisch gebruikt bij recursie)
+ * @returns Een array met de geflattende children
+ *
+ * @example
+ * // Shallow flattening (default) - alleen het eerste niveau van fragments wordt verwijderd
+ * const children = (
+ *   <>
+ *     <div>First</div>
+ *     <div>Second</div>
+ *   </>
+ * );
+ * const flattened = flattenChildren(children);
+ * // Result: [<div>First</div>, <div>Second</div>]
+ *
+ * @example
+ * // Shallow flattening met geneste fragments - binnenste fragment blijft intact
+ * const children = (
+ *   <>
+ *     <div>First</div>
+ *     <>
+ *       <div>Nested</div>
+ *     </>
+ *   </>
+ * );
+ * const flattened = flattenChildren(children);
+ * // Result: [<div>First</div>, <Fragment><div>Nested</div></Fragment>]
+ *
+ * @example
+ * // Deep flattening - alle niveaus van fragments worden recursief verwijderd
+ * const children = (
+ *   <>
+ *     <div>First</div>
+ *     <>
+ *       <>
+ *         <div>Deeply nested</div>
+ *       </>
+ *     </>
+ *   </>
+ * );
+ * const flattened = flattenChildren(children, true);
+ * // Result: [<div>First</div>, <div>Deeply nested</div>]
+ */
+export declare function flattenChildren(children: ReactNode, deep?: boolean, keys?: (string | number)[]): ReactNode[];

package/dist/lib/utils/math.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Genereer ene random integer tussen 2 waarden
+ * @param min Minimum waarde (exclusief)
+ * @param max Maximum waarde (exclusief)
+ * @param inclusive Inclusief de `min` en `max` waarde (default `true`)
+ * @returns random geheel getal tussen de `min` en de `max` waarde
+ */
+export declare function randomInt(min: number, max: number, inclusive?: boolean): number;
+/**
+ * Genereer een random double / float tussen 2 waarden
+ * @param min Minimum waarde
+ * @param max Maximum waarde
+ * @returns random getal tussen de `min` en de `max` waarde
+ */
+export declare function randomDbl(min: number, max: number): number;
+/**
+ * Rond een getal af op het `digits` aantal decimalen (default 2)
+ * @param value de af te ronden waarde
+ * @param digits de gewenste precisie (default 2)
+ * @returns
+ */
+export declare function roundTo(value: number, digits?: number): number;

package/dist/lib/utils/object.functions.d.ts

@@ -0,0 +1,37 @@
+import { DeepPartial } from 'lib/types';
+/**
+ * Test if an object is empty (has no own properties) or is null/undefined.
+ * - For arrays, it checks if the length is 0.
+ * - For objects, it checks if there are no own properties.
+ * - For null or undefined, it returns the value of `undefinedOrNullIsEmpty`.
+ * - For other types (like strings, numbers), it returns false.
+ * @param obj - The object to test.
+ * @param undefinedOrNullIsEmpty - If true, null and undefined are considered empty. Default is true.
+ * @returns True if the object is empty, false otherwise.
+ */
+export declare function isEmptyObject(obj: any, undefinedOrNullIsEmpty?: boolean): boolean;
+/**
+ * Merges two objects recursively, with support for arrays and nested objects.
+ * - If a new value is null or undefined, it will overwrite the existing value.
+ * - If both values are arrays, they can be merged based on the specified strategy (replace, concat, unique).
+ * - If both values are objects, they will be merged recursively.
+ * - For other types, the new value will overwrite the existing value.
+ * @param existing - The existing object.
+ * @param nieuw - The new object to merge.
+ * @param reuse - If true, the existing object will be modified. Default is false.
+ * @param arrayMergeStrategy - The strategy for merging arrays. Default is 'replace'.
+ * @returns The merged object, which is a combination of the existing and new objects.
+ */
+declare function mergeObjects<T extends Record<string, any>>(existing: T, nieuw: Partial<T>, reuse?: boolean, arrayMergeStrategy?: 'replace' | 'concat' | 'unique'): T;
+declare function mergeObjects<T extends Record<string, any>>(existing: T, nieuw: DeepPartial<T>, reuse?: boolean, arrayMergeStrategy?: 'replace' | 'concat' | 'unique'): T;
+declare function mergeObjects<T extends Record<string, any>, U extends Record<string, any>>(existing: T, nieuw: U, reuse?: boolean, arrayMergeStrategy?: 'replace' | 'concat' | 'unique'): T & U;
+export { mergeObjects };
+/**
+ * Maak een kopie van een object (deep clone, dus ook object-properties worden gekloond)
+ * Ondersteunt ook circulaire referenties.
+ * @param obj het originele object
+ * @returns een kopie van het originele object
+ * @alias copyObject: `cloneObject` is ook beschikbaar onder de naam `copyObject`.
+ */
+declare function cloneObject<T>(obj: T): T;
+export { cloneObject, cloneObject as copyObject };

package/dist/lib/utils/operators.d.ts

@@ -0,0 +1,195 @@
+/** recursieve AND-vergelijking met truthy and falsy waarden
+ * @param x Eerste waarde
+ * @param y Tweede waarde
+ * @param rest Nog meer waarden, die ook allemaal truthy/falsy kunnen zijn
+ * @returns true als alle waarden truthy zijn, anders false
+ * @example
+ * AND(true, false)         // false
+ * AND(1, 1)                // true
+ * AND(1, '1', null, NaN)   // false
+ *
+ * @description Truth table:
+ * |  x  |  y  | result |
+ * |-----|-----|--------|
+ * | `1` | `1` |  `1`   |
+ * | `1` | `0` |  `0`   |
+ * | `0` | `1` |  `0`   |
+ * | `0` | `0` |  `0`   |
+ */
+export declare function AND(x: unknown, y: unknown, ...rest: unknown[]): boolean;
+/**
+ * recursieve NAND vergelijking met truthy and falsy waarden
+ * @param x Eerste waarde
+ * @param y Tweede waarde
+ * @param rest Nog meer waarden, die ook allemaal truthy/falsy kunnen zijn
+ * @returns true zolang niet ALLE waarden truthy zijn, anders false
+ * @example
+ * NAND(true, false)         // true
+ * NAND(1, 1)                // false
+ * NAND(1, '1', null, NaN)   // true
+ * NAND(1,2,3,4,'str', true) // false
+ * @description Truth table:
+ * |  x  |  y  | result |
+ * |-----|-----|--------|
+ * | `1` | `1` |  `0`   |
+ * | `1` | `0` |  `1`   |
+ * | `0` | `1` |  `1`   |
+ * | `0` | `0` |  `1`   |
+ */
+export declare function NAND(x: unknown, y: unknown, ...rest: unknown[]): boolean;
+/**
+ * recursieve OR-vergelijking met truthy and falsy waarden
+ * @param x Eerste waarde
+ * @param y Tweede waarde
+ * @param rest Nog meer waarden, die ook allemaal truthy/falsy kunnen zijn
+ * @returns true als een van beide waarden truey is, of allebei, anders false
+ * @example
+ * OR(true, false)         // true
+ * OR(1, 1)                // true
+ * OR(1, '1', null, NaN)   // true
+ * OR(false,false,null,0)  // false
+ * @description Truth table:
+ * |  x  |  y  | result |
+ * |-----|-----|--------|
+ * | `1` | `1` |  `1`   |
+ * | `1` | `0` |  `1`   |
+ * | `0` | `1` |  `1`   |
+ * | `0` | `0` |  `0`   |
+ */
+export declare function OR(x: unknown, y: unknown, ...rest: unknown[]): boolean;
+/**
+ * Recursieve NOR-vergelijking, met truthy and falsy waarden
+ * @param x Eerste waarde
+ * @param y Tweede waarde
+ * @param rest Nog meer waarden, die ook allemaal truthy/falsy kunnen zijn
+ * @returns true als beide waarden falsey zijn, anders false
+ * @example
+ * NOR(true, false)         // false
+ * NOR(1, 1)                // false
+ * NOR(1, '1', null, NaN)   // false
+ * NOR(false,false,null,0)  // true
+ * @description Truth table:
+ * |  x  |  y  | result |
+ * |-----|-----|--------|
+ * | `1` | `1` |  `0`   |
+ * | `1` | `0` |  `0`   |
+ * | `0` | `1` |  `0`   |
+ * | `0` | `0` |  `1`   |
+ */
+export declare function NOR(x: unknown, y: unknown, ...rest: unknown[]): boolean;
+/**
+ * XOR-vergelijking met truthy and falsy waarden (odd parity)
+ * @param x Eerste waarde
+ * @param y Tweede waarde
+ * @param rest Nog meer waarden, die ook allemaal truthy/falsy kunnen zijn
+ * @returns true als een oneven aantal waarden truthy zijn (1, 3, 5, ...)
+ * @example
+ * XOR(true, false)                       // true
+ * XOR(1, 1)                              // false
+ * XOR(1, '1', null, true)                // false (2 truthy)
+ * XOR(1,2,3,4,'str', true)               // false (6 truthy)
+ * XOR(false, false, false, true, false)  // true (1 truthy)
+ * XOR(false, false, false, false)        // false (0 truthy)
+ * XOR(false, true, false, false, true)   // false (2 truthy)
+ * XOR(true, true, true)                  // true (3 truthy)
+ * @description Truth table (2 inputs, odd parity):
+ * |  x  |  y  | result |
+ * |-----|-----|--------|
+ * | `1` | `1` |  `0`   |
+ * | `1` | `0` |  `1`   |
+ * | `0` | `1` |  `1`   |
+ * | `0` | `0` |  `0`   |
+ *
+ * Truth table (3 inputs, odd parity):
+ * |  x  |  y  |  z  | result |
+ * |-----|-----|-----|--------|
+ * | `1` | `1` | `1` |  `1`   |
+ * | `1` | `1` | `0` |  `0`   |
+ * | `1` | `0` | `1` |  `0`   |
+ * | `1` | `0` | `0` |  `1`   |
+ * | `0` | `1` | `1` |  `0`   |
+ * | `0` | `1` | `0` |  `1`   |
+ * | `0` | `0` | `1` |  `1`   |
+ * | `0` | `0` | `0` |  `0`   |
+ */
+export declare function XOR(x: unknown, y: unknown, ...rest: unknown[]): boolean;
+/**
+ * XNOR-vergelijking met truthy and falsy waarden (even parity)
+ * @param x    Eerste waarde
+ * @param y    Tweede waarde
+ * @param rest Nog meer waarden, die ook allemaal truthy/falsy kunnen zijn
+ * @returns true als een even aantal waarden truthy zijn (0, 2, 4, ...)
+ * @description Truth table (2 inputs, even parity):
+ * |  x  |  y  | result |
+ * |-----|-----|--------|
+ * | `1` | `1` |  `1`   |
+ * | `1` | `0` |  `0`   |
+ * | `0` | `1` |  `0`   |
+ * | `0` | `0` |  `1`   |
+ *
+ * Truth table (3 inputs, even parity):
+ * |  x  |  y  |  z  | result |
+ * |-----|-----|-----|--------|
+ * | `1` | `1` | `1` |  `0`   |
+ * | `1` | `1` | `0` |  `1`   |
+ * | `1` | `0` | `1` |  `1`   |
+ * | `1` | `0` | `0` |  `0`   |
+ * | `0` | `1` | `1` |  `1`   |
+ * | `0` | `1` | `0` |  `0`   |
+ * | `0` | `0` | `1` |  `0`   |
+ * | `0` | `0` | `0` |  `1`   |
+ */
+export declare function XNOR(x: unknown, y: unknown, ...rest: unknown[]): boolean;
+/**
+ * NOT-vergelijking
+ * @param val Waarde
+ * @returns true als de waarde falsey is, anders false
+ * @description Truth table:
+ * | val | result |
+ * |-----|--------|
+ * | `1` |  `0`   |
+ * | `0` |  `1`   |
+ */
+export declare function NOT(val: unknown): boolean;
+/**
+ * IF-vergelijkking. Met 2 of 3 parameters
+ * - 2 parameters: als val truthy is, return val, anders then
+ * - 3 parameters: als val truthy is, return then, anders otherwise
+ * @param val een truthy of falsy waarde
+ * @param then een returnbare waarde
+ * @param otherwise nog een returnbare waarde in geval van 3 parameters
+ * @returns Een van de opgegeven waarden.
+ * @example
+ * // IF-vergelijking met 2 parameters. Als val truey is, return val, anders then
+ * IF(0, 'a') => 'a'
+ * IF(2, 'a') =>  2
+ * @example
+ * // IF-vergelijking met 3 parameters. Als val truey is, return then, anders otherwise
+ * IF(1, 'a', 'b') => 'a'
+ * IF(0, 'a', 'b') => 'b'
+ */
+export declare function IF<T, A>(val: T, then: A): T | A;
+export declare function IF<T, A, B>(val: T, then: A, otherwise: B): T | A | B;
+type SwitchFnType<T, RT> = {
+    /** de (optionele) waarde in de switch statement */
+    value: T | null;
+    /** een array van tuples alle mogelijke waardes van de statement, bestaand uit een value [0] en returnValue [1] */
+    cases: Array<[value: T | null, returnVal: RT | null]>;
+    /** de default waarde, als er geen match is (case default), als niet opgegeven, maken we een defaultCase van `null` */
+    defaultCase?: RT | undefined;
+    /** een functie om de geselecteerde value uit de switch te bepalen als we met objecten werken. */
+    compare?: (switchVal: T | null, caseVal: T | null) => boolean | undefined;
+};
+/**
+ * Switch statement om een waarde uit een lijst van waarden te selecteren en te returnen.
+ * een value met waarde `null` wordt gezien als defaultCase, deze kan je in de cases array zetten, of alleen de defaultCase als param opgeven
+ * @returns een van de waarden uit de cases, of de defaultCase
+ * @example
+ * SWITCH({
+ *   value: 1,
+ *   cases: [ [1, 'a'], [2, 'b'], [3, 'c'] ],
+ *   defaultCase: 'd'
+ * }); // 'a'
+ */
+export declare function SWITCH<T, RT>({ value: switchVal, cases, defaultCase, compare }: SwitchFnType<T, RT>): RT | null;
+export {};

package/dist/lib/utils/serialize.function.d.ts

@@ -0,0 +1,2 @@
+/** Default serializer met `JSON.stringify` van de waar `T` naar een `string` */
+export declare function serializeJSON<T extends unknown = {}>(value: T): string;

package/dist/lib/utils/sorting.d.ts

@@ -0,0 +1,34 @@
+import { JSDateTime } from "./JSDateTime.class";
+/**
+ * Sort boolean values
+ * @param a
+ * @param b
+ @example [true, false, false, true, true, false].sort((a,b) => boolSort(a,b))
+ @example [true, false, false, true, true, false].sort(boolSort);
+ */
+export declare const boolSort: (a?: boolean | undefined, b?: boolean | undefined) => -1 | 0 | 1 | number;
+/**
+ * sort Date / JSDateTime values
+ * @param a
+ * @param b
+ * @example [new Date(), new Date(), new Date(), new Date(), new Date(), new Date()].sort((a,b) => dateSort(a,b))
+ * @example [new Date(), new Date(), new Date(), new Date(), new Date(), new Date()].sort(dateSort);
+ * @example [new Date(), new Date(), JSDateTime.now(), JSDateTime.now(), new Date()].sort(dateSort);
+ */
+export declare const dateSort: (a?: Date | JSDateTime | undefined, b?: Date | JSDateTime | undefined) => -1 | 0 | 1 | number;
+/**
+ * Sort string values
+ * @param a
+ * @param b
+ * @example ["a", "b", "c", "d", "e", "f"].sort((a,b) => stringSort(a,b))
+ * @example ["a", "b", "c", "d", "e", "f"].sort(stringSort);
+ */
+export declare const stringSort: (a?: string | undefined, b?: string | undefined) => -1 | 0 | 1 | number;
+/**
+ * Sort number values
+ * @param a
+ * @param b
+ * @example [1, 2, 3, 4, 5, 6].sort((a,b) => numSort(a,b))
+ * @example [1, 2, 3, 4, 5, 6].sort(numSort);
+ */
+export declare const numSort: (a?: number | undefined, b?: number | undefined) => -1 | 0 | 1 | number;