@cargo-ai/utils 1.0.4

package/build/src/hooks/useStepper.js

@@ -0,0 +1,136 @@
+import React from "react";
+export function useStepper(props) {
+    const { steps, initialStep, onStep } = props;
+    React.useEffect(() => {
+        checkUniqueKeys(steps);
+    }, [steps]);
+    const initialIndex = React.useMemo(() => {
+        const stepIndex = steps.findIndex((step) => {
+            return step.key === initialStep;
+        });
+        if (stepIndex === -1) {
+            return 0;
+        }
+        return stepIndex;
+    }, [initialStep, steps]);
+    const [stepIndex, setStepIndex] = React.useState(initialIndex);
+    const step = React.useMemo(() => {
+        return steps[stepIndex];
+    }, [stepIndex, steps]);
+    const isFirstStep = React.useMemo(() => {
+        return stepIndex === 0;
+    }, [stepIndex]);
+    const isLastStep = React.useMemo(() => {
+        return stepIndex === steps.length - 1;
+    }, [stepIndex, steps.length]);
+    const goToNextStep = React.useCallback(() => {
+        setStepIndex((currentStepIndex) => {
+            const nextIndex = Math.min(currentStepIndex + 1, steps.length - 1);
+            const nextStep = steps[nextIndex];
+            if (nextStep !== undefined && onStep !== undefined) {
+                onStep(nextStep, nextIndex);
+            }
+            return nextIndex;
+        });
+    }, [steps, onStep]);
+    const goToPreviousStep = React.useCallback(() => {
+        setStepIndex((currentStepIndex) => {
+            const previousIndex = Math.max(currentStepIndex - 1, 0);
+            const previousStep = steps[previousIndex];
+            if (previousStep !== undefined && onStep !== undefined) {
+                onStep(previousStep, previousIndex);
+            }
+            return previousIndex;
+        });
+    }, [steps, onStep]);
+    const goToStep = React.useCallback((key) => {
+        const index = steps.findIndex((curentStep) => {
+            return curentStep.key === key;
+        });
+        if (index === -1) {
+            return;
+        }
+        setStepIndex(index);
+        const indexStep = steps[index];
+        if (indexStep !== undefined && onStep !== undefined) {
+            onStep(indexStep, index);
+        }
+    }, [steps, onStep]);
+    const reset = React.useCallback(() => {
+        setStepIndex(initialIndex);
+        const initialIndexStep = steps[initialIndex];
+        if (initialIndexStep !== undefined && onStep !== undefined) {
+            onStep(initialIndexStep, initialIndex);
+        }
+    }, [initialIndex, steps, onStep]);
+    const ComponentWithInjectedProps = React.useMemo(() => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, react/display-name
+        return (props) => {
+            if (step === undefined) {
+                return null;
+            }
+            return React.createElement(step.Component, {
+                ...props,
+                step,
+                stepIndex,
+                isFirstStep,
+                isLastStep,
+                goToNextStep,
+                goToPreviousStep,
+                goToStep,
+                reset,
+            });
+        };
+    }, [
+        step,
+        goToStep,
+        isFirstStep,
+        isLastStep,
+        goToNextStep,
+        goToPreviousStep,
+        reset,
+        stepIndex,
+    ]);
+    const currentStep = React.useMemo(() => {
+        if (step === undefined) {
+            return undefined;
+        }
+        return {
+            ...step,
+            Component: ComponentWithInjectedProps,
+        };
+    }, [ComponentWithInjectedProps, step]);
+    const values = React.useMemo(() => {
+        return {
+            step: currentStep,
+            stepIndex,
+            isFirstStep,
+            isLastStep,
+            goToNextStep,
+            goToPreviousStep,
+            goToStep,
+            reset,
+        };
+    }, [
+        currentStep,
+        stepIndex,
+        isFirstStep,
+        isLastStep,
+        goToNextStep,
+        goToPreviousStep,
+        goToStep,
+        reset,
+    ]);
+    return values;
+}
+function checkUniqueKeys(steps) {
+    const keys = steps.map((step) => {
+        return step.key;
+    });
+    const duplicates = keys.filter((key, index) => {
+        return keys.indexOf(key) !== index;
+    });
+    if (duplicates.length > 0) {
+        throw new Error(`Duplicate step keys found: ${duplicates.join(", ")}`);
+    }
+}

