@cargo-ai/utils 1.0.4

package/build/array.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retrievevedMovedItem = exports.difference = exports.isUnique = exports.uniqueByKey = exports.uniqueByProperty = exports.unique = void 0;
+var unique = function (arr) {
+    return arr.filter(function (v, i) { return arr.indexOf(v) === i; });
+};
+exports.unique = unique;
+var uniqueByProperty = function (array, getProperty) {
+    var uniqueArray = [];
+    array.forEach(function (item) {
+        var itemProperty = getProperty(item);
+        var isUnique = uniqueArray.some(function (otherItem) {
+            return getProperty(otherItem) === itemProperty;
+        }) === false;
+        if (isUnique === true) {
+            uniqueArray.push(item);
+        }
+    });
+    return uniqueArray;
+};
+exports.uniqueByProperty = uniqueByProperty;
+var uniqueByKey = function (arr, key) {
+    return Array.from(new Map(arr.map(function (item) { return [item[key], item]; })).values());
+};
+exports.uniqueByKey = uniqueByKey;
+var isUnique = function (arr) {
+    return arr.length === new Set(arr).size;
+};
+exports.isUnique = isUnique;
+var difference = function (a, b) {
+    return a.filter(function (element) {
+        return !b.includes(element);
+    });
+};
+exports.difference = difference;
+var retrievevedMovedItem = function (a, b) {
+    var sourceIndex = a.findIndex(function (item, index) {
+        return item !== b[index] && item !== b[index + 1];
+    });
+    if (sourceIndex === -1) {
+        return undefined;
+    }
+    var sourceItem = a[sourceIndex];
+    var destinationIndex = b.findIndex(function (item) {
+        return item === sourceItem;
+    });
+    if (destinationIndex === -1) {
+        return undefined;
+    }
+    return { sourceIndex: sourceIndex, destinationIndex: destinationIndex };
+};
+exports.retrievevedMovedItem = retrievevedMovedItem;

package/build/collection.js

@@ -0,0 +1,155 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.equals = exports.setFromPath = exports.getFromPath = exports.removeUndefined = exports.stringToDate = exports.nullToUndefined = exports.areEqualArrays = exports.groupBy = exports.mapValues = exports.fromEntries = exports.getEntries = exports.getValues = exports.getKeys = exports.pick = void 0;
+var date_fns_1 = require("date-fns");
+var fast_deep_equal_1 = require("fast-deep-equal");
+var pick = function (obj, keys) {
+    var ret = {};
+    keys.forEach(function (key) {
+        ret[key] = obj[key];
+    });
+    return ret;
+};
+exports.pick = pick;
+var getKeys = function (object) {
+    return Object.keys(object);
+};
+exports.getKeys = getKeys;
+var getValues = function (object) {
+    return Object.values(object);
+};
+exports.getValues = getValues;
+var getEntries = function (object) {
+    return Object.entries(object);
+};
+exports.getEntries = getEntries;
+var fromEntries = function (entries) {
+    var object = {};
+    for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
+        var _a = entries_1[_i], key = _a[0], value = _a[1];
+        object[key] = value;
+    }
+    return object;
+};
+exports.fromEntries = fromEntries;
+var mapValues = function (object, iteratee) {
+    var result = {};
+    for (var _i = 0, _a = (0, exports.getEntries)(object); _i < _a.length; _i++) {
+        var _b = _a[_i], key = _b[0], value = _b[1];
+        result[key] = iteratee(value, key, object);
+    }
+    return result;
+};
+exports.mapValues = mapValues;
+var groupBy = function (array, key) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return array.reduce(function (result, currentValue) {
+        (result[currentValue[key]] = result[currentValue[key]] || []).push(currentValue);
+        return result;
+    }, {});
+};
+exports.groupBy = groupBy;
+var areEqualArrays = function (array1, array2) {
+    return array1.length == array2.length &&
+        array1.every(function (element, index) {
+            return element === array2[index];
+        });
+};
+exports.areEqualArrays = areEqualArrays;
+var nullToUndefined = function (value) {
+    if (value === null) {
+        return undefined;
+    }
+    if (value instanceof Array) {
+        return value.map(exports.nullToUndefined);
+    }
+    if (value instanceof Object) {
+        return (0, exports.mapValues)(value, exports.nullToUndefined);
+    }
+    return value;
+};
+exports.nullToUndefined = nullToUndefined;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+var stringToDate = function (value) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    if (value instanceof Array) {
+        return value.map(exports.stringToDate);
+    }
+    if (value instanceof Object &&
+        Object.prototype.toString.call(value) !== "[object Date]") {
+        return (0, exports.mapValues)(value, exports.stringToDate);
+    }
+    if (isNaN(value) &&
+        typeof value === "string" &&
+        (0, date_fns_1.isValid)((0, date_fns_1.parseJSON)(value))) {
+        var date = new Date(value);
+        return isNaN(date.getTime()) ? value : date;
+    }
+    return value;
+};
+exports.stringToDate = stringToDate;
+var removeUndefined = function (value) {
+    if (value instanceof Array) {
+        return value.filter(function (v) { return v !== undefined; }).map(exports.removeUndefined);
+    }
+    if (value instanceof Object) {
+        return (0, exports.fromEntries)((0, exports.getEntries)(value)
+            .filter(function (_a) {
+            var v = _a[1];
+            return v !== undefined;
+        })
+            .map(function (_a) {
+            var k = _a[0], v = _a[1];
+            return [k, (0, exports.removeUndefined)(v)];
+        }));
+    }
+    return value;
+};
+exports.removeUndefined = removeUndefined;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+var getFromPath = function (data, path) {
+    return path.split(".").reduce(function (acc, value) {
+        var intValue = parseInt(value, 10);
+        return acc === null || acc === void 0 ? void 0 : acc[Number.isNaN(intValue) ? value : intValue];
+    }, data);
+};
+exports.getFromPath = getFromPath;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+var setFromPath = function (
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+data, path, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+value) {
+    var newData = __assign({}, data);
+    var schema = newData;
+    var keys = path.split(".");
+    for (var index = 0; index < keys.length; index++) {
+        var key = keys[index];
+        if (key === undefined) {
+            continue;
+        }
+        if (schema[key] === undefined) {
+            schema[key] = index === keys.length - 1 ? value : {};
+        }
+        schema = schema[key];
+    }
+    return newData;
+};
+exports.setFromPath = setFromPath;
+var equals = function (data, otherData) {
+    return (0, fast_deep_equal_1.default)((0, exports.removeUndefined)(data), (0, exports.removeUndefined)(otherData));
+};
+exports.equals = equals;

