@cargo-ai/utils 1.0.4

package/build/src/expression/jsonSchema.js

@@ -0,0 +1,85 @@
+export const expressionJsonSchema = {
+    type: "object",
+    title: "Expression",
+    properties: {
+        kind: {
+            type: "string",
+            enum: ["jsExpression", "templateExpression"],
+        },
+        expression: {
+            type: "string",
+            minLength: 1,
+        },
+        instructTo: {
+            type: ["string"],
+            enum: ["ai", "none"],
+        },
+        fromRecipe: {
+            type: "boolean",
+        },
+    },
+    allOf: [
+        {
+            if: {
+                properties: {
+                    fromRecipe: {
+                        const: true,
+                    },
+                },
+            },
+            then: {
+                properties: {
+                    recipe: {
+                        type: "object",
+                        properties: {
+                            uuid: {
+                                type: "string",
+                            },
+                            version: {
+                                type: "number",
+                            },
+                            variables: {
+                                type: "object",
+                                additionalProperties: true,
+                            },
+                        },
+                        required: ["uuid", "version", "variables"],
+                    },
+                },
+                required: ["recipe"],
+            },
+        },
+    ],
+    required: ["kind", "expression", "instructTo", "fromRecipe"],
+};
+export const jsonSchemaDefinitions = {
+    expression: expressionJsonSchema,
+    templateExpression: { type: "string" },
+    multi: {
+        anyOf: [
+            {
+                type: "array",
+                items: { type: "string" },
+            },
+            { type: "string" },
+        ],
+        minItems: 1,
+        uniqueItems: true,
+    },
+    encryption: {
+        type: "object",
+        properties: {
+            type: {
+                type: "string",
+                enum: ["encryption"],
+            },
+            isEncrypted: {
+                type: "boolean",
+            },
+            value: {
+                type: "string",
+            },
+        },
+        required: ["type", "isEncrypted", "value"],
+    },
+};

package/build/src/expression/matchIsExpression.d.ts

@@ -0,0 +1,2 @@
+export declare const matchIsExpression: (value: any) => boolean;
+//# sourceMappingURL=matchIsExpression.d.ts.map

package/build/src/expression/matchIsExpression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchIsExpression.d.ts","sourceRoot":"","sources":["../../../src/expression/matchIsExpression.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,iBAAiB,UAAW,GAAG,KAAG,OAQ9C,CAAC"}

package/build/src/expression/matchIsExpression.js

@@ -0,0 +1,10 @@
+import { validate as jsonSchemaValidate } from "jsonschema";
+import { expressionJsonSchema } from "./jsonSchema.js";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const matchIsExpression = (value) => {
+    if (value === undefined || value === null) {
+        return false;
+    }
+    const { valid: isValid } = jsonSchemaValidate(value, expressionJsonSchema);
+    return isValid === true;
+};

package/build/src/expression/matchIsExpressionObject.d.ts

@@ -0,0 +1,2 @@
+export declare const matchIsExpressionObject: (value: any) => boolean;
+//# sourceMappingURL=matchIsExpressionObject.d.ts.map

package/build/src/expression/matchIsExpressionObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchIsExpressionObject.d.ts","sourceRoot":"","sources":["../../../src/expression/matchIsExpressionObject.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,uBAAuB,UAAW,GAAG,KAAG,OAQpD,CAAC"}

package/build/src/expression/matchIsExpressionObject.js

@@ -0,0 +1,10 @@
+import { validate as jsonSchemaValidate } from "jsonschema";
+import { expressionJsonSchema } from "../jsonSchema.js";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const matchIsExpressionObject = (value) => {
+    if (value === undefined || value === null) {
+        return false;
+    }
+    const { valid: isValid } = jsonSchemaValidate(value, expressionJsonSchema);
+    return isValid === true;
+};

package/build/src/expression/matchIsExpressionString.d.ts

@@ -0,0 +1,2 @@
+export declare const matchIsExpressionString: (value: string) => boolean;
+//# sourceMappingURL=matchIsExpressionString.d.ts.map

package/build/src/expression/matchIsExpressionString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchIsExpressionString.d.ts","sourceRoot":"","sources":["../../../src/expression/matchIsExpressionString.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,uBAAuB,UAAW,MAAM,KAAG,OAEvD,CAAC"}