package/build/src/hooks/useStorageState.d.ts

@@ -0,0 +1,12 @@
+import { type Storage } from "../storage.js";
+interface Options<T> {
+    key: string | undefined;
+    defaultValue: T;
+    storage?: Storage;
+    getValueOverrideAfterRestore?: (storedValue: T | undefined) => Promise<T> | T;
+    matchIsValueToBeStored?: (value: T) => boolean;
+}
+type SetStateSignature<T> = (value: T | ((currentValue: T) => T)) => void;
+type ReturnType<T> = [T, SetStateSignature<T>, boolean];
+export declare function useStorageState<T>(options: Options<T>): ReturnType<T>;
+export {};

package/build/src/hooks/useStorageState.js

@@ -0,0 +1,53 @@
+import React from "react";
+import { getItemFromStorage, setItemInStorage, } from "../storage.js";
+export function useStorageState(options) {
+    const { key, defaultValue, storage = "localStorage", getValueOverrideAfterRestore, matchIsValueToBeStored, } = options;
+    const [storedValue, setStoreValue] = React.useState(defaultValue);
+    const [hasRestoredValue, setHasRestoredValue] = React.useState(false);
+    const isRestoringValueRef = React.useRef(false);
+    const lastKeyRestoredRef = React.useRef(undefined);
+    const callbacksAfterRestoreRef = React.useRef([]);
+    React.useEffect(() => {
+        if (key === undefined || key === lastKeyRestoredRef.current) {
+            return;
+        }
+        setHasRestoredValue(false);
+        isRestoringValueRef.current = true;
+        lastKeyRestoredRef.current = key;
+        const updateRestoredStorageValue = async () => {
+            const storageValue = await getItemFromStorage(key, { storage });
+            const restoredValue = getValueOverrideAfterRestore !== undefined
+                ? await getValueOverrideAfterRestore(storageValue)
+                : storageValue;
+            if (restoredValue !== undefined) {
+                let restoredValueAfterCallbacks = restoredValue;
+                // eslint-disable-next-line no-restricted-syntax
+                for (const callback of callbacksAfterRestoreRef.current) {
+                    restoredValueAfterCallbacks = callback(restoredValueAfterCallbacks);
+                }
+                setStoreValue(restoredValueAfterCallbacks);
+            }
+            setHasRestoredValue(true);
+            isRestoringValueRef.current = false;
+            callbacksAfterRestoreRef.current = [];
+        };
+        updateRestoredStorageValue();
+    }, [defaultValue, getValueOverrideAfterRestore, key, storage]);
+    const setValue = React.useCallback((value) => {
+        if (isRestoringValueRef.current === true) {
+            callbacksAfterRestoreRef.current.push(value instanceof Function ? value : () => value);
+            return;
+        }
+        const valueToStore = value instanceof Function ? value(storedValue) : value;
+        setStoreValue(valueToStore);
+        if (key !== undefined &&
+            (matchIsValueToBeStored === undefined ||
+                matchIsValueToBeStored(valueToStore))) {
+            setItemInStorage(key, valueToStore, { storage });
+        }
+    }, [key, storedValue, matchIsValueToBeStored, storage]);
+    const returnValue = React.useMemo(() => {
+        return [storedValue, setValue, hasRestoredValue];
+    }, [storedValue, setValue, hasRestoredValue]);
+    return returnValue;
+}

package/build/src/hooks/useVideoPlayer/VideoManager.d.ts

@@ -0,0 +1,18 @@
+export declare class VideoManager {
+    private static instance;
+    private videoElement;
+    private isPlaying;
+    private hasStarted;
+    private currentTime;
+    private constructor();
+    static getInstance(): VideoManager;
+    setVideoElement(video: HTMLVideoElement): void;
+    getVideoElement(): HTMLVideoElement | null;
+    play(): void;
+    pause(): void;
+    saveVideoState(): void;
+    restoreVideoState(): void;
+    releaseVideo(): void;
+    isSameVideo(video: HTMLVideoElement): boolean;
+    getHasStarted(): boolean;
+}