package/build/components.js

@@ -0,0 +1,56 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterComponentElements = exports.replaceComponentElements = exports.isComponentElement = void 0;
+var react_1 = require("react");
+var isComponentElement = function (component, element) {
+    return component.name === element.type.name;
+};
+exports.isComponentElement = isComponentElement;
+var replaceComponentElements = function (component, replace, children) {
+    if (!children) {
+        return undefined;
+    }
+    var count = react_1.default.Children.count(children);
+    return react_1.default.Children.map(children, function (child, index) {
+        if (!react_1.default.isValidElement(child)) {
+            return child;
+        }
+        var childElement = child;
+        if ((0, exports.isComponentElement)(component, childElement)) {
+            return replace(childElement.props, index, count);
+        }
+        if (childElement.props.children) {
+            return __assign(__assign({}, childElement), { props: __assign(__assign({}, childElement.props), { children: (0, exports.replaceComponentElements)(component, replace, childElement.props.children) }) });
+        }
+        return child;
+    });
+};
+exports.replaceComponentElements = replaceComponentElements;
+var filterComponentElements = function (component, children) {
+    var elements = [];
+    react_1.default.Children.forEach(children, function (child) {
+        if (!react_1.default.isValidElement(child)) {
+            return;
+        }
+        var childElement = child;
+        if ((0, exports.isComponentElement)(component, childElement)) {
+            elements.push(childElement);
+        }
+        else if (childElement.props.children) {
+            elements.push.apply(elements, (0, exports.filterComponentElements)(component, childElement.props.children));
+        }
+    });
+    return elements;
+};
+exports.filterComponentElements = filterComponentElements;

package/build/cron.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.humanizedCrons = void 0;
+var every3daysCron = "@every ".concat(3 * 24, "h");
+var everyWeekCron = "@every ".concat(7 * 24, "h");
+var every2WeeksCron = "@every ".concat(2 * 7 * 24, "h");
+var every3WeeksCron = "@every ".concat(3 * 7 * 24, "h");
+exports.humanizedCrons = {
+    "Every 30 minutes": "@every 30m",
+    "Every hour": "@every 1h",
+    "Every 3 hours": "@every 3h",
+    "Every 6 hours": "@every 6h",
+    "Every 12 hours": "@every 12h",
+    "Every day": "@every 24h",
+    "Every 3 days": every3daysCron,
+    "Every week": everyWeekCron,
+    "Every 2 weeks": every2WeeksCron,
+    "Every 3 weeks": every3WeeksCron,
+};

package/build/delay.js