package/build/src/expression/matchIsExpressionString.js

@@ -0,0 +1,4 @@
+const EXPRESSION_REGEX = /{{.*}}/;
+export const matchIsExpressionString = (value) => {
+    return EXPRESSION_REGEX.test(value);
+};

package/build/src/gclid.d.ts

@@ -0,0 +1,4 @@
+export declare const persistGclid: () => void;
+export declare const getGclid: () => string | undefined;
+export declare const appendGclidToUrl: (url: string) => string;
+//# sourceMappingURL=gclid.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gclid.d.ts","sourceRoot":"","sources":["../../src/gclid.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY,YAWxB,CAAC;AAEF,eAAO,MAAM,QAAQ,0BAQpB,CAAC;AAEF,eAAO,MAAM,gBAAgB,QAAS,MAAM,WAgB3C,CAAC"}

package/build/src/gclid.js

@@ -0,0 +1,30 @@
+const GCLID = "gclid";
+export const persistGclid = () => {
+    if (typeof window === "undefined") {
+        return;
+    }
+    const params = new URLSearchParams(window.location.search);
+    const gclid = params.get(GCLID);
+    if (gclid !== null) {
+        window.localStorage.setItem(GCLID, gclid);
+    }
+};
+export const getGclid = () => {
+    if (typeof window === "undefined") {
+        return undefined;
+    }
+    const gclid = window.localStorage.getItem(GCLID);
+    return gclid !== null ? gclid : undefined;
+};
+export const appendGclidToUrl = (url) => {
+    if (typeof window === "undefined") {
+        return url;
+    }
+    const gclid = window.localStorage.getItem(GCLID);
+    if (gclid === null) {
+        return url;
+    }
+    const parsedUrl = new URL(url);
+    parsedUrl.searchParams.set(GCLID, gclid);
+    return parsedUrl.toString();
+};

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

@@ -0,0 +1,12 @@
+export * from "./useClickOutside.js";
+export { useCountAnimation } from "./useCountAnimation.js";
+export { useDeviceType } from "./useDeviceType.js";
+export { useEventListener } from "./useEventListener.js";
+export * from "./useHeight.js";
+export { usePictureInPicture } from "./usePictureInPicture.js";
+export * from "./useResizeObserver.js";
+export { useScrollPosition } from "./useScrollPosition.js";
+export * from "./useStepper.js";
+export * from "./useStorageState.js";
+export { useVideoPlayer } from "./useVideoPlayer/index.js";
+export * from "./useWillUnmountEffect.js";

package/build/src/hooks/index.js

@@ -0,0 +1,12 @@
+export * from "./useClickOutside.js";
+export { useCountAnimation } from "./useCountAnimation.js";
+export { useDeviceType } from "./useDeviceType.js";
+export { useEventListener } from "./useEventListener.js";
+export * from "./useHeight.js";
+export { usePictureInPicture } from "./usePictureInPicture.js";
+export * from "./useResizeObserver.js";
+export { useScrollPosition } from "./useScrollPosition.js";
+export * from "./useStepper.js";
+export * from "./useStorageState.js";
+export { useVideoPlayer } from "./useVideoPlayer/index.js";
+export * from "./useWillUnmountEffect.js";

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

@@ -0,0 +1,4 @@
+import React from "react";
+type Ref<T extends HTMLElement> = React.RefObject<T | null> | T | null;
+export declare const useClickOutside: <T extends HTMLElement>(refOrRefs: Ref<T> | Ref<T>[], handle: (event: MouseEvent) => void) => void;
+export {};

package/build/src/hooks/useClickOutside.js