package/build/src/hooks/useVideoPlayer/VideoManager.js

@@ -0,0 +1,72 @@
+// Singleton to ensure unique video element
+export class VideoManager {
+    static instance = null;
+    videoElement = null;
+    isPlaying = false;
+    hasStarted = false;
+    currentTime = 0;
+    constructor() { }
+    static getInstance() {
+        if (VideoManager.instance === null) {
+            VideoManager.instance = new VideoManager();
+        }
+        return VideoManager.instance;
+    }
+    setVideoElement(video) {
+        if (this.videoElement !== null && this.videoElement !== video) {
+            this.saveVideoState();
+            this.releaseVideo();
+        }
+        this.videoElement = video;
+        this.restoreVideoState();
+    }
+    getVideoElement() {
+        return this.videoElement;
+    }
+    play() {
+        if (this.videoElement === null) {
+            return;
+        }
+        this.videoElement.play();
+        this.isPlaying = true;
+        this.hasStarted = true;
+    }
+    pause() {
+        if (this.videoElement === null) {
+            return;
+        }
+        this.videoElement.pause();
+        this.isPlaying = false;
+    }
+    saveVideoState() {
+        if (this.videoElement === null) {
+            return;
+        }
+        this.currentTime = this.videoElement.currentTime;
+        this.isPlaying = this.videoElement.paused === false;
+        this.hasStarted = this.isPlaying || this.currentTime > 0;
+    }
+    restoreVideoState() {
+        if (this.videoElement === null) {
+            return;
+        }
+        this.videoElement.currentTime = this.currentTime;
+        if (this.isPlaying === true && this.videoElement.paused === true) {
+            this.videoElement.play();
+        }
+    }
+    releaseVideo() {
+        if (this.videoElement === null) {
+            return;
+        }
+        this.pause();
+        this.videoElement = null;
+        this.hasStarted = false;
+    }
+    isSameVideo(video) {
+        return this.videoElement === video;
+    }
+    getHasStarted() {
+        return this.hasStarted;
+    }
+}

package/build/src/hooks/useVideoPlayer/index.d.ts

@@ -0,0 +1 @@
+export { useVideoPlayer } from "./useVideoPlayer.js";

package/build/src/hooks/useVideoPlayer/index.js

@@ -0,0 +1 @@
+export { useVideoPlayer } from "./useVideoPlayer.js";

package/build/src/hooks/useVideoPlayer/useVideoPlayer.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+import { VideoManager } from "./VideoManager.js";
+type UsevideoPlayerValues = readonly [
+    React.MutableRefObject<HTMLVideoElement | null>,
+    {
+        readonly isPlaying: boolean;
+        readonly hasStarted: boolean;
+        readonly onPlayback: () => void;
+        readonly onVideoEnd: () => void;
+        readonly videoDuration: number | null;
+        readonly videoManager: VideoManager;
+    }
+];
+export declare function useVideoPlayer(): UsevideoPlayerValues;
+export {};

package/build/src/hooks/useVideoPlayer/useVideoPlayer.js

