@cntrl-site/components 0.0.1

package/dist/sdk/Components/ImageRevealSlider/ControlImageRevealSliderComponent.d.ts

@@ -0,0 +1,209 @@
+import { ImageRevealSlider } from './ImageRevealSlider';
+export declare const ControlImageRevealSliderComponent: {
+    element: typeof ImageRevealSlider;
+    id: string;
+    name: string;
+    preview: {
+        type: "video";
+        url: string;
+    };
+    defaultSize: {
+        width: number;
+        height: number;
+    };
+    schema: {
+        type: string;
+        properties: {
+            settings: {
+                layoutBased: boolean;
+                type: string;
+                properties: {
+                    imageSize: {
+                        name: string;
+                        icon: string;
+                        tooltip: string;
+                        type: string;
+                        properties: {
+                            sizeType: {
+                                name: string;
+                                type: string;
+                                display: {
+                                    type: string;
+                                };
+                                enum: string[];
+                            };
+                            imageWidth: {
+                                type: string;
+                                label: string;
+                                display: {
+                                    type: string;
+                                    visible: boolean;
+                                };
+                            };
+                            randomRangeImageWidth: {
+                                type: string;
+                                display: {
+                                    type: string;
+                                    visible: boolean;
+                                };
+                                properties: {
+                                    min: {
+                                        type: string;
+                                    };
+                                    max: {
+                                        type: string;
+                                    };
+                                };
+                            };
+                        };
+                    };
+                    cursor: {
+                        name: string;
+                        icon: string;
+                        tooltip: string;
+                        type: string;
+                        properties: {
+                            cursorType: {
+                                name: string;
+                                type: string;
+                                display: {
+                                    type: string;
+                                };
+                                enum: string[];
+                            };
+                            defaultCursor: {
+                                type: string[];
+                                display: {
+                                    type: string;
+                                    title: string;
+                                    visible: boolean;
+                                };
+                            };
+                            hoverCursor: {
+                                type: string[];
+                                display: {
+                                    type: string;
+                                    title: string;
+                                    visible: boolean;
+                                };
+                            };
+                        };
+                    };
+                    position: {
+                        name: string;
+                        icon: string;
+                        tooltip: string;
+                        type: string;
+                        properties: {
+                            revealPosition: {
+                                type: string;
+                                display: {
+                                    type: string;
+                                };
+                                enum: string[];
+                            };
+                            visible: {
+                                type: string;
+                                display: {
+                                    type: string;
+                                };
+                                enum: string[];
+                            };
+                            target: {
+                                type: string;
+                                display: {
+                                    type: string;
+                                };
+                                enum: string[];
+                            };
+                        };
+                    };
+                };
+                default: {
+                    imageSize: {
+                        sizeType: string;
+                        imageWidth: number;
+                        randomRangeImageWidth: {
+                            min: number;
+                            max: number;
+                        };
+                    };
+                    cursor: {
+                        cursorType: string;
+                        defaultCursor: null;
+                        hoverCursor: null;
+                    };
+                    position: {
+                        revealPosition: string;
+                        visible: string;
+                        target: string;
+                    };
+                };
+                displayRules: ({
+                    if: {
+                        name: string;
+                        value: string;
+                    };
+                    then: {
+                        name: string;
+                        value: boolean;
+                    };
+                } | {
+                    if: {
+                        name: string;
+                        value: string;
+                    }[];
+                    then: {
+                        name: string;
+                        value: boolean;
+                    };
+                })[];
+            };
+            content: {
+                layoutBased: boolean;
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        image: {
+                            type: string;
+                            display: {
+                                type: string;
+                                isObjectFitEditable: boolean;
+                            };
+                            properties: {
+                                url: {
+                                    type: string;
+                                };
+                                name: {
+                                    type: string;
+                                };
+                                objectFit: {
+                                    type: string;
+                                    enum: string[];
+                                };
+                            };
+                            required: string[];
+                        };
+                        link: {
+                            type: string;
+                            display: {
+                                type: string;
+                                placeholder: string;
+                            };
+                        };
+                    };
+                    required: string[];
+                };
+                default: {
+                    image: {
+                        objectFit: string;
+                        url: string;
+                        name: string;
+                    };
+                    link: string;
+                }[];
+            };
+        };
+    };
+};