@@ -0,0 +1,42 @@
+import React from "react";
+export const useClickOutside = (refOrRefs, handle) => {
+    React.useEffect(() => {
+        if (refOrRefs === null ||
+            (Array.isArray(refOrRefs) && refOrRefs.length === 0)) {
+            return;
+        }
+        const handleClickOutside = (event) => {
+            const hasClickedOutsideRef = Array.isArray(refOrRefs)
+                ? refOrRefs.every((ref) => {
+                    return matchHasClickedOutsideRef(event, ref);
+                })
+                : matchHasClickedOutsideRef(event, refOrRefs);
+            if (hasClickedOutsideRef === true) {
+                handle(event);
+            }
+        };
+        document.addEventListener("mouseup", handleClickOutside);
+        return () => {
+            document.removeEventListener("mouseup", handleClickOutside);
+        };
+    }, [refOrRefs, handle]);
+};
+const matchHasClickedOutsideRef = (event, ref) => {
+    if (ref === null) {
+        return false;
+    }
+    const element = ref instanceof HTMLElement ? ref : ref.current;
+    if (element === null) {
+        return false;
+    }
+    if (event.target === null) {
+        return false;
+    }
+    const { clientX: x, clientY: y } = event;
+    const { height: refHeight, width: refWidth, top: refTop, left: refLeft, } = element.getBoundingClientRect();
+    const isClickInsideElement = x >= refLeft &&
+        x <= refLeft + refWidth &&
+        y >= refTop &&
+        y <= refTop + refHeight;
+    return isClickInsideElement === false;
+};

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

@@ -0,0 +1 @@
+export declare function useCountAnimation(targetValue: number, triggerKey?: string | number | Date): number;

package/build/src/hooks/useCountAnimation.js

@@ -0,0 +1,30 @@
+import React from "react";
+export function useCountAnimation(targetValue, triggerKey) {
+    const [currentValue, setCurrentValue] = React.useState(0);
+    const previousKey = React.useRef(triggerKey);
+    const isFirstMount = React.useRef(true);
+    React.useEffect(() => {
+        if (isFirstMount.current === true) {
+            isFirstMount.current = false;
+        }
+        else if (triggerKey === undefined || previousKey.current === triggerKey) {
+            setCurrentValue(targetValue);
+            return;
+        }
+        previousKey.current = triggerKey;
+        const start = Date.now();
+        const duration = 300;
+        const step = () => {
+            const progress = (Date.now() - start) / duration;
+            if (progress < 1) {
+                setCurrentValue(Math.floor(progress * targetValue));
+                requestAnimationFrame(step);
+            }
+            else {
+                setCurrentValue(targetValue);
+            }
+        };
+        requestAnimationFrame(step);
+    }, [targetValue, triggerKey]);
+    return currentValue;
+}

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

@@ -0,0 +1,2 @@
+export type DeviceType = "mobile" | "tablet" | "desktop" | "largeScreen";
+export declare function useDeviceType(): DeviceType | null;

package/build/src/hooks/useDeviceType.js

