@uxf/core 10.0.0-beta.9 → 10.0.0

package/README.md

@@ -378,6 +378,36 @@ import { trimTrailingZeros } from "@uxf/core/utils/trimTrailingZeros";
 const example = trimTrailingZeros("120,450") /* returns "120,45" */
 ```
 
+```tsx
+import { filterNullish } from "@uxf/core/utils/filter-nullish";
+
+filterNullish([0, "text", null, undefined, [], {}]) /* returns [0, "text", [], {}]  */
+```
+
+```tsx
+import { isNil } from "@uxf/core/utils/is-nil";
+
+isNil(null)      /* returns true */
+isNil(undefined) /* returns true */
+isNil(true)      /* returns false */
+isNil(1)         /* returns false */
+isNil(0)         /* returns false */
+isNil([])        /* returns false */
+isNil("string")  /* returns false */
+```
+
+```tsx
+import { isNotNil } from "@uxf/core/utils/is-not-nil";
+
+isNotNil(null)      /* returns false */
+isNotNil(undefined) /* returns false */
+isNotNil(true)      /* returns true */
+isNotNil(1)         /* returns true */
+isNotNil(0)         /* returns true */
+isNotNil([])        /* returns true */
+isNotNil("string")  /* returns true */
+```
+
 ## Validators
 ```tsx
 import { Validator } from "@uxf/core";

package/components/hide.d.ts

@@ -0,0 +1,7 @@
+import React, { ReactNode } from "react";
+interface HideProps {
+    when: boolean;
+    children?: ReactNode;
+}
+export declare function Hide(props: HideProps): React.JSX.Element | null;
+export {};

package/components/hide.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hide = void 0;
+const react_1 = __importDefault(require("react"));
+function Hide(props) {
+    if (props.when) {
+        return null;
+    }
+    return react_1.default.createElement(react_1.default.Fragment, null, props.children);
+}
+exports.Hide = Hide;

package/components/show.d.ts

@@ -0,0 +1,7 @@
+import React, { ReactNode } from "react";
+interface ShowProps {
+    when: boolean;
+    children?: ReactNode;
+}
+export declare function Show(props: ShowProps): React.JSX.Element | null;
+export {};

package/components/show.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Show = void 0;
+const react_1 = __importDefault(require("react"));
+function Show(props) {
+    if (!props.when) {
+        return null;
+    }
+    return react_1.default.createElement(react_1.default.Fragment, null, props.children);
+}
+exports.Show = Show;

package/hooks/useBodyScrollLock.d.ts

@@ -1,5 +1,5 @@
-import { BodyScrollOptions } from "body-scroll-lock";
 import { RefObject } from "react";
+import { BodyScrollOptions } from "../utils/bodyScrollLock";
 export interface UseBodyScrollLockOptions extends BodyScrollOptions {
     clearAllOnClose?: boolean;
 }

package/hooks/useBodyScrollLock.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useBodyScrollLock = void 0;
-const body_scroll_lock_1 = require("body-scroll-lock");
 const react_1 = require("react");
