@gxpl/sdk 0.0.1 → 0.0.2

package/dist/sdk-nextjs/components/items/useItemArea.d.ts

@@ -0,0 +1,12 @@
+import { ItemAny } from '../../../sdk/types/article/Item';
+export declare function useItemArea(item: ItemAny, sectionId: string, stateValues: {
+    top?: number;
+    left?: number;
+    width?: number;
+    height?: number;
+}): {
+    width: number | undefined;
+    height: number | undefined;
+    top: number | undefined;
+    left: number | undefined;
+};

package/dist/sdk-nextjs/components/items/useItemPointerEvents.d.ts

@@ -0,0 +1,4 @@
+export declare function useItemPointerEvents(pointerEvents: 'never' | 'when_visible' | 'always', isParentVisible: boolean): {
+    allowPointerEvents: boolean;
+    handleVisibilityChange: (isVisible: boolean) => void;
+};

package/dist/sdk-nextjs/components/items/useItemScale.d.ts

@@ -0,0 +1,2 @@
+import { ItemAny } from '../../../sdk/types/article/Item';
+export declare const useItemScale: (item: ItemAny, sectionId: string) => number | undefined;

package/dist/sdk-nextjs/components/items/useItemTriggers.d.ts

@@ -0,0 +1,6 @@
+import { ItemInteractionCtrl } from '../../interactions/types';
+export declare function useItemTriggers(interactionCtrl: ItemInteractionCtrl | undefined): {
+    onClick: () => void;
+    onMouseEnter: () => void;
+    onMouseLeave: () => void;
+};

package/dist/sdk-nextjs/components/items/useRichTextItemValues.d.ts

@@ -0,0 +1,9 @@
+import { RichTextItem } from '../../../sdk/types/article/Item';
+export declare const useRichTextItemValues: (item: RichTextItem, sectionId: string) => {
+    blur: number | undefined;
+    letterSpacing: number | undefined;
+    wordSpacing: number | undefined;
+    color: string | undefined;
+    fontSize: number | undefined;
+    lineHeight: number | undefined;
+};

package/dist/sdk-nextjs/components/items/useSizing.d.ts

@@ -0,0 +1,8 @@
+import { ItemAny } from '../../../sdk/types/article/Item';
+export declare function useSizing(item: ItemAny): Axis;
+export declare function parseSizing(sizing?: string): Axis;
+interface Axis {
+    x: 'manual' | 'auto';
+    y: 'manual' | 'auto';
+}
+export {};

package/dist/sdk-nextjs/components/items/useStickyItemTop.d.ts

@@ -0,0 +1,2 @@
+import { ItemAny } from '../../../sdk/types/article/Item';
+export declare function useStickyItemTop(item: ItemAny, sectionId: string, stateTop?: number): number;

package/dist/sdk-nextjs/components/useLayoutContext.d.ts

@@ -0,0 +1 @@
+export declare function useLayoutContext(): string | undefined;

package/dist/sdk-nextjs/interactions/CSSPropertyNameMap.d.ts

@@ -0,0 +1,4 @@
+import { ArticleItemType } from '../../sdk/types/article/ArticleItemType';
+import { ItemState } from '../../sdk/types/article/ItemState';
+export declare const CSSPropertyNameMap: Record<keyof ItemState<ArticleItemType>, string>;
+export declare function getStyleKeysFromCSSProperty(cssProp: string): string[];

package/dist/sdk-nextjs/interactions/InteractionsRegistry.d.ts

@@ -0,0 +1,39 @@
+import { InteractionsRegistryPort, ItemInteractionCtrl } from './types';
+import { InteractionItemTrigger } from '../../sdk/types/article/Interaction';
+import { Article } from '../../sdk/types/article/Article';
+export declare class InteractionsRegistry implements InteractionsRegistryPort {
+    private ctrls;
+    private items;
+    private interactions;
+    private stateItemsIdsMap;
+    private interactionStateMap;
+    private itemsStages;
+    private activeStateIdInteractionIdMap;
+    constructor(article: Article, layoutId: string);
+    register(itemId: ItemId, ctrl: ItemInteractionCtrl): void;
+    getStatePropsForItem(itemId: string): StateProps;
+    getItemAvailableTriggers(itemId: string): Set<InteractionItemTrigger['type']>;
+    notifyLoad(): void;
+    notifyScroll(position: number): void;
+    notifyItemTrigger(itemId: string, triggerType: TriggerType): void;
+    notifyTransitionStartForItems(itemsIds: string[], activeStateId: string): void;
+    notifyTransitionEnd(itemId: string): void;
+    private getCurrentStateByInteractionId;
+    private setCurrentStateForInteraction;
+    private getActiveInteractionState;
+    private notifyItemCtrlsChange;
+    private unpackItems;
+    private getNestedItems;
+    private getDefaultItemStages;
+}
+type TriggerType = InteractionItemTrigger['type'];
+type ItemId = string;
+type StateProps = Record<string, {
+    value?: string | number;
+    transition?: {
+        timing: string;
+        duration: number;
+        delay: number;
+    };
+}>;
+export {};