@@ -0,0 +1,96 @@
+import React from "react";
+import { VideoManager } from "./VideoManager.js";
+export function useVideoPlayer() {
+    const videoRef = React.useRef(null);
+    const videoManagerRef = React.useRef(VideoManager.getInstance());
+    const [isPlaying, setIsPlaying] = React.useState(false);
+    const [hasStarted, setHasStarted] = React.useState(videoManagerRef.current.getHasStarted());
+    const [videoDuration, setVideoDuration] = React.useState(null);
+    const onPlayback = React.useCallback(() => {
+        const videoElement = videoRef.current;
+        if (videoElement === null) {
+            return;
+        }
+        const videoManager = videoManagerRef.current;
+        videoManager.setVideoElement(videoElement);
+        if (videoElement.paused === true || videoElement.ended === true) {
+            videoManager.play();
+            setIsPlaying(true);
+            setHasStarted(true);
+        }
+        else {
+            videoManager.pause();
+            setIsPlaying(false);
+        }
+    }, []);
+    const onVideoEnd = React.useCallback(() => {
+        const videoElement = videoRef.current;
+        if (videoElement === null) {
+            return;
+        }
+        const videoManager = videoManagerRef.current;
+        videoManager.releaseVideo();
+        videoManager.saveVideoState();
+        videoManager.pause();
+        setIsPlaying(false);
+        setHasStarted(false);
+    }, []);
+    React.useEffect(() => {
+        const videoElement = videoRef.current;
+        if (videoElement === null) {
+            return undefined;
+        }
+        const videoManager = videoManagerRef.current;
+        if (videoManager.isSameVideo(videoElement) === true) {
+            videoManager.restoreVideoState();
+            setHasStarted(videoManager.getHasStarted());
+            setIsPlaying(videoElement.paused === false);
+        }
+        else {
+            videoElement.currentTime = 0;
+            setHasStarted(false);
+            setIsPlaying(false);
+        }
+        const handlePlay = () => {
+            setIsPlaying(true);
+            setHasStarted(true);
+        };
+        const handlePause = () => {
+            setIsPlaying(false);
+        };
+        const handleEnded = () => {
+            setIsPlaying(false);
+            setHasStarted(false);
+        };
+        const handleLoadedMetadata = () => {
+            setVideoDuration(videoElement.duration);
+        };
+        videoElement.addEventListener("play", handlePlay);
+        videoElement.addEventListener("pause", handlePause);
+        videoElement.addEventListener("ended", handleEnded);
+        videoElement.addEventListener("loadedmetadata", handleLoadedMetadata);
+        return () => {
+            videoElement.removeEventListener("play", handlePlay);
+            videoElement.removeEventListener("pause", handlePause);
+            videoElement.removeEventListener("ended", handleEnded);
+            videoElement.removeEventListener("loadedmetadata", handleLoadedMetadata);
+            const videoManager = VideoManager.getInstance();
+            if (videoManager.isSameVideo(videoElement) === true) {
+                videoManager.saveVideoState();
+            }
+        };
+    }, []);
+    return React.useMemo(() => {
+        return [
+            videoRef,
+            {
+                isPlaying,
+                hasStarted,
+                onPlayback,
+                onVideoEnd,
+                videoDuration,
+                videoManager: videoManagerRef.current,
+            },
+        ];
+    }, [hasStarted, isPlaying, onPlayback, onVideoEnd, videoDuration]);
+}

package/build/src/hooks/useWillUnmountEffect.d.ts

@@ -0,0 +1 @@
+export declare const useWillUnmountEffect: (cleanupCallback?: () => void) => void;

package/build/src/hooks/useWillUnmountEffect.js

@@ -0,0 +1,8 @@
+import React from "react";
+export const useWillUnmountEffect = (cleanupCallback = () => { }) => {
+    const callbackRef = React.useRef(cleanupCallback);
+    callbackRef.current = cleanupCallback; // always up to date
+    React.useEffect(() => {
+        return () => callbackRef.current();
+    }, []);
+};

package/build/src/index.d.ts

@@ -0,0 +1,27 @@
+export * from "./array.js";
+export * from "./base64.js";
+export * from "./bytes.js";
+export * from "./collection.js";
+export * from "./collection/index.js";
+export * from "./colors.js";
+export * from "./credits.js";
+export * from "./cron.js";
+export * from "./date/index.js";
+export * from "./delay.js";
+export * from "./expression/index.js";
+export * from "./gclid.js";
+export * from "./json/index.js";
+export * from "./jsonSchema/index.js";
+export * from "./number/index.js";
+export * from "./poll.js";
+export * from "./random.js";
+export * from "./schema.js";
+export * from "./searchInTree.js";
+export * from "./storage.js";
+export * from "./string.js";
+export * from "./string/index.js";
+export * from "./types.js";
+export * from "./user.js";
+export * from "./validation/index.js";
+export * from "./zod/index.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,uBAAuB,CAAC;AACtC,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC;AAClC,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC"}

package/build/src/index.js