package/dist/sdk/Components/ImageRevealSlider/ImageRevealSlider.d.ts

@@ -0,0 +1,38 @@
+interface ImageRevealSliderProps {
+    settings: ImageRevealSliderSettings;
+    content: ImageRevealSliderItem[];
+    isEditor?: boolean;
+}
+type RandomRange = {
+    min: number;
+    max: number;
+};
+type ImageRevealSliderImageSize = {
+    sizeType: 'as Is' | 'custom' | 'random';
+    imageWidth: number;
+    randomRangeImageWidth: RandomRange;
+};
+type ImageRevealSliderCursor = {
+    cursorType: 'system' | 'custom';
+    defaultCursor: string | null;
+    hoverCursor: string | null;
+};
+type ImageRevealSliderPosition = {
+    revealPosition: 'random' | 'same' | 'on Click';
+    visible: 'all' | 'last One';
+    target: 'area' | 'image';
+};
+type ImageRevealSliderSettings = {
+    imageSize: ImageRevealSliderImageSize;
+    cursor: ImageRevealSliderCursor;
+    position: ImageRevealSliderPosition;
+};
+type ImageRevealSliderItem = {
+    image: {
+        url: string;
+        name: string;
+    };
+    link: string;
+};
+export declare function ImageRevealSlider({ settings, content, isEditor }: ImageRevealSliderProps): JSX.Element;
+export {};

package/dist/sdk/Components/components.d.ts

@@ -0,0 +1,2 @@
+import { Component } from '../types/component/Component';
+export declare const components: Component[];

package/dist/sdk/Components/helpers/RichTextRenderer/RichTextRenderer.d.ts

@@ -0,0 +1,6 @@
+import { FC } from 'react';
+interface Props {
+    content: any[];
+}
+export declare const RichTextRenderer: FC<Props>;
+export {};

package/dist/sdk/Components/helpers/SvgImage/SvgImage.d.ts

@@ -0,0 +1,9 @@
+import { FC } from 'react';
+interface SvgImageProps {
+    url: string;
+    fill?: string;
+    hoverFill?: string;
+    className?: string;
+}
+export declare const SvgImage: FC<SvgImageProps>;
+export {};

package/dist/sdk/Components/utils/scalingValue.d.ts

@@ -0,0 +1 @@
+export declare function scalingValue(value: number, isEditor?: boolean): string;

package/dist/sdk/FontFaceGenerator/FontFaceGenerator.d.ts

@@ -0,0 +1,6 @@
+import { CustomFont } from '../types/project/Fonts';
+export declare class FontFaceGenerator {
+    private fonts;
+    constructor(fonts: CustomFont[]);
+    generate(): string;
+}

package/dist/sdk/FontFaceGenerator/FontFaceGenerator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sdk/ScrollPlaybackVideoManager/ScrollPlaybackVideoManager.d.ts

@@ -0,0 +1,31 @@
+interface ScrollVideoOptions {
+    src: string;
+    videoContainer: HTMLElement | string;
+}
+export declare class ScrollPlaybackVideoManager {
+    private container?;
+    private video?;
+    private isSafari?;
+    private currentTime;
+    private targetTime;
+    private canvas;
+    private context;
+    private frames;
+    private frameRate;
+    private transitioning;
+    private debug;
+    private frameThreshold;
+    private transitionSpeed;
+    private useWebCodecs;
+    private resizeObserver;
+    constructor(options: ScrollVideoOptions);
+    private setCoverStyle;
+    private resize;
+    private decodeVideo;
+    private paintCanvasFrame;
+    private transitionToTargetTime;
+    private resetCanvasDimensions;
+    setTargetTimePercent(setPercentage: number, jump?: boolean): void;
+    destroy(): void;
+}
+export {};

package/dist/sdk/VideoDecoder/VideoDecoder.d.ts

@@ -0,0 +1,12 @@
+export declare class Writer {
+    private data;
+    private idx;
+    private size;
+    constructor(size: number);
+    getData(): Uint8Array<ArrayBuffer>;
+    writeUint8(value: number): void;
+    writeUint16(value: number): void;
+    writeUint8Array(value: Uint8Array): void;
+}
+declare const _default: (src: string, emitFrame: (bitmap: ImageBitmap) => void, debug: boolean) => Promise<void>;
+export default _default;

