@uxf/core 11.87.0 → 11.88.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/package.json

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

package/types/index.d.ts

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

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

@@ -0,0 +1,3 @@
+export declare function filterNullishObjectValues(obj: Record<string, any>): {
+    [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-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-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);
+});