@@ -0,0 +1,26 @@
+export * from "./array.js";
+export * from "./base64.js";
+export * from "./bytes.js";
+export * from "./collection.js";
+export * from "./collection/index.js";
+export * from "./colors.js";
+export * from "./credits.js";
+export * from "./cron.js";
+export * from "./date/index.js";
+export * from "./delay.js";
+export * from "./expression/index.js";
+export * from "./gclid.js";
+export * from "./json/index.js";
+export * from "./jsonSchema/index.js";
+export * from "./number/index.js";
+export * from "./poll.js";
+export * from "./random.js";
+export * from "./schema.js";
+export * from "./searchInTree.js";
+export * from "./storage.js";
+export * from "./string.js";
+export * from "./string/index.js";
+export * from "./types.js";
+export * from "./user.js";
+export * from "./validation/index.js";
+export * from "./zod/index.js";

package/build/src/integration.d.ts

@@ -0,0 +1,14 @@
+import type { JsonSchema } from "json.js";
+type IntegrationAction = {
+    name: string;
+    config: {
+        jsonSchema: JsonSchema;
+    };
+};
+export declare const INTEGRATION_ACTION_PROPERTIES: {
+    objectType: string;
+    operation: string;
+};
+export declare const getIntegrationActionName: (integrationActionSlug: string, integrationAction: IntegrationAction, config: Record<string, unknown>) => string;
+export {};
+//# sourceMappingURL=integration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"integration.d.ts","sourceRoot":"","sources":["../../src/integration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAG1C,KAAK,iBAAiB,GAAG;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE;QACN,UAAU,EAAE,UAAU,CAAC;KACxB,CAAC;CACH,CAAC;AAEF,eAAO,MAAM,6BAA6B;;;CAGzC,CAAC;AAEF,eAAO,MAAM,wBAAwB,0BACZ,MAAM,qBACV,iBAAiB,UAC5B,OAAO,MAAM,EAAE,OAAO,CAAC,KAC9B,MAcF,CAAC"}

package/build/src/integration.js

@@ -0,0 +1,72 @@
+import pluralize from "pluralize";
+export const INTEGRATION_ACTION_PROPERTIES = {
+    objectType: "objectType",
+    operation: "action",
+};
+export const getIntegrationActionName = (integrationActionSlug, integrationAction, config) => {
+    const operationName = getIntegrationActionOperationName(integrationActionSlug, integrationAction, config[INTEGRATION_ACTION_PROPERTIES.operation]);
+    const objectTypeName = getIntegrationActionObjectTypeName(integrationActionSlug, integrationAction, config[INTEGRATION_ACTION_PROPERTIES.objectType]);
+    return `${operationName}${objectTypeName !== undefined ? ` ${objectTypeName}` : ""}`;
+};
+const getIntegrationActionOperationName = (integrationActionSlug, integrationAction, operation) => {
+    if (operation === undefined) {
+        return integrationAction.name;
+    }
+    if (integrationAction.config.jsonSchema.properties === undefined) {
+        return integrationAction.name;
+    }
+    const operationJsonSchema = integrationAction.config.jsonSchema.properties[INTEGRATION_ACTION_PROPERTIES.operation];
+    if (operationJsonSchema === undefined ||
+        operationJsonSchema.oneOf === undefined) {
+        return integrationAction.name;
+    }
+    const operationEnumJsonSchema = operationJsonSchema.oneOf.find((jsonSchema) => {
+        return jsonSchema.const === operation;
+    });
+    if (operationEnumJsonSchema === undefined) {
+        return integrationAction.name;
+    }
+    if (integrationActionSlug === "associate") {
+        if (operation === "add") {
+            return "Add to";
+        }
+        if (operation === "remove") {
+            return "Remove from";
+        }
+        if (operation === "delete") {
+            return "Remove from";
+        }
+        if (operation === "create") {
+            return "Create association";
+        }
+        if (operation === "delete") {
+            return "Delete association";
+        }
+    }
+    return operationEnumJsonSchema.title !== undefined
+        ? operationEnumJsonSchema.title
+        : integrationAction.name;
+};
+const getIntegrationActionObjectTypeName = (integrationActionSlug, integrationAction, objectType) => {
+    if (integrationAction.config.jsonSchema.properties === undefined) {
+        return undefined;
+    }
+    const operationJsonSchema = integrationAction.config.jsonSchema.properties[INTEGRATION_ACTION_PROPERTIES.objectType];
+    if (operationJsonSchema === undefined ||
+        operationJsonSchema.oneOf === undefined) {
+        return undefined;
+    }
+    let jsonSchemaEnum = objectType !== undefined
+        ? operationJsonSchema.oneOf.find((jsonSchema) => jsonSchema.const === objectType)
+        : undefined;
+    if (jsonSchemaEnum === undefined) {
+        jsonSchemaEnum = operationJsonSchema.oneOf.find((jsonSchema) => jsonSchema.type === "string");
+    }
+    if (jsonSchemaEnum === undefined || jsonSchemaEnum.title === undefined) {
+        return undefined;
+    }
+    if (integrationActionSlug === "search" || integrationActionSlug === "count") {
+        return pluralize.plural(jsonSchemaEnum.title).toLowerCase();
+    }
+    return pluralize.singular(jsonSchemaEnum.title).toLowerCase();
+};

