@uxf/core 11.85.0 → 11.88.0

package/README.md

@@ -285,6 +285,56 @@ 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.
+
+```tsx
+import { filterAriaAndDataAttrs } from "@uxf/core/utils/filter-aria-and-data-attrs";
+
+// Filter accessibility and data attributes from component props
+const props = {
+    "aria-label": "Close button",
+    "data-testid": "close-btn",
+    className: "button",
+    onClick: handleClick,
+};
+
+const htmlAttrs = filterAriaAndDataAttrs(props);
+// Result: { "aria-label": "Close button", "data-testid": "close-btn" }
+
+<button {...htmlAttrs}>Close</button>
+```
+
+```tsx
+// Use case: Passing only safe attributes to a native element
+function CustomInput({ label, onChange, ...restProps }) {
+    const accessibilityAttrs = filterAriaAndDataAttrs(restProps);
+
+    return <input {...accessibilityAttrs} onChange={onChange} />;
+}
+
+<CustomInput
+    aria-describedby="helper-text"
+    data-analytics="email-input"
+    customProp="ignored"
+/>
+```
+
 ### formatBytes
 
 Appends suitable unit to the byte value of data size.
@@ -304,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
@@ -342,6 +422,8 @@ isNotNil([]);        /* returns true */
 isNotNil("string");  /* returns true */
 ```
 
+## last
+
 ```tsx
 import { last } from "@uxf/core/utils/last";
 
@@ -349,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.85.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-aria-and-data-attrs.d.ts

@@ -0,0 +1,3 @@
+export declare function filterAriaAndDataAttrs<P extends Record<string, any>>(props: P): {
+    [k: string]: any;
+};

package/utils/filter-aria-and-data-attrs.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterAriaAndDataAttrs = filterAriaAndDataAttrs;
+function filterAriaAndDataAttrs(props) {
+    return Object.fromEntries(Object.entries(props).filter((p) => { var _a, _b; return Boolean(((_a = p.at(0)) === null || _a === void 0 ? void 0 : _a.startsWith("aria-")) || ((_b = p.at(0)) === null || _b === void 0 ? void 0 : _b.startsWith("data-"))); }));
+}

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

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

package/utils/filter-aria-and-data-attrs.test.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const filter_aria_and_data_attrs_1 = require("./filter-aria-and-data-attrs");
+describe("filterAriaAndDataAttrs", () => {
+    it("should filter only aria- attributes", () => {
+        const props = {
+            "aria-label": "test label",
+            "aria-hidden": true,
+            className: "test-class",
+            id: "test-id",
+        };
+        const result = (0, filter_aria_and_data_attrs_1.filterAriaAndDataAttrs)(props);
+        expect(result).toEqual({
+            "aria-label": "test label",
+            "aria-hidden": true,
+        });
+    });
+    it("should filter only data- attributes", () => {
+        const props = {
+            "data-testid": "test",
+            "data-value": 123,
+            className: "test-class",
+            onClick: jest.fn(),
+        };
+        const result = (0, filter_aria_and_data_attrs_1.filterAriaAndDataAttrs)(props);
+        expect(result).toEqual({
+            "data-testid": "test",
+            "data-value": 123,
+        });
+    });
+    it("should filter both aria- and data- attributes", () => {
+        const props = {
+            "aria-label": "label",
+            "data-testid": "test",
+            "aria-describedby": "desc",
+            "data-custom": "value",
+            className: "class",
+            style: { color: "red" },
+        };
+        const result = (0, filter_aria_and_data_attrs_1.filterAriaAndDataAttrs)(props);
+        expect(result).toEqual({
+            "aria-label": "label",
+            "data-testid": "test",
+            "aria-describedby": "desc",
+            "data-custom": "value",
+        });
+    });
+    it("should return empty object when no aria- or data- attributes present", () => {
+        const props = {
+            className: "test",
+            id: "id",
+            onClick: jest.fn(),
+        };
+        const result = (0, filter_aria_and_data_attrs_1.filterAriaAndDataAttrs)(props);
+        expect(result).toEqual({});
+    });
+    it("should return empty object for empty input", () => {
+        const props = {};
+        const result = (0, filter_aria_and_data_attrs_1.filterAriaAndDataAttrs)(props);
+        expect(result).toEqual({});
+    });
+    it("should handle attributes with various value types", () => {
+        const props = {
+            "aria-expanded": false,
+            "aria-level": 2,
+            "data-object": { nested: "value" },
+            "data-array": [1, 2, 3],
+            "data-null": null,
+            "data-undefined": undefined,
+            regularProp: "value",
+        };
+        const result = (0, filter_aria_and_data_attrs_1.filterAriaAndDataAttrs)(props);
+        expect(result).toEqual({
+            "aria-expanded": false,
+            "aria-level": 2,
+            "data-object": { nested: "value" },
+            "data-array": [1, 2, 3],
+            "data-null": null,
+            "data-undefined": undefined,
+        });
+    });
+    it("should not filter attributes that contain but don't start with aria- or data-", () => {
+        const props = {
+            "aria-label": "keep",
+            "data-id": "keep",
+            "my-aria-label": "remove",
+            "my-data-id": "remove",
+        };
+        const result = (0, filter_aria_and_data_attrs_1.filterAriaAndDataAttrs)(props);
+        expect(result).toEqual({
+            "aria-label": "keep",
+            "data-id": "keep",
+        });
+    });
+});

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);
+});

package/utils/resizer.js

@@ -35,7 +35,11 @@ const BASE_PATH = (_b = process.env.NEXT_PUBLIC_BASE_PATH) !== null && _b !== vo
 const resizerStaticImageUrl = (src, width = "auto", height = "auto", props = {}, version = 1) => {
     var _a;
     const { fit = "cover", position = "center", toFormat = undefined, trim = "not-trim", background = "FFF" } = props;
-    const filepath = typeof src === "string" ? src : src.src;
+    let filepath = typeof src === "string" ? src : src.src;
+    // fix absolute assetPrefix
+    if (!filepath.startsWith("/")) {
+        filepath = new URL(filepath).pathname;
+    }
     const dotIndex = filepath.lastIndexOf(".");
     const filename = filepath.slice(0, dotIndex);
     const extension = filepath.slice(dotIndex + 1);

package/utils/resizer.test.js

@@ -16,7 +16,7 @@ describe("resizerGetDefaultConfig", () => {
             toFormat: "avif",
             quality: 1,
         });
-        expect(url).toBe("/generated/static/x_x_cv_b_t_nt_1/1http://example.com/image.jpg.avif");
+        expect(url).toBe("/generated/static/x_x_cv_b_t_nt_1/1/image.jpg.avif");
     });
     it("should return a valid URL for an ImageResponse source", () => {
         const imageResponse = {
@@ -29,7 +29,7 @@ describe("resizerGetDefaultConfig", () => {
     });
     it("should return a valid URL for a string source", () => {
         const url = (0, resizer_1.resizerImageUrl)("http://example.com/image.png", 250, 250, { toFormat: "webp" });
-        expect(url).toBe("/generated/static/250_250_cv_c_FFF_nt_x/1http://example.com/image.png.webp");
+        expect(url).toBe("/generated/static/250_250_cv_c_FFF_nt_x/1/image.png.webp");
     });
     it("should return undefined for null or undefined source", () => {
         expect((0, resizer_1.resizerImageUrl)(null)).toBeUndefined();