@uxf/core 11.87.0 → 11.89.0

package/README.md

@@ -285,6 +285,20 @@ import { filterNullish } from "@uxf/core/utils/filter-nullish";
 filterNullish([0, "text", null, undefined, [], {}]); /* returns [0, "text", [], {}]  */
 ```
 
+## filterNullishObjectValues
+
+Filters out all properties with `null` or `undefined` values from an object, returning a new object with only non-nullish values.
+
+```tsx
+import { filterNullishObjectValues } from "@uxf/core/utils/filter-nullish-object-values";
+
+filterNullishObjectValues({ a: 1, b: null, c: "test", d: undefined });
+/* returns { a: 1, c: "test" } */
+
+filterNullishObjectValues({ a: 0, b: "", c: false });
+/* returns { a: 0, b: "", c: false } - keeps falsy values that are not nullish */
+```
+
 ## filterAriaAndDataAttrs
 
 Filters an object to return only properties that start with `aria-` or `data-` prefixes. This utility is useful when you need to pass accessibility and data attributes to HTML elements while excluding other props like event handlers or component-specific props.
@@ -340,6 +354,36 @@ isEmpty(["1"]); /* returns false */
 isEmpty([]); /* returns true */
 ```
 
+## isEven
+
+Checks if a number is even.
+
+```tsx
+import { isEven } from "@uxf/core/utils/is-even";
+
+isEven(2);  /* returns true */
+isEven(4);  /* returns true */
+isEven(1);  /* returns false */
+isEven(3);  /* returns false */
+isEven(0);  /* returns true */
+isEven(-2); /* returns true */
+```
+
+## isOdd
+
+Checks if a number is odd.
+
+```tsx
+import { isOdd } from "@uxf/core/utils/is-odd";
+
+isOdd(1);  /* returns true */
+isOdd(3);  /* returns true */
+isOdd(2);  /* returns false */
+isOdd(4);  /* returns false */
+isOdd(0);  /* returns false */
+isOdd(-1); /* returns true */
+```
+
 ## isBrowser / isServer
 
 ```tsx
@@ -378,6 +422,8 @@ isNotNil([]);        /* returns true */
 isNotNil("string");  /* returns true */
 ```
 
+## last
+
 ```tsx
 import { last } from "@uxf/core/utils/last";
 
@@ -385,6 +431,63 @@ last([1, 2]); /* returns 2 */
 last([]);     /* returns undefined */
 ```
 