+const bodyScrollLock_1 = require("../utils/bodyScrollLock");
 function useBodyScrollLock(containerRef, isOpen, { allowTouchMove, clearAllOnClose, reserveScrollBarGap } = {}) {
     (0, react_1.useEffect)(() => {
         const node = containerRef.current;
         if (isOpen && node) {
-            (0, body_scroll_lock_1.disableBodyScroll)(node, {
+            (0, bodyScrollLock_1.disableBodyScroll)(node, {
                 allowTouchMove: allowTouchMove ||
                     ((element) => {
                         var _a;
@@ -24,10 +24,10 @@ function useBodyScrollLock(containerRef, isOpen, { allowTouchMove, clearAllOnClo
         }
         return () => {
             if (node) {
-                (0, body_scroll_lock_1.enableBodyScroll)(node);
+                (0, bodyScrollLock_1.enableBodyScroll)(node);
             }
             if (clearAllOnClose) {
-                (0, body_scroll_lock_1.clearAllBodyScrollLocks)();
+                (0, bodyScrollLock_1.clearAllBodyScrollLocks)();
             }
         };
     }, [allowTouchMove, clearAllOnClose, containerRef, isOpen, reserveScrollBarGap]);

package/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./Validators/Validator";
 export * from "./Validators/FormValidator";
+export * from "./Validators/Validator";

package/index.js

@@ -15,5 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 // TODO @vejvis - remove me
-__exportStar(require("./Validators/Validator"), exports);
 __exportStar(require("./Validators/FormValidator"), exports);
+__exportStar(require("./Validators/Validator"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uxf/core",
-  "version": "10.0.0-beta.9",
+  "version": "10.0.0",
   "description": "UXF Core",
   "author": "Petr Vejvoda <vejvoda@uxf.cz>",
   "homepage": "https://gitlab.com/uxf-npm/core#readme",
@@ -17,25 +17,17 @@
   },
   "scripts": {
     "build": "tsc -P tsconfig.json",
-    "jest": "jest",
-    "test": "npm run jest",
     "typecheck": "tsc --noEmit --skipLibCheck"
   },
   "bugs": {
     "url": "https://gitlab.com/uxf-npm/core/issues"
   },
-  "devDependencies": {
-    "@types/body-scroll-lock": "^3.1.0",
-    "@types/jest": "^27.4.0",
-    "@types/react": "^18.2.6",
-    "body-scroll-lock": "^4.0.0-beta.0",
-    "jest": "^27.4.5",
-    "react": "^18.2.0",
-    "ts-jest": "^27.1.2"
-  },
   "peerDependencies": {
-    "body-scroll-lock": "^4.0.0-beta.0",
-    "react": "^17.0.0 || ^18.0.0"
+    "react": ">=18.2.0"
+  },
+  "devDependencies": {
+    "@types/react": "18.2.27",
+    "react": "18.2.0"
   },
   "gitHead": "a2dee6aa67621f6eda17e63e88d0edf14f88455a"
 }

package/types/index.d.ts

@@ -0,0 +1 @@
+export type Nullish = null | undefined;

package/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/utils/bodyScrollLock.d.ts

@@ -0,0 +1,7 @@
+export interface BodyScrollOptions {
+    reserveScrollBarGap?: boolean;
+    allowTouchMove?: (el: any) => boolean;
+}
+export declare const disableBodyScroll: (targetElement: any, options?: BodyScrollOptions) => void;
+export declare const clearAllBodyScrollLocks: () => void;
+export declare const enableBodyScroll: (targetElement: any) => void;

package/utils/bodyScrollLock.js

@@ -0,0 +1,224 @@
+"use strict";
+// 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;
+function noop() {
+    return void null;
+}
+// Older browsers don't support event options, feature detect it.
+let hasPassiveEvents = false;
+if (typeof window !== "undefined") {
+    const passiveTestOptions = {
+        get passive() {
+            hasPassiveEvents = true;
+            return undefined;
+        },
+    };
+    window.addEventListener("testPassive", noop, passiveTestOptions);
+    window.removeEventListener("testPassive", noop);
+}
+const isIosDevice = typeof window !== "undefined" &&
+    typeof window.navigator !== "undefined" &&
+    typeof window.navigator.platform !== "undefined" &&
+    (/iP(ad|hone|od)/.test(window.navigator.platform) ||
+        (window.navigator.platform === "MacIntel" && window.navigator.maxTouchPoints > 1));
+let locks = [];
+let documentListenerAdded = false;
+let initialClientY = -1;
+let previousBodyOverflowSetting;
+let previousBodyPosition;
+let previousBodyPaddingRight;
+// returns true if `el` should be allowed to receive touchmove events.
+const allowTouchMove = (el) => locks.some((lock) => !!(lock.options.allowTouchMove && lock.options.allowTouchMove(el)));
+const preventDefault = (rawEvent) => {
+    const e = typeof rawEvent !== "undefined" ? rawEvent : window.event;
+    // For the case whereby consumers adds a touchmove event listener to document.
+    // 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)) {
+        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) {
+        return true;
+    }
+    if (e === null || e === void 0 ? void 0 : e.preventDefault) {
+        e.preventDefault();
+    }
+    return false;
+};
+const setOverflowHidden = (options) => {
+    // If previousBodyPaddingRight is already set, don't set it again.
+    if (previousBodyPaddingRight === undefined) {
+        const reserveScrollBarGap = !!options && options.reserveScrollBarGap === true;
+        const scrollBarGap = window.innerWidth - document.documentElement.clientWidth;
+        if (reserveScrollBarGap && 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`;
+        }
+    }
+    // If previousBodyOverflowSetting is already set, don't set it again.
+    if (previousBodyOverflowSetting === undefined) {
+        previousBodyOverflowSetting = document.body.style.overflow;
+        document.body.style.overflow = "hidden";
+    }
+};
+const restoreOverflowSetting = () => {
+    if (previousBodyPaddingRight !== undefined) {
+        document.body.style.paddingRight = previousBodyPaddingRight;
+        // Restore previousBodyPaddingRight to undefined so setOverflowHidden knows it
+        // can be set again.
+        previousBodyPaddingRight = undefined;
+    }
+    if (previousBodyOverflowSetting !== undefined) {
+        document.body.style.overflow = previousBodyOverflowSetting;
+        // Restore previousBodyOverflowSetting to undefined
+        // so setOverflowHidden knows it can be set again.
+        previousBodyOverflowSetting = undefined;
+    }
+};
+const setPositionFixed = () => window.requestAnimationFrame(() => {
+    // If previousBodyPosition is already set, don't set it again.
+    if (previousBodyPosition === undefined) {
+        previousBodyPosition = {
+            position: document.body.style.position,
+            top: document.body.style.top,
+            left: document.body.style.left,
+        };
+        // Update the dom inside an animation frame
+        const { scrollY, scrollX, innerHeight } = window;
+        document.body.style.position = "fixed";
+        document.body.style.top = `${-scrollY}px`;
+        document.body.style.left = `${-scrollX}px`;
+        setTimeout(() => window.requestAnimationFrame(() => {
+            // Attempt to check if the bottom bar appeared due to the position change
+            const bottomBarHeight = innerHeight - window.innerHeight;
+            if (bottomBarHeight && scrollY >= innerHeight) {
+                // Move the content further up so that the bottom bar doesn't hide it
+                document.body.style.top = `${-(scrollY + bottomBarHeight)}px`;
+            }
+        }), 300);
+    }
+});
+const restorePositionSetting = () => {
+    if (previousBodyPosition !== undefined) {
+        // Convert the position from "px" to Int
+        const y = -parseInt(document.body.style.top, 10);
+        const x = -parseInt(document.body.style.left, 10);
+        // Restore styles
+        document.body.style.position = previousBodyPosition.position;
+        document.body.style.top = previousBodyPosition.top;
+        document.body.style.left = previousBodyPosition.left;
+        // Restore scroll
+        window.scrollTo(x, y);
+        previousBodyPosition = undefined;
+    }
+};
+// https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollHeight#Problems_and_solutions
+const isTargetElementTotallyScrolled = (targetElement) => targetElement ? targetElement.scrollHeight - targetElement.scrollTop <= targetElement.clientHeight : false;
+const handleScroll = (event, targetElement) => {
+    const clientY = event.targetTouches[0].clientY - initialClientY;
+    if (event.target && allowTouchMove(event.target)) {
+        return false;
+    }
+    if (targetElement && targetElement.scrollTop === 0 && clientY > 0) {
+        // element is at the top of its scroll.
+        return preventDefault(event);
+    }
+    if (isTargetElementTotallyScrolled(targetElement) && clientY < 0) {
+        // element is at the bottom of its scroll.
+        return preventDefault(event);
+    }
+    event.stopPropagation();
+    return true;
+};
+const disableBodyScroll = (targetElement, options) => {
+    // targetElement must be provided
+    if (!targetElement) {
+        // eslint-disable-next-line no-console
+        console.error("disableBodyScroll unsuccessful - targetElement must be provided when calling disableBodyScroll on IOS devices.");
+        return;
+    }
+    // disableBodyScroll must not have been called on this targetElement before
+    if (locks.some((lock) => lock.targetElement === targetElement)) {
+        return;
+    }
+    const lock = {
+        targetElement,
+        options: options || {},
+    };
+    locks = [...locks, lock];
+    if (isIosDevice) {
+        setPositionFixed();
+    }
+    else {
+        setOverflowHidden(options);
+    }
+    if (isIosDevice) {
+        targetElement.ontouchstart = (event) => {
+            if (event.targetTouches.length === 1) {
+                // detect single touch.
+                initialClientY = event.targetTouches[0].clientY;
+            }
+        };
+        targetElement.ontouchmove = (event) => {
+            if (event.targetTouches.length === 1) {
+                // detect single touch.
+                handleScroll(event, targetElement);
+            }
+        };
+        if (!documentListenerAdded) {
+            document.addEventListener("touchmove", preventDefault, hasPassiveEvents ? { passive: false } : undefined);
+            documentListenerAdded = true;
+        }
+    }
+};
+exports.disableBodyScroll = disableBodyScroll;
+const clearAllBodyScrollLocks = () => {
+    if (isIosDevice) {
+        // Clear all locks ontouchstart/ontouchmove handlers, and the references.
+        locks.forEach((lock) => {
+            lock.targetElement.ontouchstart = null;
+            lock.targetElement.ontouchmove = null;
+        });
+        if (documentListenerAdded) {
+            document.removeEventListener("touchmove", preventDefault);
+            documentListenerAdded = false;
+        }
+        // Reset initial clientY.
+        initialClientY = -1;
+    }
+    if (isIosDevice) {
+        restorePositionSetting();
+    }
+    else {
+        restoreOverflowSetting();
+    }
+    locks = [];
+};
+exports.clearAllBodyScrollLocks = clearAllBodyScrollLocks;
+const enableBodyScroll = (targetElement) => {
+    if (!targetElement) {
+        // eslint-disable-next-line no-console
+        console.error("enableBodyScroll unsuccessful - targetElement must be provided when calling enableBodyScroll on IOS devices.");
+        return;
+    }
+    locks = locks.filter((lock) => lock.targetElement !== targetElement);
+    if (isIosDevice) {
+        targetElement.ontouchstart = null;
+        targetElement.ontouchmove = null;
+        if (documentListenerAdded && locks.length === 0) {
+            document.removeEventListener("touchmove", preventDefault);
+            documentListenerAdded = false;
+        }
+    }
+    if (isIosDevice) {
+        restorePositionSetting();
+    }
+    else {
+        restoreOverflowSetting();
+    }
+};
+exports.enableBodyScroll = enableBodyScroll;

package/utils/buildArray.d.ts

@@ -1,21 +1,9 @@
-export declare function buildArray<T>(): {
-    add: (data: T) => {
-        add: any;
-        when: (condition: boolean, data: T) => {
-            add: any;
-            when: any;
-            get: () => T[];
-        };
-        get: () => T[];
-    };
-    when: (condition: boolean, data: T) => {
-        add: (data: T) => {
-            add: any;
-            when: any;
-            get: () => T[];
-        };
-        when: any;
-        get: () => T[];
-    };
-    get: () => T[];
-};
+type Element<T> = T;
+type WhenFn<T> = (when: boolean, element: Element<T>) => ProxiedArray<T>;
+type AddFn<T> = (element: Element<T>) => ProxiedArray<T>;
+type ProxiedArray<T> = {
+    when: WhenFn<T>;
+    add: AddFn<T>;
+} & T[];
+export declare function buildArray<T = unknown>(initial?: T[]): ProxiedArray<T>;
+export {};

package/utils/buildArray.js

@@ -1,28 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildArray = void 0;
-function get(array) {
-    return () => {
-        return array;
-    };
-}
-function add(array) {
-    return (data) => {
-        array.push(data);
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        return { add: add(array), when: when(array), get: get(array) };
-    };
-}
-function when(array) {
-    return (condition, data) => {
-        if (condition) {
-            array.push(data);
-        }
-        return { add: add(array), when: when(array), get: get(array) };
-    };
-}
-function buildArray() {
-    const array = [];
-    return { add: add(array), when: when(array), get: get(array) };
+function buildArray(initial) {
+    const initialArray = (initial ? [...initial] : []);
+    const proxiedArray = new Proxy(initialArray, {
+        get: (target, prop, receiver) => {
+            if ("add" === prop) {
+                return (element) => {
+                    target.push(element);
+                    return proxiedArray;
+                };
+            }
+            if ("when" === prop) {
+                return (when, element) => {
+                    if (when) {
+                        target.push(element);
+                    }
+                    return proxiedArray;
+                };
+            }
+            return Reflect.get(target, prop, receiver);
+        },
+    });
+    return proxiedArray;
 }
 exports.buildArray = buildArray;

package/utils/buildArray.test.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const buildArray_1 = require("./buildArray");
 test("buildArray", () => {
-    expect((0, buildArray_1.buildArray)().get()).toStrictEqual([]);
-    expect((0, buildArray_1.buildArray)().add("uxf").get()).toStrictEqual(["uxf"]);
-    expect((0, buildArray_1.buildArray)().add("ux").add("fans").get()).toStrictEqual(["ux", "fans"]);
-    expect((0, buildArray_1.buildArray)().add("ux").when(true, "fans").get()).toStrictEqual(["ux", "fans"]);
-    expect((0, buildArray_1.buildArray)().add("ux").when(false, "fans").get()).toStrictEqual(["ux"]);
+    expect((0, buildArray_1.buildArray)()).toStrictEqual([]);
+    expect((0, buildArray_1.buildArray)().add("uxf")).toStrictEqual(["uxf"]);
+    expect((0, buildArray_1.buildArray)().add("ux").add("fans")).toStrictEqual(["ux", "fans"]);
+    expect((0, buildArray_1.buildArray)().add("ux").when(true, "fans")).toStrictEqual(["ux", "fans"]);
+    expect((0, buildArray_1.buildArray)().add("ux").when(false, "fans")).toStrictEqual(["ux"]);
 });

package/utils/copy-to-clipboard.js

@@ -9,7 +9,7 @@ function copyToClipboardFallback(text) {
     textArea.style.left = "0";
     textArea.style.position = "fixed";
     document.body.appendChild(textArea);
-    textArea.focus();
+    textArea.focus({ preventScroll: true });
     textArea.select();
     document.execCommand("copy");
     document.body.removeChild(textArea);

package/utils/filter-nullish.d.ts

@@ -0,0 +1 @@
+export declare function filterNullish<T>(val: Array<T | null | undefined>): T[];

package/utils/filter-nullish.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterNullish = void 0;
+const is_not_nil_1 = require("./is-not-nil");
+function filterNullish(val) {
+    return val.filter(is_not_nil_1.isNotNil);
+}
+exports.filterNullish = filterNullish;

package/utils/image.d.ts

@@ -1,11 +1,13 @@
-import { ImageSource, ResizerImageProps } from "./resizer";
 import { FC } from "react";
+import { ImageSource, ResizerImageProps } from "./resizer";
 export type Dimension = number | "auto";
 export type Format = "avif" | "webp" | "original";
 export type Quality = number | Record<Format, number>;
 export declare function getSvgImgUrl(src: ImageSource): string | undefined;
 export declare function getImgQuality(quality: Quality | undefined, format: Format): number | undefined;
 export declare function getImgUniqueIdentifier(src: ImageSource): string | undefined;
+export declare function getImgElementHeight(src: ImageSource, width: number | undefined, height: number | undefined): number | undefined;
+export declare function getImgElementWidth(src: ImageSource, width: number | undefined, height: number | undefined): number | undefined;
 export declare function getImgSrcSet(src?: ImageSource, width?: Dimension, height?: Dimension, options?: ResizerImageProps): string | undefined;
 interface ImageSourcesProps {
     breakpointIndex?: number;

package/utils/image.js

@@ -3,10 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImgSources = exports.getImgSrcSet = exports.getImgUniqueIdentifier = exports.getImgQuality = exports.getSvgImgUrl = void 0;
+exports.ImgSources = exports.getImgSrcSet = exports.getImgElementWidth = exports.getImgElementHeight = exports.getImgUniqueIdentifier = exports.getImgQuality = exports.getSvgImgUrl = void 0;
+const react_1 = __importDefault(require("react"));
 const file_1 = require("./file");
 const resizer_1 = require("./resizer");
-const react_1 = __importDefault(require("react"));
 function toImageResponse(src) {
     return typeof src !== "string" && "uuid" in src ? src : undefined;
 }
@@ -41,6 +41,20 @@ function getImgUniqueIdentifier(src) {
     return typeof src === "string" ? src : (_b = (_a = toImageResponse(src)) === null || _a === void 0 ? void 0 : _a.uuid) !== null && _b !== void 0 ? _b : (_c = toStaticImageData(src)) === null || _c === void 0 ? void 0 : _c.src;
 }
 exports.getImgUniqueIdentifier = getImgUniqueIdentifier;
+function getImgElementHeight(src, width, height) {
+    var _a, _b;
+    return typeof src === "string"
+        ? height
+        : height !== null && height !== void 0 ? height : (Math.floor((((_a = src.height) !== null && _a !== void 0 ? _a : 0) / ((_b = src.width) !== null && _b !== void 0 ? _b : 0)) * (width || 0)) || undefined);
+}
+exports.getImgElementHeight = getImgElementHeight;
+function getImgElementWidth(src, width, height) {
+    var _a, _b;
+    return typeof src === "string"
+        ? width
+        : width !== null && width !== void 0 ? width : (Math.floor(((_a = src.width) !== null && _a !== void 0 ? _a : 0) / ((_b = src.height) !== null && _b !== void 0 ? _b : 0)) * (height || 0) || undefined);
+}
+exports.getImgElementWidth = getImgElementWidth;
 const HIDPI_SIZES = [3, 2, 1];
 function getImgSrcSet(src, width, height, options = {}) {
     var _a, _b;
@@ -72,7 +86,7 @@ function getImgSrcSet(src, width, height, options = {}) {
         w = w || staticImageData.width;
     }
     if (typeof h === "number" || typeof w === "number") {
-        return HIDPI_SIZES.map((size) => (0, resizer_1.resizerImageUrl)(src, w * size, h * size, {
+        return HIDPI_SIZES.map((size) => (0, resizer_1.resizerImageUrl)(src, typeof w === "number" ? w * size : "auto", typeof h === "number" ? h * size : "auto", {
             toFormat,
             ...options,
         }) + (size > 1 ? ` ${size}x` : "")).join(", ");

package/utils/is-nil.d.ts

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

package/utils/is-nil.js

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

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

@@ -0,0 +1 @@
+export declare function isNotNil<T>(val: T | null | undefined): val is T;

package/utils/is-not-nil.js

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

package/utils/resizer.js

@@ -48,7 +48,7 @@ const resizerStaticImageUrl = (src, width = "auto", height = "auto", props = {},
 };
 const resizerImageUrl = (source, width = "auto", height = "auto", props = {}, version = 1) => {
     var _a, _b;
-    if (source === null || source === undefined) {
+    if (source === null || source === undefined || source === "") {
         return undefined;
     }
     if (typeof source === "string" || "src" in source) {

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

@@ -0,0 +1 @@
+export declare function sortObjectKeys<T extends Record<string, any>>(object: T): T;

package/utils/sort-object-keys.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortObjectKeys = void 0;
+function sortObjectKeys(object) {
+    const sortedObject = {};
+    const keys = Object.keys(object);
+    keys.sort();
+    keys.forEach((key) => {
+        if (typeof object[key] === "string") {
+            sortedObject[key] = object[key];
+        }
+        else {
+            sortedObject[key] = sortObjectKeys(object[key]);
+        }
+    });
+    return sortedObject;
+}
+exports.sortObjectKeys = sortObjectKeys;

package/utils/forwardRef.d.ts

@@ -1,10 +0,0 @@
-import { ForwardedRef, ForwardRefExoticComponent, PropsWithoutRef, ReactElement, RefAttributes } from "react";
-export type ForwardRefRenderFunction<T, P> = {
-    (props: P, ref: ForwardedRef<T>): ReactElement | null;
-    displayName?: string;
-    /** defaultProps are not supported on render functions */
-    defaultProps?: never;
-    /** propTypes are not supported on render functions */
-    propTypes?: never;
-};
-export declare const forwardRef: <T, P>(name: string, render: ForwardRefRenderFunction<T, P>) => ForwardRefExoticComponent<PropsWithoutRef<P> & RefAttributes<T>>;

package/utils/forwardRef.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.forwardRef = void 0;
-const react_1 = require("react");
-const forwardRef = (name, render) => {
-    const Component = (0, react_1.forwardRef)(render);
-    Component.displayName = name;
-    return Component;
-};
-exports.forwardRef = forwardRef;