package/dist/sdk-nextjs/interactions/ItemInteractionCtrl.d.ts

@@ -0,0 +1,21 @@
+import { InteractionsRegistryPort, ItemInteractionCtrl } from './types';
+import { InteractionItemTrigger } from '../../sdk/types/article/Interaction';
+export declare class ItemInteractionController implements ItemInteractionCtrl {
+    private itemId;
+    private registry;
+    private onChange;
+    private transitionsInProgress;
+    private actionReceiver;
+    constructor(itemId: string, registry: InteractionsRegistryPort, onChange: () => void);
+    getState<T>(keys: string[]): {
+        styles: Record<string, T>;
+        transition: string;
+    };
+    getHasTrigger(itemId: string, triggerType: InteractionItemTrigger['type']): boolean;
+    sendTrigger(type: 'click' | 'hover-in' | 'hover-out'): void;
+    receiveAction(type: 'play' | 'pause'): void;
+    setActionReceiver(action: (type: 'play' | 'pause') => void): void;
+    handleTransitionStart: (types: string[]) => void;
+    handleTransitionEnd: (cssPropKey: string) => void;
+    receiveChange(): void;
+}

package/dist/sdk-nextjs/interactions/getTransition.d.ts

@@ -0,0 +1,9 @@
+export declare function getTransition(state: Record<string, StateInfo>, keys: string[]): string;
+type StateInfo = {
+    transition?: {
+        duration: number;
+        delay: number;
+        timing: string;
+    };
+};
+export {};

package/dist/sdk-nextjs/interactions/types.d.ts

@@ -0,0 +1,34 @@
+import { ArticleItemType } from '../../sdk/types/article/ArticleItemType';
+import { InteractionItemTrigger } from '../../sdk/types/article/Interaction';
+import { ItemState } from '../../sdk/types/article/ItemState';
+export interface ItemInteractionCtrl {
+    getState<T>(keys: string[]): StateCSSInfo<T>;
+    getHasTrigger(itemId: string, triggerType: InteractionItemTrigger['type']): boolean;
+    sendTrigger(type: 'click' | 'hover-in' | 'hover-out'): void;
+    handleTransitionEnd?: (styleKey: string) => void;
+    handleTransitionStart?: (styleKeys: string[]) => void;
+    receiveChange: () => void;
+    receiveAction: (type: 'play' | 'pause') => void;
+    setActionReceiver: (action: (type: 'play' | 'pause') => void) => void;
+}
+export interface InteractionsRegistryPort {
+    register(itemId: string, ctrl: ItemInteractionCtrl): void;
+    getStatePropsForItem(itemId: string): StateProps<unknown>;
+    getItemAvailableTriggers(itemId: string): Set<InteractionItemTrigger['type']>;
+    notifyItemTrigger(itemId: string, type: TriggerType): void;
+    notifyTransitionEnd(itemId: string): void;
+}
+type StateCSSInfo<T> = {
+    styles: Partial<Record<string, T>>;
+    transition?: string;
+};
+type StateProps<T> = Record<keyof ItemState<ArticleItemType>, {
+    value?: T;
+    transition?: {
+        timing: string;
+        duration: number;
+        delay: number;
+    };
+}>;
+type TriggerType = 'click' | 'hover-in' | 'hover-out';
+export {};

package/dist/sdk-nextjs/interactions/useItemInteractionCtrl.d.ts

@@ -0,0 +1,2 @@
+import { ItemInteractionCtrl } from './types';
+export declare function useItemInteractionCtrl(itemId: string): ItemInteractionCtrl | undefined;

package/dist/sdk-nextjs/provider/ArticleRectContext.d.ts

