@gxpl/sdk 0.0.1

package/dist/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/Components/ImageRevealSlider/ImageRevealSlider.d.ts

@@ -0,0 +1,39 @@
+import { default as React } from 'react';
+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): React.JSX.Element;
+export {};

package/dist/Components/components.d.ts

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

package/dist/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/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/Components/utils/scalingValue.d.ts

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

package/dist/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/FontFaceGenerator/FontFaceGenerator.test.d.ts

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

package/dist/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/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/cli.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+export interface LayoutRange {
+    /** closed range [start, end] */
+    start: number;
+    end: number;
+    exemplary: number;
+    name: string;
+    isFirst: boolean;
+    isLast: boolean;
+}

package/dist/cli.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ejs_1 = __importDefault(require("ejs"));
+const dotenv_1 = require("dotenv");
+const commander_1 = require("commander");
+const Client_1 = require("./Client/Client");
+commander_1.program
+    .command('generate-layouts')
+    .option('-o, --output <outputFilePath>', 'Output file path', 'cntrl.scss')
+    .option('-e, --env <envFilename>', 'Name of the .env file', '.env.local')
+    .action((options) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        (0, dotenv_1.config)({ path: options.env });
+        const templateFilePath = path_1.default.resolve(__dirname, '../resources/template.scss.ejs');
+        const scssTemplate = fs_1.default.readFileSync(templateFilePath, 'utf-8');
+        const apiUrl = process.env.CNTRL_API_URL;
+        if (!apiUrl) {
+            throw new Error('Environment variable "CNTRL_API_URL" must be set.');
+        }
+        const client = new Client_1.Client(apiUrl);
+        const layouts = yield client.getLayouts();
+        const ranges = convertLayouts(layouts);
+        const compiledTemplate = ejs_1.default.compile(scssTemplate);
+        const renderedTemplate = compiledTemplate({ ranges });
+        const outputFilePath = path_1.default.resolve(process.cwd(), options.output);
+        fs_1.default.writeFileSync(outputFilePath, renderedTemplate);
+        console.log(`Generated .scss file at ${outputFilePath}`);
+    }
+    catch (error) {
+        console.error('An error occurred:', error);
+        process.exit(1);
+    }
+}));
+function convertLayouts(layouts, maxLayoutWidth = Number.MAX_SAFE_INTEGER) {
+    const sorted = layouts.slice().sort((la, lb) => la.startsWith - lb.startsWith);
+    const mapped = sorted.map((layout, i, ls) => {
+        const next = ls[i + 1];
+        return {
+            start: layout.startsWith,
+            end: next ? next.startsWith - 1 : maxLayoutWidth,
+            exemplary: layout.exemplary,
+            name: layout.title,
+            isFirst: i === 0,
+            isLast: !next
+        };
+    });
+    return mapped;
+}
+commander_1.program.parse(process.argv);

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+export { Client as CntrlClient } from './Client/Client';
+export { FontFaceGenerator } from './FontFaceGenerator/FontFaceGenerator';
+export { getLayoutStyles, getLayoutMediaQuery } from './utils';
+export { ScrollPlaybackVideoManager } from './ScrollPlaybackVideoManager/ScrollPlaybackVideoManager';
+export { SectionHeightMode } from './types/article/Section';
+export { TextAlign, TextDecoration, TextTransform, VerticalAlign } from './types/article/RichText';
+export { ArticleItemType } from './types/article/ArticleItemType';
+export { AreaAnchor, AnchorSide, DimensionMode, PositionType } from './types/article/ItemArea';
+export { KeyframeType } from './types/keyframe/Keyframe';
+export type { Article } from './types/article/Article';
+export type { Section, SectionHeight } from './types/article/Section';
+export type { Item, ImageItem, ItemAny, CustomItem, ItemCommonParamsMap, ItemLayoutParamsMap, RectangleItem, StickyParams, VideoItem, RichTextItem, Link, VimeoEmbedItem, YoutubeEmbedItem, GroupItem, CodeEmbedItem, CompoundItem, ComponentItem, FillLayer } from './types/article/Item';
+export type { RichTextBlock, RichTextEntity, RichTextStyle } from './types/article/RichText';
+export type { ItemArea } from './types/article/ItemArea';
+export type { ItemState, ItemStateParams, StateParams, ItemStatesMap } from './types/article/ItemState';
+export type { Interaction, InteractionItemTrigger, InteractionScrollTrigger, InteractionState } from './types/article/Interaction';
+export type { Layout } from './types/project/Layout';
+export type { Project } from './types/project/Project';
+export type { Meta } from './types/project/Meta';
+export type { KeyframeValueMap, KeyframeAny } from './types/keyframe/Keyframe';
+export type { CompoundSettings } from './types/article/CompoundSettings';
+export type { Component } from './types/component/Component';
+export { components } from './Components/components';