@@ -0,0 +1,50 @@
+"use client";
+import { useEffect, useSyncExternalStore } from "react";
+import { useEventListener } from "./useEventListener.js";
+const sizes = {
+    sm: 640,
+    md: 768,
+    lg: 1024,
+    xl: 1280,
+    "2xl": 1536,
+};
+function getDeviceType(width, height) {
+    const isLandscape = width > height;
+    const 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() {
+    const listeners = new Set();
+    let currentDeviceType = null;
+    const updateDeviceType = () => {
+        const newDeviceType = getDeviceType(window.innerWidth, window.innerHeight);
+        if (currentDeviceType !== newDeviceType) {
+            currentDeviceType = newDeviceType;
+            listeners.forEach((listener) => listener());
+        }
+    };
+    return {
+        updateDeviceType,
+        subscribe: (callback) => {
+            listeners.add(callback);
+            return () => listeners.delete(callback);
+        },
+        getSnapshot: () => currentDeviceType,
+        getServerSnapshot: () => currentDeviceType,
+    };
+}
+const deviceTypeStore = createDeviceTypeStore();
+export function useDeviceType() {
+    const { subscribe, getSnapshot, getServerSnapshot, updateDeviceType } = deviceTypeStore;
+    useEffect(() => updateDeviceType(), [updateDeviceType]);
+    useEventListener("resize", updateDeviceType);
+    return useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+}

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

@@ -0,0 +1,6 @@
+import type { RefObject } from "react";
+declare function useEventListener<K extends keyof MediaQueryListEventMap>(eventName: K, handler: (event: MediaQueryListEventMap[K]) => void, element?: RefObject<MediaQueryList>, options?: boolean | AddEventListenerOptions): void;
+declare function useEventListener<K extends keyof WindowEventMap>(eventName: K, handler: (event: WindowEventMap[K]) => void, element?: undefined, options?: boolean | AddEventListenerOptions): void;
+declare function useEventListener<K extends keyof HTMLElementEventMap, T extends HTMLElement = HTMLDivElement>(eventName: K, handler: (event: HTMLElementEventMap[K]) => void, element?: RefObject<T>, options?: boolean | AddEventListenerOptions): void;
+declare function useEventListener<K extends keyof DocumentEventMap>(eventName: K, handler: (event: DocumentEventMap[K]) => void, element?: RefObject<Document>, options?: boolean | AddEventListenerOptions): void;
+export { useEventListener };

package/build/src/hooks/useEventListener.js

@@ -0,0 +1,23 @@
+"use client";
+import { useEffect, useRef } from "react";
+function useEventListener(eventName, handler, element, options) {
+    // Create a ref that stores handler
+    const savedHandler = useRef(handler);
+    useEffect(() => {
+        savedHandler.current = handler;
+    }, [handler]);
+    useEffect(() => {
+        // Define the listening target
+        const targetElement = element?.current ?? window;
+        if (!(targetElement && targetElement.addEventListener))
+            return;
+        // Create event listener that calls handler function stored in ref
+        const listener = (event) => savedHandler.current(event);
+        targetElement.addEventListener(eventName, listener, options);
+        // Remove event listener on cleanup
+        return () => {
+            targetElement.removeEventListener(eventName, listener, options);
+        };
+    }, [eventName, element, options]);
+}
+export { useEventListener };

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

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const useHeight: <T extends HTMLElement>() => [React.MutableRefObject<T | null>, number];

package/build/src/hooks/useHeight.js

@@ -0,0 +1,20 @@
+import React from "react";
+export const useHeight = () => {
+    const ref = React.useRef(null);
+    const [height, setHeight] = React.useState(0);
+    const heightRef = React.useRef(height);
+    const [resizeObserver] = React.useState(() => new ResizeObserver(() => {
+        if (ref.current && heightRef.current !== ref.current.offsetHeight) {
+            heightRef.current = ref.current.offsetHeight;
+            setHeight(ref.current.offsetHeight);
+        }
+    }));
+    React.useLayoutEffect(() => {
+        if (ref.current) {
+            setHeight(ref.current.offsetHeight);
+            resizeObserver.observe(ref.current, {});
+        }
+        return () => resizeObserver.disconnect();
+    }, [resizeObserver]);
+    return [ref, height];
+};

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

@@ -0,0 +1,9 @@
+import React from "react";
+type UsePictureInPictureValues = {
+    isPipAvailable: boolean;
+    isPipActive: boolean;
+    enterPip: () => Promise<void>;
+    exitPip: () => Promise<void>;
+};
+export declare function usePictureInPicture(videoRef: React.MutableRefObject<HTMLVideoElement | null>): UsePictureInPictureValues;
+export {};

package/build/src/hooks/usePictureInPicture.js

@@ -0,0 +1,60 @@
+import React from "react";
+export function usePictureInPicture(videoRef) {
+    const [isPipAvailable, setIsPipAvailable] = React.useState(false);
+    const [isPipActive, setIsPipActive] = React.useState(false);
+    const pipWindowRef = React.useRef(null);
+    React.useEffect(() => {
+        setIsPipAvailable(document.pictureInPictureEnabled === true);
+    }, []);
+    const enterPip = React.useCallback(async () => {
+        const videoElement = videoRef.current;
+        if (videoElement === null || isPipAvailable === false) {
+            return;
+        }
+        try {
+            pipWindowRef.current = await videoElement.requestPictureInPicture();
+            setIsPipActive(true);
+            videoElement.play();
+        }
+        catch (error) {
+            console.error("Failed to enter Picture-in-Picture mode:", { error });
+        }
+    }, [isPipAvailable, videoRef]);
+    const exitPip = React.useCallback(async () => {
+        if (document.pictureInPictureElement === null) {
+            return;
+        }
+        try {
+            await document.exitPictureInPicture();
+            setIsPipActive(false);
+        }
+        catch (error) {
+            console.error("Failed to exit Picture-in-Picture mode:", { error });
+        }
+    }, []);
+    const handlePipChange = React.useCallback(() => {
+        const isPipActive = document.pictureInPictureElement === videoRef.current;
+        setIsPipActive(isPipActive);
+    }, [videoRef]);
+    React.useEffect(() => {
+        const videoElement = videoRef.current;
+        if (videoElement === null) {
+            return;
+        }
+        videoElement.addEventListener("enterpictureinpicture", handlePipChange);
+        videoElement.addEventListener("leavepictureinpicture", handlePipChange);
+        return () => {
+            videoElement.removeEventListener("enterpictureinpicture", handlePipChange);
+            videoElement.removeEventListener("leavepictureinpicture", handlePipChange);
+        };
+    }, [handlePipChange, videoRef]);
+    const values = React.useMemo(() => {
+        return {
+            isPipAvailable,
+            isPipActive,
+            enterPip,
+            exitPip,
+        };
+    }, [enterPip, exitPip, isPipActive, isPipAvailable]);
+    return values;
+}

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

@@ -0,0 +1,4 @@
+import React from "react";
+type Callback = (entry: DOMRectReadOnly) => void;
+export declare function useResizeObserver<T extends Element>(ref: React.MutableRefObject<T | null> | T | null, callback: Callback | undefined): void;
+export {};

package/build/src/hooks/useResizeObserver.js

@@ -0,0 +1,31 @@
+import { ResizeObserver } from "@juggle/resize-observer";
+import React from "react";
+export function useResizeObserver(ref, callback) {
+    React.useEffect(() => {
+        const element = ref === null ? null : "current" in ref ? ref.current : ref;
+        if (element === null || callback === undefined) {
+            return;
+        }
+        const observer = new ResizeObserver((entries) => {
+            // https://stackoverflow.com/questions/49384120/resizeobserver-loop-limit-exceeded/58701523#58701523
+            requestAnimationFrame(() => {
+                if (!Array.isArray(entries) || !entries.length) {
+                    return;
+                }
+                // By the time the animation frame fires, the DOM might have be unmounted already
+                if (element === null || callback === undefined) {
+                    return;
+                }
+                const entry = entries[0];
+                if (entry === undefined) {
+                    return;
+                }
+                callback(entry.contentRect);
+            });
+        });
+        observer.observe(element);
+        return () => {
+            observer.disconnect();
+        };
+    }, [ref, callback]);
+}

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

@@ -0,0 +1,5 @@
+import React from "react";
+export declare function useScrollPosition<T extends HTMLElement = HTMLElement>(): readonly [React.MutableRefObject<T | null>, {
+    readonly isScrollAtStart: boolean;
+    readonly isScrollAtEnd: boolean;
+}];

package/build/src/hooks/useScrollPosition.js

@@ -0,0 +1,18 @@
+import React from "react";
+import { useEventListener } from "./useEventListener.js";
+export function useScrollPosition() {
+    const elementRef = React.useRef(null);
+    const [isScrollAtStart, setIsScrollAtStart] = React.useState(true);
+    const [isScrollAtEnd, setIsScrollAtEnd] = React.useState(false);
+    const onScroll = React.useCallback(() => {
+        const element = elementRef.current;
+        if (element === null) {
+            return;
+        }
+        const { scrollTop, scrollHeight, clientHeight } = element;
+        setIsScrollAtStart(scrollTop === 0);
+        setIsScrollAtEnd(scrollTop + clientHeight >= scrollHeight);
+    }, []);
+    useEventListener("scroll", onScroll, elementRef);
+    return [elementRef, { isScrollAtStart, isScrollAtEnd }];
+}

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

@@ -0,0 +1,26 @@
+import React from "react";
+export type Step<ComponentProps = object> = {
+    key: string;
+    Component: React.ComponentType<Stepper & ComponentProps>;
+};
+type CurrentStep<ComponentProps = object> = {
+    key: string;
+    Component: React.FC<ComponentProps>;
+};
+type Props<ComponentProps = object> = {
+    steps: Step<ComponentProps>[];
+    initialStep?: string;
+    onStep?: (step: Step<ComponentProps>, index: number) => void;
+};
+type Stepper<ComponentProps = object> = {
+    step: CurrentStep<ComponentProps> | undefined;
+    stepIndex: number;
+    isFirstStep: boolean;
+    isLastStep: boolean;
+    goToNextStep: () => void;
+    goToPreviousStep: () => void;
+    goToStep: (key: string) => void;
+    reset: () => void;
+};
+export declare function useStepper<ComponentProps>(props: Props<ComponentProps>): Stepper<ComponentProps>;
+export {};