@@ -0,0 +1,52 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delay = void 0;
+var delay = function (milliseconds) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, new Promise(function (resolve) {
+                    return setTimeout(function () { return resolve(); }, milliseconds);
+                })];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); };
+exports.delay = delay;

package/build/hooks/index.js

@@ -0,0 +1,35 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useVideoPlayer = exports.useScrollPosition = exports.usePictureInPicture = exports.useEventListener = exports.useDeviceType = exports.useCountAnimation = void 0;
+__exportStar(require("./useClickOutside.js"), exports);
+var useCountAnimation_js_1 = require("./useCountAnimation.js");
+Object.defineProperty(exports, "useCountAnimation", { enumerable: true, get: function () { return useCountAnimation_js_1.useCountAnimation; } });
+var useDeviceType_js_1 = require("./useDeviceType.js");
+Object.defineProperty(exports, "useDeviceType", { enumerable: true, get: function () { return useDeviceType_js_1.useDeviceType; } });
+var useEventListener_js_1 = require("./useEventListener.js");
+Object.defineProperty(exports, "useEventListener", { enumerable: true, get: function () { return useEventListener_js_1.useEventListener; } });
+__exportStar(require("./useHeight.js"), exports);
+var usePictureInPicture_js_1 = require("./usePictureInPicture.js");
+Object.defineProperty(exports, "usePictureInPicture", { enumerable: true, get: function () { return usePictureInPicture_js_1.usePictureInPicture; } });
+__exportStar(require("./useResizeObserver.js"), exports);
+var useScrollPosition_js_1 = require("./useScrollPosition.js");
+Object.defineProperty(exports, "useScrollPosition", { enumerable: true, get: function () { return useScrollPosition_js_1.useScrollPosition; } });
+__exportStar(require("./useStepper.js"), exports);
+__exportStar(require("./useStorageState.js"), exports);
+var index_js_1 = require("./useVideoPlayer/index.js");
+Object.defineProperty(exports, "useVideoPlayer", { enumerable: true, get: function () { return index_js_1.useVideoPlayer; } });
+__exportStar(require("./useWillUnmountEffect.js"), exports);

package/build/hooks/useClickOutside.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useClickOutside = void 0;
+var react_1 = require("react");
+var useClickOutside = function (refOrRefs, handle) {
+    react_1.default.useEffect(function () {
+        if (refOrRefs === null ||
+            (Array.isArray(refOrRefs) && refOrRefs.length === 0)) {
+            return;
+        }
+        var handleClickOutside = function (event) {
+            var hasClickedOutsideRef = Array.isArray(refOrRefs)
+                ? refOrRefs.every(function (ref) {
+                    return matchHasClickedOutsideRef(event, ref);
+                })
+                : matchHasClickedOutsideRef(event, refOrRefs);
+            if (hasClickedOutsideRef === true) {
+                handle(event);
+            }
+        };
+        document.addEventListener("mouseup", handleClickOutside);
+        return function () {
+            document.removeEventListener("mouseup", handleClickOutside);
+        };
+    }, [refOrRefs, handle]);
+};
+exports.useClickOutside = useClickOutside;
+var matchHasClickedOutsideRef = function (event, ref) {
+    if (ref === null) {
+        return false;
+    }
+    var element = ref instanceof HTMLElement ? ref : ref.current;
+    if (element === null) {
+        return false;
+    }
+    if (event.target === null) {
+        return false;
+    }
+    var x = event.clientX, y = event.clientY;
+    var _a = element.getBoundingClientRect(), refHeight = _a.height, refWidth = _a.width, refTop = _a.top, refLeft = _a.left;
+    var isClickInsideElement = x >= refLeft &&
+        x <= refLeft + refWidth &&
+        y >= refTop &&
+        y <= refTop + refHeight;
+    return isClickInsideElement === false;
+};

package/build/hooks/useCountAnimation.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCountAnimation = void 0;
+var react_1 = require("react");
+function useCountAnimation(targetValue, triggerKey) {
+    var _a = react_1.default.useState(0), currentValue = _a[0], setCurrentValue = _a[1];
+    var previousKey = react_1.default.useRef(triggerKey);
+    var isFirstMount = react_1.default.useRef(true);
+    react_1.default.useEffect(function () {
+        if (isFirstMount.current === true) {
+            isFirstMount.current = false;
+        }
+        else if (triggerKey === undefined || previousKey.current === triggerKey) {
+            setCurrentValue(targetValue);
+            return;
+        }
+        previousKey.current = triggerKey;
+        var start = Date.now();
+        var duration = 300;
+        var step = function () {
+            var progress = (Date.now() - start) / duration;
+            if (progress < 1) {
+                setCurrentValue(Math.floor(progress * targetValue));
+                requestAnimationFrame(step);
+            }
+            else {
+                setCurrentValue(targetValue);
+            }
+        };
+        requestAnimationFrame(step);
+    }, [targetValue, triggerKey]);
+    return currentValue;
+}
+exports.useCountAnimation = useCountAnimation;