@@ -0,0 +1,2 @@
+import { ArticleRectObserver } from '../utils/ArticleRectManager/ArticleRectObserver';
+export declare const ArticleRectContext: import('react').Context<ArticleRectObserver | null>;

package/dist/sdk-nextjs/provider/CntrlContext.d.ts

@@ -0,0 +1,2 @@
+import { CntrlSdkContext } from './CntrlSdkContext';
+export declare const CntrlContext: import('react').Context<CntrlSdkContext>;

package/dist/sdk-nextjs/provider/CntrlProvider.d.ts

@@ -0,0 +1,2 @@
+import { FC, PropsWithChildren } from 'react';
+export declare const CntrlProvider: FC<PropsWithChildren<{}>>;

package/dist/sdk-nextjs/provider/CntrlSdkContext.d.ts

@@ -0,0 +1,31 @@
+import { Article } from '../../sdk/types/article/Article';
+import { Section, SectionHeight } from '../../sdk/types/article/Section';
+import { Layout } from '../../sdk/types/project/Layout';
+import { Project } from '../../sdk/types/project/Project';
+import { CustomItemRegistry } from './CustomItemRegistry';
+import { CustomSectionRegistry } from './CustomSectionRegistry';
+import { Component as TComponent } from '../../sdk/types/component/Component';
+interface SdkContextInitProps {
+    project: Project;
+    article: Article;
+}
+export declare class CntrlSdkContext {
+    readonly customItems: CustomItemRegistry;
+    readonly customSections: CustomSectionRegistry;
+    private _layouts;
+    private _fonts?;
+    private sectionHeightMap;
+    private components;
+    constructor(customItems: CustomItemRegistry, customSections: CustomSectionRegistry);
+    resolveSectionData(sections: Section[]): Promise<Record<string, any>>;
+    init({ project, article }: SdkContextInitProps): void;
+    setLayouts(layouts: Layout[]): void;
+    private setComponents;
+    private setFonts;
+    setSectionsHeight(sections: Section[]): void;
+    getSectionHeightData(sectionId: string): Record<string, SectionHeight> | undefined;
+    get layouts(): Layout[];
+    get fonts(): Project['fonts'] | undefined;
+    getComponent(id: string): TComponent | undefined;
+}
+export {};

package/dist/sdk-nextjs/provider/CustomItemRegistry.d.ts

@@ -0,0 +1,6 @@
+import { CustomItemComponent } from './CustomItemTypes';
+export declare class CustomItemRegistry {
+    private definitions;
+    define<T extends string>(type: T, component: CustomItemComponent<T>): this;
+    get(type: string): CustomItemComponent<string> | undefined;
+}

package/dist/sdk-nextjs/provider/CustomItemTypes.d.ts

@@ -0,0 +1,2 @@
+import { FC } from 'react';
+export type CustomItemComponent<T extends string> = FC<{}>;

package/dist/sdk-nextjs/provider/CustomSectionRegistry.d.ts

@@ -0,0 +1,15 @@
+import { default as React, PropsWithChildren } from 'react';
+export declare class CustomSectionRegistry {
+    private definitions;
+    define<TData>(name: string, section: CustomSection<TData>): this;
+    getComponent(name: string): CustomSectionComponent<any> | undefined;
+    getResolver(name: string): (() => Promise<any>) | undefined;
+}
+type CustomSection<TData = {}> = {
+    component: CustomSectionComponent<TData>;
+    dataResolver?: () => Promise<TData>;
+};
+type CustomSectionComponent<TData> = React.FC<PropsWithChildren<{
+    data: TData;
+}>>;
+export {};

package/dist/sdk-nextjs/provider/InteractionsContext.d.ts

@@ -0,0 +1,10 @@
+import { FC, PropsWithChildren } from 'react';
+import { InteractionsRegistry } from '../interactions/InteractionsRegistry';
+import { Article } from '../../sdk/types/article/Article';
+export declare const InteractionsContext: import('react').Context<InteractionsRegistry | undefined>;
+interface Props {
+    article: Article;
+}
+export declare const InteractionsProvider: FC<PropsWithChildren<Props>>;
+export declare function useInteractionsRegistry(): InteractionsRegistry | undefined;
+export {};

package/dist/sdk-nextjs/provider/Keyframes.d.ts