package/dist/sdk/schemas/article/Article.schema.d.ts

@@ -0,0 +1,328 @@
+import { z } from 'zod';
+export declare const ArticleSchema: z.ZodObject<{
+    id: z.ZodString;
+    sections: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        items: z.ZodArray<z.ZodType<import('../../..').ItemAny, z.ZodTypeDef, import('../../..').ItemAny>, "many">;
+        name: z.ZodOptional<z.ZodString>;
+        height: z.ZodRecord<z.ZodString, z.ZodObject<{
+            mode: z.ZodNativeEnum<typeof import('../../..').SectionHeightMode>;
+            units: z.ZodNumber;
+            vhUnits: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            mode: import('../../..').SectionHeightMode;
+            units: number;
+            vhUnits?: number | undefined;
+        }, {
+            mode: import('../../..').SectionHeightMode;
+            units: number;
+            vhUnits?: number | undefined;
+        }>>;
+        position: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        hidden: z.ZodRecord<z.ZodString, z.ZodBoolean>;
+        color: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>;
+        media: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            url: z.ZodString;
+            size: z.ZodString;
+            type: z.ZodLiteral<"video">;
+            play: z.ZodEnum<["on-click", "auto"]>;
+            coverUrl: z.ZodNullable<z.ZodString>;
+            position: z.ZodString;
+            offsetX: z.ZodNullable<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            url: string;
+            coverUrl: string | null;
+            play: "on-click" | "auto";
+            position: string;
+            type: "video";
+            size: string;
+            offsetX: number | null;
+        }, {
+            url: string;
+            coverUrl: string | null;
+            play: "on-click" | "auto";
+            position: string;
+            type: "video";
+            size: string;
+            offsetX: number | null;
+        }>, z.ZodObject<{
+            url: z.ZodString;
+            type: z.ZodLiteral<"image">;
+            size: z.ZodString;
+            position: z.ZodString;
+            offsetX: z.ZodNullable<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            url: string;
+            position: string;
+            type: "image";
+            size: string;
+            offsetX: number | null;
+        }, {
+            url: string;
+            position: string;
+            type: "image";
+            size: string;
+            offsetX: number | null;
+        }>]>>>;
+    }, "strip", z.ZodTypeAny, {
+        color: Record<string, string | null>;
+        hidden: Record<string, boolean>;
+        position: Record<string, number>;
+        id: string;
+        height: Record<string, {
+            mode: import('../../..').SectionHeightMode;
+            units: number;
+            vhUnits?: number | undefined;
+        }>;
+        items: import('../../..').ItemAny[];
+        name?: string | undefined;
+        media?: Record<string, {
+            url: string;
+            coverUrl: string | null;
+            play: "on-click" | "auto";
+            position: string;
+            type: "video";
+            size: string;
+            offsetX: number | null;
+        } | {
+            url: string;
+            position: string;
+            type: "image";
+            size: string;
+            offsetX: number | null;
+        }> | undefined;
+    }, {
+        color: Record<string, string | null>;
+        hidden: Record<string, boolean>;
+        position: Record<string, number>;
+        id: string;
+        height: Record<string, {
+            mode: import('../../..').SectionHeightMode;
+            units: number;
+            vhUnits?: number | undefined;
+        }>;
+        items: import('../../..').ItemAny[];
+        name?: string | undefined;
+        media?: Record<string, {
+            url: string;
+            coverUrl: string | null;
+            play: "on-click" | "auto";
+            position: string;
+            type: "video";
+            size: string;
+            offsetX: number | null;
+        } | {
+            url: string;
+            position: string;
+            type: "image";
+            size: string;
+            offsetX: number | null;
+        }> | undefined;
+    }>, "many">;
+    interactions: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        triggers: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            itemId: z.ZodString;
+            type: z.ZodEnum<["hover-in", "hover-out", "click"]>;
+            from: z.ZodString;
+            to: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: "hover-in" | "hover-out" | "click";
+            from: string;
+            to: string;
+            itemId: string;
+        }, {
+            type: "hover-in" | "hover-out" | "click";
+            from: string;
+            to: string;
+            itemId: string;
+        }>, z.ZodObject<{
+            position: z.ZodNumber;
+            from: z.ZodString;
+            to: z.ZodString;
+            isReverse: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            position: number;
+            from: string;
+            to: string;
+            isReverse: boolean;
+        }, {
+            position: number;
+            from: string;
+            to: string;
+            isReverse: boolean;
+        }>]>, "many">;
+        states: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                type: z.ZodEnum<["play", "pause"]>;
+                itemId: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: "play" | "pause";
+                itemId: string;
+            }, {
+                type: "play" | "pause";
+                itemId: string;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            actions?: {
+                type: "play" | "pause";
+                itemId: string;
+            }[] | undefined;
+        }, {
+            id: string;
+            actions?: {
+                type: "play" | "pause";
+                itemId: string;
+            }[] | undefined;
+        }>, "many">;
+        startStateId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        triggers: ({
+            type: "hover-in" | "hover-out" | "click";
+            from: string;
+            to: string;
+            itemId: string;
+        } | {
+            position: number;
+            from: string;
+            to: string;
+            isReverse: boolean;
+        })[];
+        states: {
+            id: string;
+            actions?: {
+                type: "play" | "pause";
+                itemId: string;
+            }[] | undefined;
+        }[];
+        startStateId: string;
+    }, {
+        id: string;
+        triggers: ({
+            type: "hover-in" | "hover-out" | "click";
+            from: string;
+            to: string;
+            itemId: string;
+        } | {
+            position: number;
+            from: string;
+            to: string;
+            isReverse: boolean;
+        })[];
+        states: {
+            id: string;
+            actions?: {
+                type: "play" | "pause";
+                itemId: string;
+            }[] | undefined;
+        }[];
+        startStateId: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    sections: {
+        color: Record<string, string | null>;
+        hidden: Record<string, boolean>;
+        position: Record<string, number>;
+        id: string;
+        height: Record<string, {
+            mode: import('../../..').SectionHeightMode;
+            units: number;
+            vhUnits?: number | undefined;
+        }>;
+        items: import('../../..').ItemAny[];
+        name?: string | undefined;
+        media?: Record<string, {
+            url: string;
+            coverUrl: string | null;
+            play: "on-click" | "auto";
+            position: string;
+            type: "video";
+            size: string;
+            offsetX: number | null;
+        } | {
+            url: string;
+            position: string;
+            type: "image";
+            size: string;
+            offsetX: number | null;
+        }> | undefined;
+    }[];
+    interactions: Record<string, {
+        id: string;
+        triggers: ({
+            type: "hover-in" | "hover-out" | "click";
+            from: string;
+            to: string;
+            itemId: string;
+        } | {
+            position: number;
+            from: string;
+            to: string;
+            isReverse: boolean;
+        })[];
+        states: {
+            id: string;
+            actions?: {
+                type: "play" | "pause";
+                itemId: string;
+            }[] | undefined;
+        }[];
+        startStateId: string;
+    }[]>;
+}, {
+    id: string;
+    sections: {
+        color: Record<string, string | null>;
+        hidden: Record<string, boolean>;
+        position: Record<string, number>;
+        id: string;
+        height: Record<string, {
+            mode: import('../../..').SectionHeightMode;
+            units: number;
+            vhUnits?: number | undefined;
+        }>;
+        items: import('../../..').ItemAny[];
+        name?: string | undefined;
+        media?: Record<string, {
+            url: string;
+            coverUrl: string | null;
+            play: "on-click" | "auto";
+            position: string;
+            type: "video";
+            size: string;
+            offsetX: number | null;
+        } | {
+            url: string;
+            position: string;
+            type: "image";
+            size: string;
+            offsetX: number | null;
+        }> | undefined;
+    }[];
+    interactions: Record<string, {
+        id: string;
+        triggers: ({
+            type: "hover-in" | "hover-out" | "click";
+            from: string;
+            to: string;
+            itemId: string;
+        } | {
+            position: number;
+            from: string;
+            to: string;
+            isReverse: boolean;
+        })[];
+        states: {
+            id: string;
+            actions?: {
+                type: "play" | "pause";
+                itemId: string;
+            }[] | undefined;
+        }[];
+        startStateId: string;
+    }[]>;
+}>;