+## nonEmptyArrayOrNull
+
+Converts empty arrays, `null`, or `undefined` values to `null`, leaving all non-empty arrays unchanged. Useful for normalizing form inputs or API data where empty arrays should be treated as `null`.
+
+```tsx
+import { nonEmptyArrayOrNull } from "@uxf/core/utils/non-empty-array-or-null";
+
+nonEmptyArrayOrNull([]);          /* returns null */
+nonEmptyArrayOrNull(null);        /* returns null */
+nonEmptyArrayOrNull(undefined);   /* returns null */
+nonEmptyArrayOrNull([1, 2, 3]);   /* returns [1, 2, 3] */
+nonEmptyArrayOrNull(["a", "b"]);  /* returns ["a", "b"] */
+```
+
+## nonEmptyStringOrNull
+
+Converts empty strings and `undefined` values to `null`, leaving all other strings unchanged. Useful for normalizing form inputs or API data where empty strings should be treated as `null`.
+
+```tsx
+import { nonEmptyStringOrNull } from "@uxf/core/utils/non-empty-string-or-null";
+
+nonEmptyStringOrNull("");         /* returns null */
+nonEmptyStringOrNull(undefined);  /* returns null */
+nonEmptyStringOrNull(null);       /* returns null */
+nonEmptyStringOrNull("test");     /* returns "test" */
+nonEmptyStringOrNull(" ");        /* returns " " - non-empty string */
+```
+
+## nullishToEmptyString
+
+Converts `null` or `undefined` values to an empty string, leaving all other strings unchanged. Useful for safely displaying nullable string values in UI components.
+
+```tsx
+import { nullishToEmptyString } from "@uxf/core/utils/nullish-to-empty-string";
+
+nullishToEmptyString(null);            /* returns "" */
+nullishToEmptyString(undefined);       /* returns "" */
+nullishToEmptyString("");              /* returns "" */
+nullishToEmptyString("hello world");   /* returns "hello world" */
+```
+
+## numberOrNull
+
+Converts `NaN`, `null`, or `undefined` values to `null`, leaving all valid numbers unchanged. Useful for normalizing numeric inputs or API data where invalid numbers should be treated as `null`.
+
+```tsx
+import { numberOrNull } from "@uxf/core/utils/number-or-null";
+
+numberOrNull(0);          /* returns 0 */
+numberOrNull(42);         /* returns 42 */
+numberOrNull(-1);         /* returns -1 */
+numberOrNull(3.14);       /* returns 3.14 */
+numberOrNull(NaN);        /* returns null */
+numberOrNull(null);       /* returns null */
+numberOrNull(undefined);  /* returns null */
+```
+
 ## slugify
 
 ```tsx

package/constants/empty-object.d.ts

@@ -1 +1 @@
-export declare const EMPTY_OBJECT: Record<string, never>;
+export declare const EMPTY_OBJECT: Partial<Record<string, never>>;

package/cookie/index.d.ts

@@ -1,3 +1,4 @@
+import { AnyObject } from "../types";
 interface CookieOptions {
     domain?: string;
     httpOnly?: boolean;
@@ -8,8 +9,8 @@ interface CookieOptions {
 }
 export declare class Cookie {
     private ctx;
-    constructor(ctx?: any | null);
-    static create(ctx?: any): Cookie;
+    constructor(ctx?: AnyObject | null);
+    static create(ctx?: AnyObject | null): Cookie;
     has(name: string): boolean;
     set(name: string, value: string, ttl?: number, options?: CookieOptions): Cookie;
     get(cookieName: string): string;

package/cookie/index.js

@@ -14,6 +14,7 @@ class Cookie {
         return (0, is_not_empty_1.isNotEmpty)(this.get(name));
     }
     set(name, value, ttl = 3600, options = {}) {
+        var _a, _b;
         const date = new Date();
         date.setTime(date.getTime() + ttl * 1000);
         const cookieParts = [`${name}=${encodeURIComponent(value)}`, `expires=${date.toUTCString()}`];
@@ -38,9 +39,9 @@ class Cookie {
             document.cookie = cookie;
         }
         else {
-            const existsCookies = (this.ctx.res.getHeader("Set-Cookie") || []).slice(0);
+            const existsCookies = (((_a = this.ctx) === null || _a === void 0 ? void 0 : _a.res.getHeader("Set-Cookie")) || []).slice(0);
             existsCookies.push(cookie);
-            this.ctx.res.setHeader("Set-Cookie", existsCookies);
+            (_b = this.ctx) === null || _b === void 0 ? void 0 : _b.res.setHeader("Set-Cookie", existsCookies);
         }
         return this;
     }

package/date/to-date-string.d.ts

@@ -1,2 +1,5 @@
 import { DateString } from "./index";
-export declare function toDateString<T extends Date | null>(value: T): T extends null ? DateString | null : DateString;
+type InputType = Date | null;
+type ReturnType<T extends InputType> = T extends null ? DateString | null : DateString;
+export declare function toDateString<T extends InputType>(value: T): ReturnType<T>;
+export {};

package/date/to-datetime-string.d.ts

@@ -1,2 +1,5 @@
 import { DatetimeString } from "./index";
-export declare function toDatetimeString<T extends Date | null>(value: T): T extends null ? DatetimeString | null : DatetimeString;
+type InputType = Date | null;
+type ReturnType<T extends InputType> = T extends null ? DatetimeString | null : DatetimeString;
+export declare function toDatetimeString<T extends InputType>(value: T): ReturnType<T>;
+export {};

package/date/to-time-string.d.ts

@@ -1,2 +1,5 @@
 import { TimeString } from "./index";
-export declare function toTimeString<T extends Date | null>(value: T): T extends null ? TimeString | null : TimeString;
+type InputType = Date | null;
+type ReturnType<T extends InputType> = T extends null ? TimeString | null : TimeString;
+export declare function toTimeString<T extends InputType>(value: T): ReturnType<T>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uxf/core",
-    "version": "11.87.0",
+    "version": "11.89.0",
     "description": "UXF Core",
     "author": "Petr Vejvoda <vejvoda@uxf.cz>",
     "homepage": "https://gitlab.com/uxf-npm/core#readme",

package/qr/index.d.ts

@@ -1,7 +1,7 @@
 interface Config {
-    width?: number;
     errorCorrectionLevel?: "L" | "M" | "Q" | "H";
     margin?: number;
+    width?: number;
 }
 export declare function qrCodeUrl(url: string, config?: Config): string;
 export {};

package/types/index.d.ts

@@ -1,5 +1,7 @@
 export type Nullish = null | undefined;
 export type Noop = () => void;
+export type AnyObject = Partial<Record<string, any>>;
+export type AnyJSON = any;
 export interface FileResponse {
     id: number;
     name: string;

package/utils/body-scroll-lock.d.ts

@@ -1,7 +1,7 @@
-export interface BodyScrollOptions {
-    reserveScrollBarGap?: boolean;
-    allowTouchMove?: (el: any) => boolean;
+export interface BodyScrollOptions<E extends HTMLElement> {
+    allowTouchMove?: (el: E) => boolean;
+    willReserveScrollBarGap?: boolean;
 }
-export declare const disableBodyScroll: (targetElement: any, options?: BodyScrollOptions) => void;
+export declare const disableBodyScroll: <E extends HTMLElement = HTMLElement>(targetElement: E | null, options?: BodyScrollOptions<E>) => void;
 export declare const clearAllBodyScrollLocks: () => void;
-export declare const enableBodyScroll: (targetElement: any) => void;
+export declare const enableBodyScroll: <E extends HTMLElement = HTMLElement>(targetElement: E | null) => void;

package/utils/body-scroll-lock.js

@@ -2,6 +2,7 @@
 // Forked from "body-scroll-lock" https://github.com/willmcpo/body-scroll-lock
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.enableBodyScroll = exports.clearAllBodyScrollLocks = exports.disableBodyScroll = void 0;
+const is_nil_1 = require("./is-nil");
 const noop_1 = require("./noop");
 // Older browsers don't support event options, feature detect it.
 let hasPassiveEvents = false;
@@ -21,7 +22,7 @@ const isIosDevice = typeof window !== "undefined" &&
     (/iP(ad|hone|od)/.test(window.navigator.platform) ||
         (window.navigator.platform === "MacIntel" && window.navigator.maxTouchPoints > 1));
 let locks = [];
-let documentListenerAdded = false;
+let isDocumentListenerAdded = false;
 let initialClientY = -1;
 let previousBodyOverflowSetting;
 let previousBodyPosition;
@@ -34,11 +35,11 @@ const preventDefault = (rawEvent) => {
     // Recall that we do document.addEventListener('touchmove', preventDefault, { passive: false })
     // in disableBodyScroll - so if we provide this opportunity to allowTouchMove, then
     // the touchmove event on document will break.
-    if ((e === null || e === void 0 ? void 0 : e.target) && allowTouchMove(e.target)) {
+    if ((e === null || e === void 0 ? void 0 : e.target) && e.target instanceof HTMLElement && allowTouchMove(e.target)) {
         return true;
     }
     // Do not prevent if the event has more than one touch (usually meaning this is a multi touch gesture like pinch to zoom).
-    if ((e === null || e === void 0 ? void 0 : e.touches.length) > 1) {
+    if (e instanceof TouchEvent && e.touches.length > 1) {
         return true;
     }
     if (e === null || e === void 0 ? void 0 : e.preventDefault) {
@@ -49,9 +50,9 @@ const preventDefault = (rawEvent) => {
 const setOverflowHidden = (options) => {
     // If previousBodyPaddingRight is already set, don't set it again.
     if (previousBodyPaddingRight === undefined) {
-        const reserveScrollBarGap = (options === null || options === void 0 ? void 0 : options.reserveScrollBarGap) === true;
+        const willReserveScrollBarGap = (options === null || options === void 0 ? void 0 : options.willReserveScrollBarGap) === true;
         const scrollBarGap = window.innerWidth - document.documentElement.clientWidth;
-        if (reserveScrollBarGap && scrollBarGap > 0) {
+        if (willReserveScrollBarGap && scrollBarGap > 0) {
             const computedBodyPaddingRight = parseInt(window.getComputedStyle(document.body).getPropertyValue("padding-right"), 10);
             previousBodyPaddingRight = document.body.style.paddingRight;
             document.body.style.paddingRight = `${computedBodyPaddingRight + scrollBarGap}px`;
@@ -119,7 +120,7 @@ const isTargetElementTotallyScrolled = (targetElement) => targetElement ? target
 const handleScroll = (event, targetElement) => {
     var _a, _b;
     const clientY = (_b = (_a = event.targetTouches.item(0)) === null || _a === void 0 ? void 0 : _a.clientY) !== null && _b !== void 0 ? _b : 0 - initialClientY;
-    if (event.target && allowTouchMove(event.target)) {
+    if (event.target && event.target instanceof HTMLElement && allowTouchMove(event.target)) {
         return false;
     }
     if (targetElement && targetElement.scrollTop === 0 && clientY > 0) {
@@ -169,9 +170,9 @@ const disableBodyScroll = (targetElement, options) => {
                 handleScroll(event, targetElement);
             }
         };
-        if (!documentListenerAdded) {
+        if (!isDocumentListenerAdded) {
             document.addEventListener("touchmove", preventDefault, hasPassiveEvents ? { passive: false } : undefined);
-            documentListenerAdded = true;
+            isDocumentListenerAdded = true;
         }
     }
 };
@@ -180,12 +181,15 @@ const clearAllBodyScrollLocks = () => {
     if (isIosDevice) {
         // Clear all locks ontouchstart/ontouchmove handlers, and the references.
         locks.forEach((lock) => {
+            if ((0, is_nil_1.isNil)(lock.targetElement)) {
+                return;
+            }
             lock.targetElement.ontouchstart = null;
             lock.targetElement.ontouchmove = null;
         });
-        if (documentListenerAdded) {
+        if (isDocumentListenerAdded) {
             document.removeEventListener("touchmove", preventDefault);
-            documentListenerAdded = false;
+            isDocumentListenerAdded = false;
         }
         // Reset initial clientY.
         initialClientY = -1;
@@ -209,9 +213,9 @@ const enableBodyScroll = (targetElement) => {
     if (isIosDevice) {
         targetElement.ontouchstart = null;
         targetElement.ontouchmove = null;
-        if (documentListenerAdded && locks.length === 0) {
+        if (isDocumentListenerAdded && locks.length === 0) {
             document.removeEventListener("touchmove", preventDefault);
-            documentListenerAdded = false;
+            isDocumentListenerAdded = false;
         }
     }
     if (isIosDevice) {

package/utils/cxa.d.ts

@@ -1,3 +1,4 @@
-export type CxaClassValue = CxaClassArray | Record<string, any> | string | number | null | boolean | undefined;
+import { AnyObject } from "../types";
+export type CxaClassValue = CxaClassArray | AnyObject | string | number | null | boolean | undefined;
 export type CxaClassArray = CxaClassValue[];
 export declare function cxa(...classes: CxaClassValue[]): string;

package/utils/deep-equal-ingoring-key-order.test.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-// packages/core/utils/deep-equal-ingoring-key-order.test.ts
 const deep_equal_ingoring_key_order_1 = require("./deep-equal-ingoring-key-order");
 describe("deepEqualIgnoringKeyOrder", () => {
     it("returns true for objects with same keys in different orders", () => {

package/utils/filter-aria-and-data-attrs.d.ts

@@ -1,3 +1,4 @@
-export declare function filterAriaAndDataAttrs<P extends Record<string, any>>(props: P): {
+import { AnyObject } from "../types";
+export declare function filterAriaAndDataAttrs<P extends AnyObject>(props: P): {
     [k: string]: any;
 };

package/utils/filter-nullish-object-values.d.ts

@@ -0,0 +1,4 @@
+import { AnyObject } from "../types";
+export declare function filterNullishObjectValues(obj: AnyObject): {
+    [k: string]: any;
+};

package/utils/filter-nullish-object-values.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterNullishObjectValues = filterNullishObjectValues;
+const is_not_nil_1 = require("@uxf/core/utils/is-not-nil");
+function filterNullishObjectValues(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([, value]) => (0, is_not_nil_1.isNotNil)(value)));
+}

package/utils/filter-nullish-object-values.test.d.ts

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

package/utils/filter-nullish-object-values.test.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const filter_nullish_object_values_1 = require("./filter-nullish-object-values");
+test("filter-nullish-object-values", () => {
+    expect((0, filter_nullish_object_values_1.filterNullishObjectValues)({ a: 1, b: null, c: "test", d: undefined })).toStrictEqual({
+        a: 1,
+        c: "test",
+    });
+    expect((0, filter_nullish_object_values_1.filterNullishObjectValues)({ a: 0, b: "", c: false, d: NaN })).toStrictEqual({
+        a: 0,
+        b: "",
+        c: false,
+        d: NaN,
+    });
+    expect((0, filter_nullish_object_values_1.filterNullishObjectValues)({ a: [], b: {} })).toStrictEqual({ a: [], b: {} });
+    expect((0, filter_nullish_object_values_1.filterNullishObjectValues)({})).toStrictEqual({});
+    expect((0, filter_nullish_object_values_1.filterNullishObjectValues)({ a: null, b: undefined })).toStrictEqual({});
+});

package/utils/filter-nullish.d.ts

@@ -1 +1,2 @@
-export declare function filterNullish<T>(val: Array<T | null | undefined>): T[];
+import { Nullish } from "../types";
+export declare function filterNullish<T>(val: Array<T | Nullish>): T[];

package/utils/is-empty.d.ts

@@ -1,3 +1,2 @@
-export declare function isEmpty(value: any[] | {
-    [key: string]: any;
-} | string): boolean;
+import { AnyObject } from "../types";
+export declare function isEmpty(value: unknown[] | AnyObject | string): boolean;

package/utils/is-even.d.ts

@@ -0,0 +1 @@
+export declare function isEven(n: number): boolean;

package/utils/is-even.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEven = isEven;
+function isEven(n) {
+    return n % 2 === 0;
+}

package/utils/is-even.test.d.ts

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

package/utils/is-even.test.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_even_1 = require("./is-even");
+test("is-even", () => {
+    [0, 2, 4, 10, 100, -2, -4].map((value) => expect((0, is_even_1.isEven)(value)).toBeTruthy());
+    [1, 3, 5, 11, 101, -1, -3].map((value) => expect((0, is_even_1.isEven)(value)).toBeFalsy());
+});

package/utils/is-nil.d.ts

@@ -1 +1 @@
-export declare function isNil(value: any): value is null | undefined;
+export declare function isNil(value: unknown): value is null | undefined;

package/utils/is-not-empty.d.ts

@@ -1,3 +1,2 @@
-export declare function isNotEmpty(value: any[] | {
-    [key: string]: any;
-} | string): boolean;
+import { AnyObject } from "../types";
+export declare function isNotEmpty(value: unknown[] | AnyObject | string): boolean;

package/utils/is-odd.d.ts

@@ -0,0 +1 @@
+export declare function isOdd(n: number): boolean;

package/utils/is-odd.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isOdd = isOdd;
+const is_even_1 = require("./is-even");
+function isOdd(n) {
+    return !(0, is_even_1.isEven)(n);
+}

package/utils/is-odd.test.d.ts

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

package/utils/is-odd.test.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_odd_1 = require("./is-odd");
+test("is-odd", () => {
+    [1, 3, 5, 11, 101, -1, -3].map((value) => expect((0, is_odd_1.isOdd)(value)).toBeTruthy());
+    [0, 2, 4, 10, 100, -2, -4].map((value) => expect((0, is_odd_1.isOdd)(value)).toBeFalsy());
+});

package/utils/non-empty-array-or-null.d.ts

@@ -0,0 +1,2 @@
+import { Nullish } from "@uxf/core/types";
+export declare function nonEmptyArrayOrNull<T>(value: Nullish | T[]): T[] | null;

package/utils/non-empty-array-or-null.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nonEmptyArrayOrNull = nonEmptyArrayOrNull;
+const is_empty_1 = require("@uxf/core/utils/is-empty");
+const is_nil_1 = require("@uxf/core/utils/is-nil");
+function nonEmptyArrayOrNull(value) {
+    return (0, is_nil_1.isNil)(value) || (0, is_empty_1.isEmpty)(value) ? null : value;
+}

package/utils/non-empty-array-or-null.test.d.ts

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

package/utils/non-empty-array-or-null.test.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const non_empty_array_or_null_1 = require("./non-empty-array-or-null");
+test("non-empty-array-or-null", () => {
+    expect((0, non_empty_array_or_null_1.nonEmptyArrayOrNull)([])).toBe(null);
+    expect((0, non_empty_array_or_null_1.nonEmptyArrayOrNull)(undefined)).toBe(null);
+    expect((0, non_empty_array_or_null_1.nonEmptyArrayOrNull)(null)).toBe(null);
+    expect((0, non_empty_array_or_null_1.nonEmptyArrayOrNull)([1, 2, 3])).toStrictEqual([1, 2, 3]);
+    expect((0, non_empty_array_or_null_1.nonEmptyArrayOrNull)(["a", "b"])).toStrictEqual(["a", "b"]);
+    expect((0, non_empty_array_or_null_1.nonEmptyArrayOrNull)([0])).toStrictEqual([0]);
+    expect((0, non_empty_array_or_null_1.nonEmptyArrayOrNull)([false])).toStrictEqual([false]);
+    expect((0, non_empty_array_or_null_1.nonEmptyArrayOrNull)([null])).toStrictEqual([null]);
+    expect((0, non_empty_array_or_null_1.nonEmptyArrayOrNull)([{}])).toStrictEqual([{}]);
+});

package/utils/non-empty-string-or-null.d.ts

@@ -0,0 +1,2 @@
+import { Nullish } from "../types";
+export declare function nonEmptyStringOrNull(value: string | Nullish): string | null;

package/utils/non-empty-string-or-null.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nonEmptyStringOrNull = nonEmptyStringOrNull;
+function nonEmptyStringOrNull(value) {
+    return value === "" || value === undefined ? null : value;
+}

package/utils/non-empty-string-or-null.test.d.ts

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

package/utils/non-empty-string-or-null.test.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const non_empty_string_or_null_1 = require("./non-empty-string-or-null");
+test("nullish-empty-string-to-nullable", () => {
+    expect((0, non_empty_string_or_null_1.nonEmptyStringOrNull)("")).toBe(null);
+    expect((0, non_empty_string_or_null_1.nonEmptyStringOrNull)(undefined)).toBe(null);
+    expect((0, non_empty_string_or_null_1.nonEmptyStringOrNull)(null)).toBe(null);
+    expect((0, non_empty_string_or_null_1.nonEmptyStringOrNull)("test")).toBe("test");
+    expect((0, non_empty_string_or_null_1.nonEmptyStringOrNull)("hello world")).toBe("hello world");
+    expect((0, non_empty_string_or_null_1.nonEmptyStringOrNull)(" ")).toBe(" ");
+});

package/utils/nullish-to-empty-string.d.ts

@@ -0,0 +1,2 @@
+import { Nullish } from "../types";
+export declare function nullishToEmptyString(value: string | Nullish): string;

package/utils/nullish-to-empty-string.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nullishToEmptyString = nullishToEmptyString;
+function nullishToEmptyString(value) {
+    return value !== null && value !== void 0 ? value : "";
+}

package/utils/nullish-to-empty-string.test.d.ts

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

package/utils/nullish-to-empty-string.test.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const nullish_to_empty_string_1 = require("./nullish-to-empty-string");
+test("nullish-to-empty-string", () => {
+    expect((0, nullish_to_empty_string_1.nullishToEmptyString)(null)).toBe("");
+    expect((0, nullish_to_empty_string_1.nullishToEmptyString)(undefined)).toBe("");
+    expect((0, nullish_to_empty_string_1.nullishToEmptyString)("")).toBe("");
+    expect((0, nullish_to_empty_string_1.nullishToEmptyString)("test")).toBe("test");
+    expect((0, nullish_to_empty_string_1.nullishToEmptyString)("hello world")).toBe("hello world");
+});

package/utils/number-or-null.d.ts

@@ -0,0 +1,2 @@
+import { Nullish } from "../types";
+export declare function numberOrNull(value: number | Nullish): number | null;

package/utils/number-or-null.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberOrNull = numberOrNull;
+const is_not_nil_1 = require("./is-not-nil");
+function numberOrNull(value) {
+    return (0, is_not_nil_1.isNotNil)(value) && !isNaN(value) ? value : null;
+}

package/utils/number-or-null.test.d.ts

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

package/utils/number-or-null.test.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const number_or_null_1 = require("./number-or-null");
+test("number-or-null", () => {
+    // Valid numbers should return the number
+    expect((0, number_or_null_1.numberOrNull)(0)).toBe(0);
+    expect((0, number_or_null_1.numberOrNull)(1)).toBe(1);
+    expect((0, number_or_null_1.numberOrNull)(-1)).toBe(-1);
+    expect((0, number_or_null_1.numberOrNull)(42)).toBe(42);
+    expect((0, number_or_null_1.numberOrNull)(3.14)).toBe(3.14);
+    expect((0, number_or_null_1.numberOrNull)(-99.99)).toBe(-99.99);
+    // null should return null
+    expect((0, number_or_null_1.numberOrNull)(null)).toBe(null);
+    // undefined should return null
+    expect((0, number_or_null_1.numberOrNull)(undefined)).toBe(null);
+    // NaN should return null
+    expect((0, number_or_null_1.numberOrNull)(NaN)).toBe(null);
+});

package/utils/omit.d.ts

@@ -1 +1,2 @@
-export declare function omit<T extends Record<string, any>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+import { AnyObject } from "../types";
+export declare function omit<T extends AnyObject, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;

package/utils/sort-object-keys.d.ts

@@ -1 +1,2 @@
-export declare function sortObjectKeys<T extends Record<string, any>>(object: T): T;
+import { AnyObject } from "../types";
+export declare function sortObjectKeys<T extends AnyObject>(object: T): T;

package/validators/form-validator.d.ts

@@ -5,5 +5,5 @@ export declare const FormValidator: {
     isLessOrEqualThan: (maxValue: number, errorMessage?: string) => (value: string) => string | undefined;
     isLessThan: (maxValue: number, errorMessage?: string) => (value: string) => string | undefined;
     isPhone: (errorMessage?: string) => (value: string) => string | undefined;
-    required: (errorMessage?: string) => (value: any) => string | undefined;
+    required: (errorMessage?: string) => (value: unknown) => string | undefined;
 };