@@ -0,0 +1,6 @@
+import { KeyframeAny } from '../../sdk/types/keyframe/Keyframe';
+export declare class Keyframes {
+    private keyframes;
+    constructor(keyframes?: KeyframeAny[]);
+    getItemKeyframes(itemId: string): KeyframeAny[];
+}

package/dist/sdk-nextjs/provider/KeyframesContext.d.ts

@@ -0,0 +1,2 @@
+import { Keyframes } from './Keyframes';
+export declare const KeyframesContext: import('react').Context<Keyframes>;

package/dist/sdk-nextjs/provider/LayoutContext.d.ts

@@ -0,0 +1 @@
+export declare const LayoutContext: import('react').Context<string | undefined>;

package/dist/sdk-nextjs/provider/WebGLContextManagerContext.d.ts

@@ -0,0 +1,2 @@
+import { WebGLContextManager } from '@cntrl-site/effects';
+export declare const WebglContextManagerContext: import('react').Context<WebGLContextManager>;

package/dist/sdk-nextjs/provider/defaultContext.d.ts

@@ -0,0 +1,2 @@
+import { CntrlSdkContext } from './CntrlSdkContext';
+export declare const cntrlSdkContext: CntrlSdkContext;

package/dist/sdk-nextjs/provider/useCntrlContext.d.ts

@@ -0,0 +1,2 @@
+import { CntrlSdkContext } from './CntrlSdkContext';
+export declare function useCntrlContext(): CntrlSdkContext;

package/dist/sdk-nextjs/utils/Animator/Animator.d.ts

@@ -0,0 +1,43 @@
+import { KeyframeType, KeyframeValueMap } from '../../../sdk/types/keyframe/Keyframe';
+import { FillLayer } from '../../../sdk/types/article/Item';
+export interface AnimationData<T extends KeyframeType> {
+    position: number;
+    value: KeyframeValueMap[T];
+    type: T;
+}
+interface PositionKeyframes<T extends KeyframeType> {
+    start: AnimationData<T>;
+    end: AnimationData<T>;
+}
+export type KeyframesMap = {
+    [T in KeyframeType]: AnimationData<T>[];
+};
+export declare class Animator {
+    private keyframes;
+    private static pushKeyframeToMap;
+    private keyframesMap;
+    constructor(keyframes: AnimationData<KeyframeType>[]);
+    getFXParams(valuesMap: Record<string, number>, pos: number): KeyframeValueMap[KeyframeType.FXParams];
+    getDimensions(values: KeyframeValueMap[KeyframeType.Dimensions], pos: number): KeyframeValueMap[KeyframeType.Dimensions];
+    getPositions(values: KeyframeValueMap[KeyframeType.Position], pos: number): KeyframeValueMap[KeyframeType.Position];
+    getBorderFill(values: KeyframeValueMap[KeyframeType.BorderFill], pos: number): FillLayer[];
+    getFill(values: KeyframeValueMap[KeyframeType.Fill], pos: number): FillLayer[];
+    getRadius(values: KeyframeValueMap[KeyframeType.BorderRadius], pos: number): KeyframeValueMap[KeyframeType.BorderRadius];
+    getBorderWidth(values: KeyframeValueMap[KeyframeType.BorderWidth], pos: number): KeyframeValueMap[KeyframeType.BorderWidth];
+    getRotation(values: KeyframeValueMap[KeyframeType.Rotation], pos: number): KeyframeValueMap[KeyframeType.Rotation];
+    getOpacity(values: KeyframeValueMap[KeyframeType.Opacity], pos: number): KeyframeValueMap[KeyframeType.Opacity];
+    getScale(values: KeyframeValueMap[KeyframeType.Scale], pos: number): KeyframeValueMap[KeyframeType.Scale];
+    getBlur(values: KeyframeValueMap[KeyframeType.Blur], pos: number): KeyframeValueMap[KeyframeType.Blur];
+    getBackdropBlur(values: KeyframeValueMap[KeyframeType.BackdropBlur], pos: number): KeyframeValueMap[KeyframeType.BackdropBlur];
+    getTextColor(values: KeyframeValueMap[KeyframeType.TextColor], pos: number): KeyframeValueMap[KeyframeType.TextColor];
+    getLetterSpacing(values: KeyframeValueMap[KeyframeType.LetterSpacing], pos: number): KeyframeValueMap[KeyframeType.LetterSpacing];
+    getWordSpacing(values: KeyframeValueMap[KeyframeType.WordSpacing], pos: number): KeyframeValueMap[KeyframeType.WordSpacing];
+    getStartEnd<T extends KeyframeType>(position: number, keyframes: AnimationData<T>[]): PositionKeyframes<T>;
+    private fillKeyframesMap;
+    private getRangeColor;
+    private getRangeGradient;
+    private interpolateFillLayerArray;
+    private interpolateFillLayer;
+    private interpolateColorStops;
+}
+export {};