package/build/src/json/castToJsonType.d.ts

@@ -0,0 +1,5 @@
+import type { JsonType } from "./types.js";
+export declare const castToJsonType: (value: unknown, type: JsonType, options?: {
+    timezone?: string;
+}) => unknown;
+//# sourceMappingURL=castToJsonType.d.ts.map

package/build/src/json/castToJsonType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"castToJsonType.d.ts","sourceRoot":"","sources":["../../../src/json/castToJsonType.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,cAAc,UAClB,OAAO,QACR,QAAQ,YACL;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,KAC7B,OAoEF,CAAC"}

package/build/src/json/castToJsonType.js

@@ -0,0 +1,58 @@
+import { getDate } from "../date/getDate.js";
+export const castToJsonType = (value, type, options = {}) => {
+    const { timezone = "UTC" } = options;
+    try {
+        if (value === undefined) {
+            return undefined;
+        }
+        if (value === null) {
+            return null;
+        }
+        if (type === "object") {
+            if (typeof value === "object") {
+                return value;
+            }
+            try {
+                return JSON.parse(value);
+            }
+            catch {
+                return value;
+            }
+        }
+        if (type === "array") {
+            if (Array.isArray(value)) {
+                return value;
+            }
+            try {
+                const parsedValue = JSON.parse(value);
+                if (Array.isArray(parsedValue) === false) {
+                    return null;
+                }
+                return parsedValue;
+            }
+            catch {
+                return null;
+            }
+        }
+        if (type === "string") {
+            return String(value);
+        }
+        if (type === "boolean") {
+            return Boolean(value);
+        }
+        if (type === "number") {
+            const number = Number(value);
+            if (isNaN(number)) {
+                return null;
+            }
+            return number;
+        }
+        if (type === "date") {
+            return getDate(value, { timezone });
+        }
+        return value;
+    }
+    catch {
+        return null;
+    }
+};

package/build/src/json/cleanJson.d.ts

@@ -0,0 +1,3 @@
+import { type Schema } from "jsonschema";
+export declare const cleanJson: (jsonSchema: Schema, value: unknown) => unknown;
+//# sourceMappingURL=cleanJson.d.ts.map

package/build/src/json/cleanJson.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanJson.d.ts","sourceRoot":"","sources":["../../../src/json/cleanJson.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,YAAY,CAAC;AAIzC,eAAO,MAAM,SAAS,eAAgB,MAAM,SAAS,OAAO,KAAG,OAuB9D,CAAC"}

package/build/src/json/cleanJson.js

@@ -0,0 +1,18 @@
+import { getEntries } from "../collection.js";
+export const cleanJson = (jsonSchema, value) => {
+    if (jsonSchema.type === "object" &&
+        jsonSchema.properties !== undefined &&
+        typeof value === "object" &&
+        value !== null) {
+        return getEntries(jsonSchema.properties).reduce((out, [key, subJsonSchema]) => {
+            if (key in value) {
+                return {
+                    ...out,
+                    [key]: cleanJson(subJsonSchema, value[key]),
+                };
+            }
+            return out;
+        }, {});
+    }
+    return value;
+};