package/build/hooks/useDeviceType.js

@@ -0,0 +1,54 @@
+"use client";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDeviceType = void 0;
+var react_1 = require("react");
+var useEventListener_js_1 = require("./useEventListener.js");
+var sizes = {
+    sm: 640,
+    md: 768,
+    lg: 1024,
+    xl: 1280,
+    "2xl": 1536,
+};
+function getDeviceType(width, height) {
+    var isLandscape = width > height;
+    var landscapeMobileMaxWidth = 850;
+    if (isLandscape && width <= landscapeMobileMaxWidth)
+        return "mobile";
+    if (width < sizes.sm)
+        return "mobile";
+    if (width >= sizes.sm && width <= sizes.lg)
+        return "tablet";
+    if (width >= sizes.lg && width <= sizes.xl)
+        return "desktop";
+    return "largeScreen";
+}
+function createDeviceTypeStore() {
+    var listeners = new Set();
+    var currentDeviceType = null;
+    var updateDeviceType = function () {
+        var newDeviceType = getDeviceType(window.innerWidth, window.innerHeight);
+        if (currentDeviceType !== newDeviceType) {
+            currentDeviceType = newDeviceType;
+            listeners.forEach(function (listener) { return listener(); });
+        }
+    };
+    return {
+        updateDeviceType: updateDeviceType,
+        subscribe: function (callback) {
+            listeners.add(callback);
+            return function () { return listeners.delete(callback); };
+        },
+        getSnapshot: function () { return currentDeviceType; },
+        getServerSnapshot: function () { return currentDeviceType; },
+    };
+}
+var deviceTypeStore = createDeviceTypeStore();
+function useDeviceType() {
+    var subscribe = deviceTypeStore.subscribe, getSnapshot = deviceTypeStore.getSnapshot, getServerSnapshot = deviceTypeStore.getServerSnapshot, updateDeviceType = deviceTypeStore.updateDeviceType;
+    (0, react_1.useEffect)(function () { return updateDeviceType(); }, [updateDeviceType]);
+    (0, useEventListener_js_1.useEventListener)("resize", updateDeviceType);
+    return (0, react_1.useSyncExternalStore)(subscribe, getSnapshot, getServerSnapshot);
+}
+exports.useDeviceType = useDeviceType;

package/build/hooks/useEventListener.js

@@ -0,0 +1,27 @@
+"use client";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useEventListener = void 0;
+var react_1 = require("react");
+function useEventListener(eventName, handler, element, options) {
+    // Create a ref that stores handler
+    var savedHandler = (0, react_1.useRef)(handler);
+    (0, react_1.useEffect)(function () {
+        savedHandler.current = handler;
+    }, [handler]);
+    (0, react_1.useEffect)(function () {
+        var _a;
+        // Define the listening target
+        var targetElement = (_a = element === null || element === void 0 ? void 0 : element.current) !== null && _a !== void 0 ? _a : window;
+        if (!(targetElement && targetElement.addEventListener))
+            return;
+        // Create event listener that calls handler function stored in ref
+        var listener = function (event) { return savedHandler.current(event); };
+        targetElement.addEventListener(eventName, listener, options);
+        // Remove event listener on cleanup
+        return function () {
+            targetElement.removeEventListener(eventName, listener, options);
+        };
+    }, [eventName, element, options]);
+}
+exports.useEventListener = useEventListener;

package/build/hooks/useHeight.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useHeight = void 0;
+var react_1 = require("react");
+var useHeight = function () {
+    var ref = react_1.default.useRef(null);
+    var _a = react_1.default.useState(0), height = _a[0], setHeight = _a[1];
+    var heightRef = react_1.default.useRef(height);
+    var resizeObserver = react_1.default.useState(function () {
+        return new ResizeObserver(function () {
+            if (ref.current && heightRef.current !== ref.current.offsetHeight) {
+                heightRef.current = ref.current.offsetHeight;
+                setHeight(ref.current.offsetHeight);
+            }
+        });
+    })[0];
+    react_1.default.useLayoutEffect(function () {
+        if (ref.current) {
+            setHeight(ref.current.offsetHeight);
+            resizeObserver.observe(ref.current, {});
+        }
+        return function () { return resizeObserver.disconnect(); };
+    }, [resizeObserver]);
+    return [ref, height];
+};
+exports.useHeight = useHeight;