package/dist/sdk-nextjs/utils/ArticleRectManager/ArticleRectObserver.d.ts

@@ -0,0 +1,25 @@
+import { EventEmitter } from '../EventEmitter';
+interface EventMap {
+    'scroll': undefined;
+    'resize': DOMRect;
+}
+export declare class ArticleRectObserver extends EventEmitter<EventMap> {
+    private resizeObserver;
+    private articleWidth;
+    private registry;
+    private scrollPos;
+    private animationFrame;
+    private parent;
+    private sectionsScrollMap;
+    constructor();
+    get scroll(): number;
+    getSectionScroll(sectionId: string): number;
+    getSectionTop(sectionId: string): number;
+    get width(): number;
+    private setScroll;
+    init(parent: HTMLElement): () => void;
+    register(el: HTMLElement, sectionId: string): () => void;
+    private handleScroll;
+    private handleResize;
+}
+export {};

package/dist/sdk-nextjs/utils/ArticleRectManager/useArticleRectObserver.d.ts

@@ -0,0 +1,2 @@
+import { ArticleRectObserver } from './ArticleRectObserver';
+export declare const useArticleRectObserver: (el?: HTMLElement | null) => ArticleRectObserver | null;

package/dist/sdk-nextjs/utils/ArticleRectManager/useSectionRegistry.d.ts

@@ -0,0 +1 @@
+export declare const useSectionRegistry: (sectionId: string, el?: HTMLElement | null) => void;

package/dist/sdk-nextjs/utils/EventEmitter.d.ts

@@ -0,0 +1,11 @@
+export type Listener<P> = (payload: P) => void;
+type Listeners<EventMap> = {
+    [E in keyof (EventMap)]?: Listener<EventMap[E]>[];
+};
+export declare abstract class EventEmitter<EventMap> {
+    protected listeners: Listeners<EventMap>;
+    on<E extends (keyof EventMap)>(event: E, listener: Listener<EventMap[E]>): () => void;
+    off<E extends (keyof EventMap)>(event: E, listener: Listener<EventMap[E]>): void;
+    protected emit<E extends (keyof EventMap)>(event: E, payload: EventMap[E]): void;
+}
+export {};

package/dist/sdk-nextjs/utils/RichTextConverter/RichTextConverter.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+import { Layout } from '../../../sdk/types/project/Layout';
+import { RichTextItem } from '../../../sdk/types/article/Item';
+export declare const FontStyles: Record<string, Record<string, string>>;
+export declare class RichTextConverter {
+    toHtml(richText: RichTextItem, layouts: Layout[]): [ReactNode[], string];
+    private serializeRanges;
+    private normalizeStyles;
+    private groupEntities;
+    private static fromRangeStylesToInline;
+}

package/dist/sdk-nextjs/utils/ScaleAnchorMap.d.ts

@@ -0,0 +1,11 @@
+export declare const ScaleAnchorMap: {
+    "top-left": string;
+    "top-center": string;
+    "top-right": string;
+    "middle-left": string;
+    "middle-center": string;
+    "middle-right": string;
+    "bottom-left": string;
+    "bottom-center": string;
+    "bottom-right": string;
+};

package/dist/sdk-nextjs/utils/StickyManager/StickyManager.d.ts

@@ -0,0 +1,10 @@
+export type TSticky = {
+    from: number;
+    to?: number;
+} | null;
+export declare class StickyManager {
+    private sticky;
+    constructor(sticky: TSticky);
+    getIsSticky(scroll: number): boolean;
+    getPosition(scroll: number, top: number): number;
+}

package/dist/sdk-nextjs/utils/Youtube/YouTubeIframeApiLoader.d.ts

@@ -0,0 +1,10 @@
+import { YT } from './YoutubeIframeApi';
+export declare class YouTubeIframeApiLoader {
+    private static instance;
+    static create(): YouTubeIframeApiLoader;
+    private loadingPromise;
+    private constructor();
+    getApi(): Promise<YT>;
+    private loadApi;
+}
+export declare function captureStackTrace(error: Error): void;

