@cargo-ai/utils 1.0.4

package/build/json.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isJsonSchemaEmpty = exports.castToJsonType = exports.getJsonType = exports.isJson = exports.jsonTypes = void 0;
+var collection_js_1 = require("./collection.js");
+exports.jsonTypes = [
+    "string",
+    "number",
+    "object",
+    "array",
+    "date",
+    "boolean",
+    "any",
+];
+var isJson = function (value) {
+    try {
+        JSON.parse(value);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+};
+exports.isJson = isJson;
+var getJsonType = function (value) {
+    if (value === null || value === undefined) {
+        return "any";
+    }
+    if (Array.isArray(value)) {
+        return "array";
+    }
+    if (value instanceof Date) {
+        return "date";
+    }
+    if (typeof value === "object") {
+        return "object";
+    }
+    if (value === true || value === false) {
+        return "boolean";
+    }
+    if (typeof value === "number") {
+        return "number";
+    }
+    if (typeof value === "string") {
+        return "string";
+    }
+    return "any";
+};
+exports.getJsonType = getJsonType;
+var castToJsonType = function (value, type) {
+    try {
+        if (type === "array") {
+            return Array.isArray(value) ? value : null;
+        }
+        if (type === "string") {
+            return String(value);
+        }
+        if (type === "boolean") {
+            return Boolean(value);
+        }
+        if (type === "number") {
+            var number = Number(value);
+            if (isNaN(number)) {
+                return undefined;
+            }
+            return number;
+        }
+        if (type === "date") {
+            return new Date(value);
+        }
+        return value;
+    }
+    catch (_a) {
+        return undefined;
+    }
+};
+exports.castToJsonType = castToJsonType;
+var isJsonSchemaEmpty = function (jsonSchema) {
+    return jsonSchema.type === "object" &&
+        (!jsonSchema.properties || (0, collection_js_1.getKeys)(jsonSchema.properties).length === 0);
+};
+exports.isJsonSchemaEmpty = isJsonSchemaEmpty;

package/build/random.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.random = void 0;
+var random = function (min, max) {
+    return Math.floor(Math.random() * (max - min + 1) + min);
+};
+exports.random = random;

package/build/src/array.d.ts

@@ -0,0 +1,16 @@
+export declare const chunk: <T>(arr: T[], size: number) => T[][];
+export declare const unique: <T>(arr: T[]) => T[];
+export declare const uniqueByProperty: <T>(array: T[], getProperty: (item: T) => unknown, options?: {
+    isReverse?: boolean;
+}) => T[];
+export declare const uniqueByKey: <T extends Record<string, unknown>>(arr: T[], key: keyof T) => T[];
+export declare const isUnique: <T>(arr: T[]) => boolean;
+export declare const difference: <T>(a: T[], b: T[]) => T[];
+export declare const shuffle: <T>(array: T[]) => T[];
+export declare const move: <T>(array: T[], fromIndex: number, toIndex: number) => T[];
+export declare const retrievevedMovedItem: <T>(a: T[], b: T[]) => {
+    sourceIndex: number;
+    destinationIndex: number;
+} | undefined;
+export declare const pickRandom: <T>(array: T[], amount?: number) => T[];
+//# sourceMappingURL=array.d.ts.map

package/build/src/array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../src/array.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,KAAK,sBAAuB,MAAM,UAI9C,CAAC;AAEF,eAAO,MAAM,MAAM,sBAElB,CAAC;AAEF,eAAO,MAAM,gBAAgB,4CAED,OAAO,YACxB;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE,QAqBjC,CAAC;AAEF,eAAO,MAAM,WAAW,oEAKvB,CAAC;AAEF,eAAO,MAAM,QAAQ,mBAAkB,OAEtC,CAAC;AAEF,eAAO,MAAM,UAAU,4BAItB,CAAC;AAEF,eAAO,MAAM,OAAO,wBAEnB,CAAC;AAEF,eAAO,MAAM,IAAI,6BAEJ,MAAM,WACR,MAAM,QAkBhB,CAAC;AAEF,eAAO,MAAM,oBAAoB;iBAGf,MAAM;sBAAoB,MAAM;aAmBjD,CAAC;AAEF,eAAO,MAAM,UAAU,2BAA2B,MAAM,QAqBvD,CAAC"}

package/build/src/array.js

@@ -0,0 +1,81 @@
+export const chunk = (arr, size) => {
+    return Array.from({ length: Math.ceil(arr.length / size) }, (_, i) => arr.slice(i * size, i * size + size));
+};
+export const unique = (arr) => {
+    return [...new Set(arr)];
+};
+export const uniqueByProperty = (array, getProperty, options = {}) => {
+    const { isReverse = false } = options;
+    const arrayCopy = isReverse === true ? [...array].reverse() : array;
+    const uniqueArray = [];
+    arrayCopy.forEach((item) => {
+        const itemProperty = getProperty(item);
+        const isUnique = uniqueArray.some((otherItem) => {
+            return getProperty(otherItem) === itemProperty;
+        }) === false;
+        if (isUnique === true) {
+            uniqueArray.push(item);
+        }
+    });
+    return uniqueArray;
+};
+export const uniqueByKey = (arr, key) => {
+    return Array.from(new Map(arr.map((item) => [item[key], item])).values());
+};
+export const isUnique = (arr) => {
+    return arr.length === new Set(arr).size;
+};
+export const difference = (a, b) => {
+    return a.filter((element) => {
+        return !b.includes(element);
+    });
+};
+export const shuffle = (array) => {
+    return array.sort(() => 0.5 - Math.random());
+};
+export const move = (array, fromIndex, toIndex) => {
+    const newArray = [...array];
+    const startIndex = fromIndex < 0 ? newArray.length + fromIndex : fromIndex;
+    if (startIndex >= 0 && startIndex < newArray.length) {
+        const endIndex = toIndex < 0 ? newArray.length + toIndex : toIndex;
+        const [item] = newArray.splice(fromIndex, 1);
+        if (item === undefined) {
+            return newArray;
+        }
+        newArray.splice(endIndex, 0, item);
+    }
+    return newArray;
+};
+export const retrievevedMovedItem = (a, b) => {
+    const sourceIndex = a.findIndex((item, index) => {
+        return item !== b[index] && item !== b[index + 1];
+    });
+    if (sourceIndex === -1) {
+        return undefined;
+    }
+    const sourceItem = a[sourceIndex];
+    const destinationIndex = b.findIndex((item) => {
+        return item === sourceItem;
+    });
+    if (destinationIndex === -1) {
+        return undefined;
+    }
+    return { sourceIndex, destinationIndex };
+};
+export const pickRandom = (array, amount = 1) => {
+    if (amount <= 0) {
+        return [];
+    }
+    if (amount >= array.length) {
+        return [...array];
+    }
+    const result = [];
+    const availableIndices = Array.from({ length: array.length }, (_, i) => i);
+    for (let i = 0; i < amount; i++) {
+        const randomIndex = Math.floor(Math.random() * availableIndices.length);
+        const selectedIndex = availableIndices[randomIndex];
+        result.push(array[selectedIndex]);
+        availableIndices.splice(randomIndex, 1);
+    }
+    return result;
+};

package/build/src/base64.d.ts

@@ -0,0 +1,3 @@
+export declare const encodeBase64: (value: string) => string;
+export declare const decodeBase64: (value: string) => string;
+//# sourceMappingURL=base64.d.ts.map

package/build/src/base64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64.d.ts","sourceRoot":"","sources":["../../src/base64.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,UAAW,MAAM,KAAG,MAE5C,CAAC;AAEF,eAAO,MAAM,YAAY,UAAW,MAAM,KAAG,MAE5C,CAAC"}

package/build/src/base64.js

@@ -0,0 +1,6 @@
+export const encodeBase64 = (value) => {
+    return Buffer.from(value, "utf-8").toString("base64");
+};
+export const decodeBase64 = (value) => {
+    return Buffer.from(value, "base64").toString("utf-8");
+};

package/build/src/bytes.d.ts

@@ -0,0 +1,7 @@
+export declare const getByteLength: (obj: unknown) => number | undefined;
+export declare const byteChunk: <T>(arr: T[], maxByteLength: number) => T[][];
+export declare const byteObjectChunk: (obj: Record<string, unknown>, maxByteLength: number) => Record<string, unknown>[];
+export declare const getBytesUnit: (bytes: number) => "Bytes" | "KB" | "MB" | "GB" | "TB";
+export declare const getBytesValue: (bytes: number, decimals?: number) => number;
+export declare const getBytesWithUnitString: (bytes: number, decimals?: number) => string;
+//# sourceMappingURL=bytes.d.ts.map

package/build/src/bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.d.ts","sourceRoot":"","sources":["../../src/bytes.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,QAAS,OAAO,uBAMzC,CAAC;AAEF,eAAO,MAAM,SAAS,+BAAgC,MAAM,UAmB3D,CAAC;AAEF,eAAO,MAAM,eAAe,QACrB,OAAO,MAAM,EAAE,OAAO,CAAC,iBACb,MAAM,KACpB,OAAO,MAAM,EAAE,OAAO,CAAC,EAyBzB,CAAC;AAEF,eAAO,MAAM,YAAY,UAChB,MAAM,KACZ,OAAO,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAiBjC,CAAC;AAEF,eAAO,MAAM,aAAa,UAAW,MAAM,wBAAiB,MAS3D,CAAC;AAEF,eAAO,MAAM,sBAAsB,UAAW,MAAM,wBAAiB,MAEpE,CAAC"}

package/build/src/bytes.js

@@ -0,0 +1,71 @@
+import { fromEntries, getKeys } from "./collection.js";
+export const getByteLength = (obj) => {
+    try {
+        return Buffer.byteLength(JSON.stringify(obj));
+    }
+    catch {
+        return undefined;
+    }
+};
+export const byteChunk = (arr, maxByteLength) => {
+    if (arr.length === 1) {
+        return [arr];
+    }
+    const byteLength = getByteLength(arr);
+    if (byteLength === undefined || byteLength > maxByteLength) {
+        const divider = Math.floor(arr.length / 2);
+        const arr1 = arr.slice(0, divider);
+        const arr2 = arr.slice(divider);
+        return [
+            byteChunk(arr1, maxByteLength),
+            byteChunk(arr2, maxByteLength),
+        ].flat();
+    }
+    return [arr];
+};
+export const byteObjectChunk = (obj, maxByteLength) => {
+    const keys = getKeys(obj);
+    const byteLength = Buffer.byteLength(JSON.stringify(obj));
+    if (byteLength > maxByteLength) {
+        // if too big => we remove it
+        if (keys.length === 1) {
+            return [];
+        }
+        const divider = Math.floor(keys.length / 2);
+        const keys1 = keys.slice(0, divider);
+        const keys2 = keys.slice(divider);
+        const obj1 = fromEntries(keys1.map((k) => [k, obj[k]]));
+        const obj2 = fromEntries(keys2.map((k) => [k, obj[k]]));
+        return [
+            byteObjectChunk(obj1, maxByteLength),
+            byteObjectChunk(obj2, maxByteLength),
+        ].flat();
+    }
+    return [obj];
+};
+export const getBytesUnit = (bytes) => {
+    if (bytes === 0) {
+        return "Bytes";
+    }
+    const sizes = [
+        "Bytes",
+        "KB",
+        "MB",
+        "GB",
+        "TB",
+    ];
+    const threshold = 1024;
+    const index = Math.floor(Math.log(bytes) / Math.log(threshold));
+    return sizes[index] || "Bytes";
+};
+export const getBytesValue = (bytes, decimals = 2) => {
+    if (bytes === 0) {
+        return 0;
+    }
+    const threshold = 1024;
+    const index = Math.floor(Math.log(bytes) / Math.log(threshold));
+    return parseFloat((bytes / Math.pow(threshold, index)).toFixed(decimals));
+};
+export const getBytesWithUnitString = (bytes, decimals = 2) => {
+    return `${getBytesValue(bytes, decimals)} ${getBytesUnit(bytes)}`;
+};

package/build/src/collection/deepMergeObjects.d.ts

@@ -0,0 +1,2 @@
+export declare const deepMergeObjects: <T>(object1: T, object2: T) => T;
+//# sourceMappingURL=deepMergeObjects.d.ts.map

package/build/src/collection/deepMergeObjects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deepMergeObjects.d.ts","sourceRoot":"","sources":["../../../src/collection/deepMergeObjects.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,kCA0C5B,CAAC"}

package/build/src/collection/deepMergeObjects.js

@@ -0,0 +1,30 @@
+export const deepMergeObjects = (object1, object2) => {
+    if (Array.isArray(object1) === true && Array.isArray(object2) === true) {
+        const maxLength = Math.max(object1.length, object2.length);
+        const mergedArray = [];
+        for (let index = 0; index < maxLength; index++) {
+            const object1Value = object1[index];
+            const object2Value = object2[index];
+            if (object1Value !== undefined && object2Value !== undefined) {
+                mergedArray[index] = deepMergeObjects(object1Value, object2Value);
+            }
+            else {
+                mergedArray[index] =
+                    object2Value !== undefined ? object2Value : object1Value;
+            }
+        }
+        return mergedArray;
+    }
+    const mergedObject = { ...object1 };
+    for (const key in object2) {
+        const object1Value = object1[key];
+        const object2Value = object2[key];
+        if (object1Value instanceof Object === true &&
+            object2Value instanceof Object === true) {
+            mergedObject[key] = deepMergeObjects(object1Value, object2Value);
+            continue;
+        }
+        mergedObject[key] = object2Value;
+    }
+    return mergedObject;
+};

package/build/src/collection/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./deepMergeObjects.js";
+//# sourceMappingURL=index.d.ts.map

package/build/src/collection/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/collection/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC"}

package/build/src/collection/index.js

@@ -0,0 +1 @@
+export * from "./deepMergeObjects.js";

package/build/src/collection.d.ts

@@ -0,0 +1,22 @@
+import type { RecursiveNonNull } from "./types.js";
+export declare const pick: <T>(obj: T, keys: (keyof T)[]) => Partial<T>;
+export declare const getKeys: <T extends object>(object: T) => (keyof T & string)[];
+export declare const getValues: <T extends object>(object: T) => T[keyof T][];
+export declare const getEntries: <T extends object>(object: T) => [keyof T & string, T[keyof T & string]][];
+export declare const fromEntries: <K extends string | symbol, V>(entries: [K, V][]) => { [key in K]: V; };
+export declare const mapValues: <I extends object, O extends { [key in keyof I]: O[key]; }>(object: I, iteratee: <K extends keyof I & string>(value: I[K], key?: K | undefined, object?: I | undefined) => O[K]) => O;
+export declare const groupBy: <I extends Record<string, unknown>>(array: I[], key: keyof I) => Record<string, I[]>;
+export declare const sortBy: <I extends Record<string, unknown>>(array: I[], key: keyof I, order: "asc" | "desc") => I[];
+export declare const areArraysEqual: <I>(array1: I[], array2: I[]) => boolean;
+export declare const nullToUndefined: <Value>(value: Value) => RecursiveNonNull<Value>;
+export declare const stringToDate: (value: any, options?: {
+    timezone?: string;
+}) => any;
+export declare const dateToString: (value: any) => any;
+export declare const removeUndefined: (value: unknown) => unknown;
+export declare const setFromPath: <T>(data: T, path: string[], value: unknown) => T;
+export declare const getFromPath: (data: unknown, path: string[]) => unknown;
+export declare const equals: (data: unknown, otherData: unknown) => boolean;
+export declare const getPathFromJavascriptPath: (value: string) => string[];
+export declare const merge: <T>(data: T, dataToMerge: T) => T;
+//# sourceMappingURL=collection.d.ts.map

package/build/src/collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../../src/collection.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,eAAO,MAAM,IAAI,8CAOhB,CAAC;AAEF,eAAO,MAAM,OAAO,uDAInB,CAAC;AAEF,eAAO,MAAM,SAAS,+CAErB,CAAC;AAEF,eAAO,MAAM,UAAU,4EAMtB,CAAC;AAEF,eAAO,MAAM,WAAW,yEAQvB,CAAC;AAEF,eAAO,MAAM,SAAS,uLAgBrB,CAAC;AAEF,eAAO,MAAM,OAAO,sFAYnB,CAAC;AAEF,eAAO,MAAM,MAAM,uEAGV,KAAK,GAAG,MAAM,QAwBtB,CAAC;AAEF,eAAO,MAAM,cAAc,mCAAkC,OAM5D,CAAC;AAEF,eAAO,MAAM,eAAe,kDAmB3B,CAAC;AAEF,eAAO,MAAM,YAAY,UAEhB,GAAG,YACD;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,KAE7B,GAiCF,CAAC;AAGF,eAAO,MAAM,YAAY,UAAW,GAAG,KAAG,GAkBzC,CAAC;AAEF,eAAO,MAAM,eAAe,UAAW,OAAO,KAAG,OAchD,CAAC;AAEF,eAAO,MAAM,WAAW,qBAAsB,MAAM,EAAE,SAAS,OAAO,MAyDrE,CAAC;AAEF,eAAO,MAAM,WAAW,SAAU,OAAO,QAAQ,MAAM,EAAE,KAAG,OAY3D,CAAC;AAEF,eAAO,MAAM,MAAM,SAAU,OAAO,aAAa,OAAO,KAAG,OAE1D,CAAC;AAEF,eAAO,MAAM,yBAAyB,UAAW,MAAM,KAAG,MAAM,EAE/D,CAAC;AAEF,eAAO,MAAM,KAAK,mCAiBjB,CAAC"}

package/build/src/collection.js

@@ -0,0 +1,210 @@
+import { isValid, parseJSON } from "date-fns";
+import fastDeepEqual from "fast-deep-equal";
+import { getDate } from "./date/getDate.js";
+export const pick = (obj, keys) => {
+    const ret = {};
+    keys.forEach((key) => {
+        ret[key] = obj[key];
+    });
+    return ret;
+};
+export const getKeys = (object) => {
+    return Object.keys(object);
+};
+export const getValues = (object) => {
+    return Object.values(object);
+};
+export const getEntries = (object) => {
+    return Object.entries(object);
+};
+export const fromEntries = (entries) => {
+    const object = {};
+    for (const [key, value] of entries) {
+        object[key] = value;
+    }
+    return object;
+};
+export const mapValues = (object, iteratee) => {
+    const result = {};
+    for (const [key, value] of getEntries(object)) {
+        result[key] = iteratee(value, key, object);
+    }
+    return result;
+};
+export const groupBy = (array, key) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return array.reduce((result, currentValue) => {
+        (result[currentValue[key]] = result[currentValue[key]] || []).push(currentValue);
+        return result;
+    }, {});
+};
+export const sortBy = (array, key, order) => {
+    return array.sort((itemA, itemB) => {
+        const valueA = itemA[key];
+        const valueB = itemB[key];
+        if (valueA === null || valueA === undefined) {
+            return order === "asc" ? -1 : 1;
+        }
+        if (valueB === null || valueB === undefined) {
+            return order === "asc" ? 1 : -1;
+        }
+        let comparison = 0;
+        if (typeof valueA === "string" && typeof valueB === "string") {
+            comparison = valueA.localeCompare(valueB);
+        }
+        else if (typeof valueA === "number" && typeof valueB === "number") {
+            comparison = valueA - valueB;
+        }
+        return order === "asc" ? comparison : -comparison;
+    });
+};
+export const areArraysEqual = (array1, array2) => {
+    if (array1.length !== array2.length) {
+        return false;
+    }
+    return array1.every((value, index) => value === array2[index]);
+};
+export const nullToUndefined = (value) => {
+    if (value === null) {
+        return undefined;
+    }
+    if (value instanceof Array) {
+        return value.map(nullToUndefined);
+    }
+    if (value instanceof Object) {
+        return mapValues(value, (attributeValue) => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return nullToUndefined(attributeValue);
+        });
+    }
+    return value;
+};
+export const stringToDate = (
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+value, options = {}) => {
+    const { timezone = "UTC" } = options;
+    if (value === null || value === undefined) {
+        return value;
+    }
+    if (value instanceof Array) {
+        return value.map((item) => {
+            return stringToDate(item, { timezone });
+        });
+    }
+    if (value instanceof Object &&
+        Object.prototype.toString.call(value) !== "[object Date]") {
+        return mapValues(value, (item) => {
+            return stringToDate(item, { timezone });
+        });
+    }
+    if (isNaN(value) &&
+        typeof value === "string" &&
+        isValid(parseJSON(value))) {
+        const date = getDate(value, { timezone });
+        return isNaN(date.getTime()) ? value : date;
+    }
+    return value;
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const dateToString = (value) => {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (value instanceof Array) {
+        return value.map(dateToString);
+    }
+    if (value instanceof Object) {
+        return mapValues(value, dateToString);
+    }
+    return value;
+};
+export const removeUndefined = (value) => {
+    if (value instanceof Array) {
+        return value.filter((v) => v !== undefined).map(removeUndefined);
+    }
+    if (value instanceof Object) {
+        return fromEntries(getEntries(value)
+            .filter(([, v]) => v !== undefined)
+            .map(([k, v]) => [k, removeUndefined(v)]));
+    }
+    return value;
+};
+export const setFromPath = (data, path, value) => {
+    const [head, ...rest] = path;
+    if (head === undefined) {
+        return value;
+    }
+    if (data === null || data === undefined) {
+        const index = Number(head);
+        const isNumeric = isNaN(index) === false;
+        if (rest.length === 0) {
+            if (isNumeric === true) {
+                return Array.from({ length: index + 1 }, (_, i) => {
+                    return i === index ? value : undefined;
+                });
+            }
+            return { [head]: value };
+        }
+        if (isNumeric === true) {
+            return Array.from({ length: index + 1 }, (_, i) => {
+                return i === index ? setFromPath(undefined, rest, value) : undefined;
+            });
+        }
+        return { [head]: setFromPath(undefined, rest, value) };
+    }
+    if (data instanceof Array) {
+        const index = Number(head);
+        const maxIndex = Math.max(data.length, index + 1);
+        if (rest.length === 0) {
+            return Array.from({ length: maxIndex }, (_, i) => {
+                return i === index ? value : data[i];
+            });
+        }
+        return Array.from({ length: maxIndex }, (_, i) => i === index ? setFromPath(data[i], rest, value) : data[i]);
+    }
+    if (typeof data === "object") {
+        if (rest.length === 0) {
+            return { ...data, [head]: value };
+        }
+        return {
+            ...data,
+            [head]: setFromPath(data[head], rest, value),
+        };
+    }
+    return { [head]: setFromPath(undefined, rest, value) };
+};
+export const getFromPath = (data, path) => {
+    return path.reduce((acc, value) => {
+        if (acc === undefined || acc === null) {
+            return acc;
+        }
+        if (typeof acc === "object") {
+            return acc[value];
+        }
+        return undefined;
+    }, data);
+};
+export const equals = (data, otherData) => {
+    return fastDeepEqual(removeUndefined(data), removeUndefined(otherData));
+};
+export const getPathFromJavascriptPath = (value) => {
+    return value.split(/\.|\[|\]/g).filter(Boolean);
+};
+export const merge = (data, dataToMerge) => {
+    if (dataToMerge === undefined) {
+        return data;
+    }
+    if (data instanceof Array && dataToMerge instanceof Array) {
+        return [...data, ...dataToMerge];
+    }
+    if (data instanceof Object && dataToMerge instanceof Object) {
+        return {
+            ...data,
+            ...dataToMerge,
+        };
+    }
+    return dataToMerge;
+};

package/build/src/colors.d.ts

@@ -0,0 +1,2 @@
+export declare function hexToRgba(hex: string, alpha?: number): string;
+//# sourceMappingURL=colors.d.ts.map

package/build/src/colors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colors.d.ts","sourceRoot":"","sources":["../../src/colors.ts"],"names":[],"mappings":"AAAA,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,SAAI,UAiB/C"}

package/build/src/colors.js

@@ -0,0 +1,14 @@
+export function hexToRgba(hex, alpha = 1) {
+    let sanitizedHex = hex.replace("#", "");
+    if (sanitizedHex.length === 3) {
+        sanitizedHex = sanitizedHex
+            .split("")
+            .map((char) => char + char)
+            .join("");
+    }
+    const bigint = parseInt(sanitizedHex, 16);
+    const r = (bigint >> 16) & 255;
+    const g = (bigint >> 8) & 255;
+    const b = bigint & 255;
+    return `rgba(${r}, ${g}, ${b}, ${alpha})`;
+}

package/build/src/components.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+export declare const isComponentElement: <Props>(component: React.FC<Props>, element: React.ReactElement) => boolean;
+export declare const replaceComponentElements: <Props>(component: React.FC<Props>, replace: (props: Props, index: number, count: number) => React.ReactElement, children?: React.ReactNode) => React.ReactNode;
+export declare const filterComponentElements: <Props>(component: React.FC<Props>, children?: React.ReactNode) => React.ReactElement<Props, string | React.JSXElementConstructor<any>>[];

package/build/src/components.js

@@ -0,0 +1,45 @@
+import React from "react";
+export const isComponentElement = (component, element) => {
+    return component.name === element.type.name;
+};
+export const replaceComponentElements = (component, replace, children) => {
+    if (!children) {
+        return undefined;
+    }
+    const count = React.Children.count(children);
+    return React.Children.map(children, (child, index) => {
+        if (!React.isValidElement(child)) {
+            return child;
+        }
+        const childElement = child;
+        if (isComponentElement(component, childElement)) {
+            return replace(childElement.props, index, count);
+        }
+        if (childElement.props.children) {
+            return {
+                ...childElement,
+                props: {
+                    ...childElement.props,
+                    children: replaceComponentElements(component, replace, childElement.props.children),
+                },
+            };
+        }
+        return child;
+    });
+};
+export const filterComponentElements = (component, children) => {
+    const elements = [];
+    React.Children.forEach(children, (child) => {
+        if (!React.isValidElement(child)) {
+            return;
+        }
+        const childElement = child;
+        if (isComponentElement(component, childElement)) {
+            elements.push(childElement);
+        }
+        else if (childElement.props.children) {
+            elements.push(...filterComponentElements(component, childElement.props.children));
+        }
+    });
+    return elements;
+};

package/build/src/credits.d.ts

@@ -0,0 +1,7 @@
+export type CreditsCost = {
+    rate: number;
+    amount: number;
+    fixedPrice: number;
+};
+export declare const CREDITS_COSTS: Record<string, CreditsCost[]>;
+//# sourceMappingURL=credits.d.ts.map

package/build/src/credits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credits.d.ts","sourceRoot":"","sources":["../../src/credits.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAwFF,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,EAAE,CAGvD,CAAC"}