package/dist/sdk-nextjs/utils/Youtube/YoutubeIframeApi.d.ts

@@ -0,0 +1,89 @@
+export interface YT {
+    Player: YTPlayerConstructor;
+}
+export interface YTPlayerConstructor {
+    new (container: string | Element, params: YTPlayerParams): YTPlayer;
+}
+export interface YTEvent<Data> {
+    target: YTPlayer;
+    data: Data;
+}
+type YTBool = 0 | 1 | '0' | '1';
+export interface YTPlayerParams {
+    width?: string | number;
+    height?: string | number;
+    videoId?: string;
+    playerVars?: Partial<{
+        autoplay: YTBool;
+        cc_lang_pref: string;
+        cc_load_policy: YTBool;
+        color: string;
+        controls: YTBool;
+        disablekb: YTBool;
+        enablejsapi: YTBool;
+        end: number | string;
+        fs: YTBool;
+        hl: string;
+        iv_load_policy: 1 | 3 | '1' | '3';
+        list: string;
+        listType: 'playlist' | 'user_uploads';
+        loop: YTBool;
+        origin: string;
+        playlist: string;
+        playsinline: YTBool;
+        rel: YTBool;
+        start: number | string;
+        widget_referrer: string;
+    }>;
+    events?: Partial<{
+        onReady: (event: YTEvent<void>) => void;
+        onStateChange: (event: YTEvent<YTPlayerState>) => void;
+    }>;
+}
+export declare enum YTPlayerState {
+    Unstarted = -1,
+    Ended = 0,
+    Playing = 1,
+    Paused = 2,
+    Buffering = 3,
+    VideoCued = 5
+}
+export interface YTPlayer {
+    loadVideoById(videoId: string, startSeconds?: number): void;
+    loadVideoById(params: {
+        videoId: string;
+        startSeconds?: number;
+        endSeconds?: number;
+    }): void;
+    loadVideoByUrl(mediaContentUrl: string, startSeconds?: number): void;
+    loadVideoByUrl(params: {
+        mediaContentUrl: string;
+        startSeconds?: number;
+        endSeconds?: number;
+    }): void;
+    playVideo(): void;
+    pauseVideo(): void;
+    stopVideo(): void;
+    seekTo(seconds: number, allowSeekAhead: boolean): void;
+    mute(): void;
+    unMute(): void;
+    isMuted(): void;
+    setVolume(volume: number): void;
+    getVolume(): void;
+    setSize(width: number, height: number): void;
+    setLoop(loopPlaylists: boolean): void;
+    getVideoLoadedFraction(): number;
+    getPlayerState(): YTPlayerState;
+    getDuration(): number;
+    getVideoUrl(): string;
+    getVideoEmbedCode(): string;
+    getIframe(): HTMLIFrameElement | undefined;
+    destroy(): void;
+}
+declare global {
+    interface Window {
+        YT?: YT;
+        onYouTubeIframeAPIReady?: () => void;
+    }
+}
+export {};

package/dist/sdk-nextjs/utils/Youtube/useYouTubeIframeApi.d.ts

@@ -0,0 +1,2 @@
+import { YT } from './YoutubeIframeApi';
+export declare function useYouTubeIframeApi(): YT | undefined;

package/dist/sdk-nextjs/utils/areFillsVisible/areFillsVisible.d.ts

@@ -0,0 +1,23 @@
+export declare function areFillsVisible(fills: FillLayer[]): boolean;
+export type FillLayer = {
+    type: 'solid';
+    value: string;
+} | {
+    type: 'linear-gradient';
+    colors: {
+        value: string;
+    }[];
+} | {
+    type: 'radial-gradient';
+    colors: {
+        value: string;
+    }[];
+} | {
+    type: 'conic-gradient';
+    colors: {
+        value: string;
+    }[];
+} | {
+    type: 'image';
+    opacity: number;
+};

package/dist/sdk-nextjs/utils/binSearchInsertAt.d.ts

@@ -0,0 +1,5 @@
+type CompareFn<L, R> = (lhs: L, rhs: R) => number;
+type InsertStrategy<T> = (list: T[], item: T, compare: CompareFn<T, T>) => number;
+export declare function binSearchInsertAt<T, K>(list: T[], item: K, compare: CompareFn<K, T>): number;
+export declare function createInsert<T>(start: InsertStrategy<T>, compare: CompareFn<T, T>): (list: T[], item: T) => void;
+export {};

package/dist/sdk-nextjs/utils/castObject.d.ts

@@ -0,0 +1,5 @@
+type Ctor = {
+    new (...args: any): any;
+};
+export declare function castObject<O extends Ctor>(value: unknown, ctor: O): InstanceType<O>;
+export {};

package/dist/sdk-nextjs/utils/checkOverflowClipSupport.d.ts

@@ -0,0 +1 @@
+export declare function isOverflowClipSupported(): boolean;

package/dist/sdk-nextjs/utils/effects/useImageFx.d.ts

@@ -0,0 +1,7 @@
+interface FxParams {
+    imageUrl?: string;
+    fragmentShader: string | null;
+    controlsValues?: Record<string, number | [number, number]>;
+}
+export declare function useImageFx(canvas: HTMLCanvasElement | null | undefined, enabled: boolean, { imageUrl, fragmentShader, controlsValues }: FxParams, width: number, height: number): boolean;
+export {};

package/dist/sdk-nextjs/utils/effects/useVideoFx.d.ts

@@ -0,0 +1,7 @@
+interface FxParams {
+    videoUrl?: string;
+    fragmentShader: string | null;
+    controls?: Record<string, number | [number, number]>;
+}
+export declare function useVideoFx(canvas: HTMLCanvasElement | null | undefined, enabled: boolean, { videoUrl, fragmentShader, controls }: FxParams, width: number, height: number): boolean;
+export {};

package/dist/sdk-nextjs/utils/getAnchoredItemTop.d.ts

@@ -0,0 +1,2 @@
+import { AnchorSide } from '../../sdk/types/article/ItemArea';
+export declare function getAnchoredItemTop(top: number, sectionHeight: string, anchorSide?: AnchorSide): string;

package/dist/sdk-nextjs/utils/getCompoundBoundaryStyles.d.ts

@@ -0,0 +1,12 @@
+import { AreaAnchor, DimensionMode } from '../../sdk/types/article/ItemArea';
+export declare function getCompoundHeight(compoundSettings: CompoundSettings | undefined, height: number | undefined): string | undefined;
+export declare function getCompoundWidth(compoundSettings: CompoundSettings | undefined, width: number | undefined, isRichText: boolean, exemplary?: number): string | undefined;
+export declare function getCompoundTop(compoundSettings: CompoundSettings | undefined, top: number | undefined): string | undefined;
+export declare function getCompoundLeft(compoundSettings: CompoundSettings | undefined, left: number | undefined): string | undefined;
+export declare function getCompoundTransform(compoundSettings: CompoundSettings | undefined): string;
+type CompoundSettings = {
+    positionAnchor: AreaAnchor;
+    widthMode: DimensionMode;
+    heightMode: DimensionMode;
+};
+export {};

package/dist/sdk-nextjs/utils/getFill.d.ts

@@ -0,0 +1,2 @@
+import { FillLayer } from '../../sdk/types/article/Item';
+export declare function getFill(fill: FillLayer): string;

package/dist/sdk-nextjs/utils/getFontFamilyValue.d.ts

@@ -0,0 +1 @@
+export declare function getFontFamilyValue(value: string | undefined): string;

package/dist/sdk-nextjs/utils/getInvertedRanges.d.ts

@@ -0,0 +1,10 @@
+interface Range {
+    start: number;
+    end: number;
+}
+/**
+ * @param length
+ * @param ranges - SORTED array of ranges [start, end)
+ */
+export declare function getInvertedRanges(length: number, ranges: Range[]): Range[];
+export {};

package/dist/sdk-nextjs/utils/getItemTopStyle.d.ts

@@ -0,0 +1,2 @@
+import { AnchorSide } from '../../sdk/types/article/ItemArea';
+export declare function getItemTopStyle(top: number, anchorSide?: AnchorSide): string;

package/dist/sdk-nextjs/utils/getStyleFromItemStateAndParams.d.ts

@@ -0,0 +1 @@
+export declare function getStyleFromItemStateAndParams<T>(stateValue: T | undefined, paramsValue: T | undefined): T | undefined;

package/dist/sdk-nextjs/utils/getValidYoutubeUrl.d.ts

@@ -0,0 +1 @@
+export declare function getYoutubeId({ hostname, pathname, search }: URL): string;