@webflow/webflow-cli 1.0.0

package/dist/devlink-engine/_Builtin/Typography.d.ts

@@ -0,0 +1,291 @@
+import * as React from "react";
+import { type Props } from "./Basic";
+type HeadingProps = React.PropsWithChildren<{
+    tag?: "h1" | "h2" | "h3" | "h4" | "h5" | "h6";
+}> & React.HTMLAttributes<HTMLHeadingElement>;
+export declare function Heading({ tag, ...props }: HeadingProps): React.DetailedReactHTMLElement<{
+    children?: React.ReactNode;
+    defaultChecked?: boolean | undefined;
+    defaultValue?: string | number | readonly string[] | undefined;
+    suppressContentEditableWarning?: boolean | undefined;
+    suppressHydrationWarning?: boolean | undefined;
+    accessKey?: string | undefined;
+    autoFocus?: boolean | undefined;
+    className?: string | undefined;
+    contentEditable?: "inherit" | (boolean | "true" | "false") | undefined;
+    contextMenu?: string | undefined;
+    dir?: string | undefined;
+    draggable?: (boolean | "true" | "false") | undefined;
+    hidden?: boolean | undefined;
+    id?: string | undefined;
+    lang?: string | undefined;
+    nonce?: string | undefined;
+    placeholder?: string | undefined;
+    slot?: string | undefined;
+    spellCheck?: (boolean | "true" | "false") | undefined;
+    style?: React.CSSProperties | undefined;
+    tabIndex?: number | undefined;
+    title?: string | undefined;
+    translate?: "yes" | "no" | undefined;
+    radioGroup?: string | undefined;
+    role?: React.AriaRole | undefined;
+    about?: string | undefined;
+    content?: string | undefined;
+    datatype?: string | undefined;
+    inlist?: any;
+    prefix?: string | undefined;
+    property?: string | undefined;
+    rel?: string | undefined;
+    resource?: string | undefined;
+    rev?: string | undefined;
+    typeof?: string | undefined;
+    vocab?: string | undefined;
+    autoCapitalize?: string | undefined;
+    autoCorrect?: string | undefined;
+    autoSave?: string | undefined;
+    color?: string | undefined;
+    itemProp?: string | undefined;
+    itemScope?: boolean | undefined;
+    itemType?: string | undefined;
+    itemID?: string | undefined;
+    itemRef?: string | undefined;
+    results?: number | undefined;
+    security?: string | undefined;
+    unselectable?: "off" | "on" | undefined;
+    inputMode?: "none" | "text" | "search" | "tel" | "url" | "email" | "numeric" | "decimal" | undefined;
+    is?: string | undefined;
+    'aria-activedescendant'?: string | undefined;
+    'aria-atomic'?: (boolean | "true" | "false") | undefined;
+    'aria-autocomplete'?: "none" | "list" | "inline" | "both" | undefined;
+    'aria-busy'?: (boolean | "true" | "false") | undefined;
+    'aria-checked'?: boolean | "true" | "false" | "mixed" | undefined;
+    'aria-colcount'?: number | undefined;
+    'aria-colindex'?: number | undefined;
+    'aria-colspan'?: number | undefined;
+    'aria-controls'?: string | undefined;
+    'aria-current'?: boolean | "time" | "true" | "false" | "page" | "step" | "location" | "date" | undefined;
+    'aria-describedby'?: string | undefined;
+    'aria-details'?: string | undefined;
+    'aria-disabled'?: (boolean | "true" | "false") | undefined;
+    'aria-dropeffect'?: "none" | "link" | "copy" | "execute" | "move" | "popup" | undefined;
+    'aria-errormessage'?: string | undefined;
+    'aria-expanded'?: (boolean | "true" | "false") | undefined;
+    'aria-flowto'?: string | undefined;
+    'aria-grabbed'?: (boolean | "true" | "false") | undefined;
+    'aria-haspopup'?: boolean | "dialog" | "menu" | "true" | "false" | "grid" | "listbox" | "tree" | undefined;
+    'aria-hidden'?: (boolean | "true" | "false") | undefined;
+    'aria-invalid'?: boolean | "true" | "false" | "grammar" | "spelling" | undefined;
+    'aria-keyshortcuts'?: string | undefined;
+    'aria-label'?: string | undefined;
+    'aria-labelledby'?: string | undefined;
+    'aria-level'?: number | undefined;
+    'aria-live'?: "polite" | "off" | "assertive" | undefined;
+    'aria-modal'?: (boolean | "true" | "false") | undefined;
+    'aria-multiline'?: (boolean | "true" | "false") | undefined;
+    'aria-multiselectable'?: (boolean | "true" | "false") | undefined;
+    'aria-orientation'?: "horizontal" | "vertical" | undefined;
+    'aria-owns'?: string | undefined;
+    'aria-placeholder'?: string | undefined;
+    'aria-posinset'?: number | undefined;
+    'aria-pressed'?: boolean | "true" | "false" | "mixed" | undefined;
+    'aria-readonly'?: (boolean | "true" | "false") | undefined;
+    'aria-relevant'?: "text" | "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text additions" | "text removals" | undefined;
+    'aria-required'?: (boolean | "true" | "false") | undefined;
+    'aria-roledescription'?: string | undefined;
+    'aria-rowcount'?: number | undefined;
+    'aria-rowindex'?: number | undefined;
+    'aria-rowspan'?: number | undefined;
+    'aria-selected'?: (boolean | "true" | "false") | undefined;
+    'aria-setsize'?: number | undefined;
+    'aria-sort'?: "none" | "ascending" | "descending" | "other" | undefined;
+    'aria-valuemax'?: number | undefined;
+    'aria-valuemin'?: number | undefined;
+    'aria-valuenow'?: number | undefined;
+    'aria-valuetext'?: string | undefined;
+    dangerouslySetInnerHTML?: {
+        __html: string | TrustedHTML;
+    } | undefined;
+    onCopy?: React.ClipboardEventHandler<HTMLHeadingElement> | undefined;
+    onCopyCapture?: React.ClipboardEventHandler<HTMLHeadingElement> | undefined;
+    onCut?: React.ClipboardEventHandler<HTMLHeadingElement> | undefined;
+    onCutCapture?: React.ClipboardEventHandler<HTMLHeadingElement> | undefined;
+    onPaste?: React.ClipboardEventHandler<HTMLHeadingElement> | undefined;
+    onPasteCapture?: React.ClipboardEventHandler<HTMLHeadingElement> | undefined;
+    onCompositionEnd?: React.CompositionEventHandler<HTMLHeadingElement> | undefined;
+    onCompositionEndCapture?: React.CompositionEventHandler<HTMLHeadingElement> | undefined;
+    onCompositionStart?: React.CompositionEventHandler<HTMLHeadingElement> | undefined;
+    onCompositionStartCapture?: React.CompositionEventHandler<HTMLHeadingElement> | undefined;
+    onCompositionUpdate?: React.CompositionEventHandler<HTMLHeadingElement> | undefined;
+    onCompositionUpdateCapture?: React.CompositionEventHandler<HTMLHeadingElement> | undefined;
+    onFocus?: React.FocusEventHandler<HTMLHeadingElement> | undefined;
+    onFocusCapture?: React.FocusEventHandler<HTMLHeadingElement> | undefined;
+    onBlur?: React.FocusEventHandler<HTMLHeadingElement> | undefined;
+    onBlurCapture?: React.FocusEventHandler<HTMLHeadingElement> | undefined;
+    onChange?: React.FormEventHandler<HTMLHeadingElement> | undefined;
+    onChangeCapture?: React.FormEventHandler<HTMLHeadingElement> | undefined;
+    onBeforeInput?: React.FormEventHandler<HTMLHeadingElement> | undefined;
+    onBeforeInputCapture?: React.FormEventHandler<HTMLHeadingElement> | undefined;
+    onInput?: React.FormEventHandler<HTMLHeadingElement> | undefined;
+    onInputCapture?: React.FormEventHandler<HTMLHeadingElement> | undefined;
+    onReset?: React.FormEventHandler<HTMLHeadingElement> | undefined;
+    onResetCapture?: React.FormEventHandler<HTMLHeadingElement> | undefined;
+    onSubmit?: React.FormEventHandler<HTMLHeadingElement> | undefined;
+    onSubmitCapture?: React.FormEventHandler<HTMLHeadingElement> | undefined;
+    onInvalid?: React.FormEventHandler<HTMLHeadingElement> | undefined;
+    onInvalidCapture?: React.FormEventHandler<HTMLHeadingElement> | undefined;
+    onLoad?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onLoadCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onError?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onErrorCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onKeyDown?: React.KeyboardEventHandler<HTMLHeadingElement> | undefined;
+    onKeyDownCapture?: React.KeyboardEventHandler<HTMLHeadingElement> | undefined;
+    onKeyPress?: React.KeyboardEventHandler<HTMLHeadingElement> | undefined;
+    onKeyPressCapture?: React.KeyboardEventHandler<HTMLHeadingElement> | undefined;
+    onKeyUp?: React.KeyboardEventHandler<HTMLHeadingElement> | undefined;
+    onKeyUpCapture?: React.KeyboardEventHandler<HTMLHeadingElement> | undefined;
+    onAbort?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onAbortCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onCanPlay?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onCanPlayCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onCanPlayThrough?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onCanPlayThroughCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onDurationChange?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onDurationChangeCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onEmptied?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onEmptiedCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onEncrypted?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onEncryptedCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onEnded?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onEndedCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onLoadedData?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onLoadedDataCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onLoadedMetadata?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onLoadedMetadataCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onLoadStart?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onLoadStartCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onPause?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onPauseCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onPlay?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onPlayCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onPlaying?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onPlayingCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onProgress?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onProgressCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onRateChange?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onRateChangeCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onResize?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onResizeCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onSeeked?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onSeekedCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onSeeking?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onSeekingCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onStalled?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onStalledCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onSuspend?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onSuspendCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onTimeUpdate?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onTimeUpdateCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onVolumeChange?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onVolumeChangeCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onWaiting?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onWaitingCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onAuxClick?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onAuxClickCapture?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onClick?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onClickCapture?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onContextMenu?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onContextMenuCapture?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onDoubleClick?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onDoubleClickCapture?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onDrag?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragCapture?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragEnd?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragEndCapture?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragEnter?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragEnterCapture?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragExit?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragExitCapture?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragLeave?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragLeaveCapture?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragOver?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragOverCapture?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragStart?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragStartCapture?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDrop?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onDropCapture?: React.DragEventHandler<HTMLHeadingElement> | undefined;
+    onMouseDown?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseDownCapture?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseEnter?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseLeave?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseMove?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseMoveCapture?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseOut?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseOutCapture?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseOver?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseOverCapture?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseUp?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseUpCapture?: React.MouseEventHandler<HTMLHeadingElement> | undefined;
+    onSelect?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onSelectCapture?: React.ReactEventHandler<HTMLHeadingElement> | undefined;
+    onTouchCancel?: React.TouchEventHandler<HTMLHeadingElement> | undefined;
+    onTouchCancelCapture?: React.TouchEventHandler<HTMLHeadingElement> | undefined;
+    onTouchEnd?: React.TouchEventHandler<HTMLHeadingElement> | undefined;
+    onTouchEndCapture?: React.TouchEventHandler<HTMLHeadingElement> | undefined;
+    onTouchMove?: React.TouchEventHandler<HTMLHeadingElement> | undefined;
+    onTouchMoveCapture?: React.TouchEventHandler<HTMLHeadingElement> | undefined;
+    onTouchStart?: React.TouchEventHandler<HTMLHeadingElement> | undefined;
+    onTouchStartCapture?: React.TouchEventHandler<HTMLHeadingElement> | undefined;
+    onPointerDown?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerDownCapture?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerMove?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerMoveCapture?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerUp?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerUpCapture?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerCancel?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerCancelCapture?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerEnter?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerEnterCapture?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerLeave?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerLeaveCapture?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerOver?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerOverCapture?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerOut?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerOutCapture?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onGotPointerCapture?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onGotPointerCaptureCapture?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onLostPointerCapture?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onLostPointerCaptureCapture?: React.PointerEventHandler<HTMLHeadingElement> | undefined;
+    onScroll?: React.UIEventHandler<HTMLHeadingElement> | undefined;
+    onScrollCapture?: React.UIEventHandler<HTMLHeadingElement> | undefined;
+    onWheel?: React.WheelEventHandler<HTMLHeadingElement> | undefined;
+    onWheelCapture?: React.WheelEventHandler<HTMLHeadingElement> | undefined;
+    onAnimationStart?: React.AnimationEventHandler<HTMLHeadingElement> | undefined;
+    onAnimationStartCapture?: React.AnimationEventHandler<HTMLHeadingElement> | undefined;
+    onAnimationEnd?: React.AnimationEventHandler<HTMLHeadingElement> | undefined;
+    onAnimationEndCapture?: React.AnimationEventHandler<HTMLHeadingElement> | undefined;
+    onAnimationIteration?: React.AnimationEventHandler<HTMLHeadingElement> | undefined;
+    onAnimationIterationCapture?: React.AnimationEventHandler<HTMLHeadingElement> | undefined;
+    onTransitionEnd?: React.TransitionEventHandler<HTMLHeadingElement> | undefined;
+    onTransitionEndCapture?: React.TransitionEventHandler<HTMLHeadingElement> | undefined;
+}, HTMLElement>;
+export declare function Paragraph(props: Props<"p">): React.DetailedReactHTMLElement<import("./Basic").ElementProps<"p"> & {
+    children?: React.ReactNode;
+}, HTMLElement>;
+export declare function Emphasized(props: Props<"em">): JSX.Element;
+export declare function Strong(props: Props<"strong">): React.DetailedReactHTMLElement<import("./Basic").ElementProps<"strong"> & {
+    children?: React.ReactNode;
+}, HTMLElement>;
+type FigureProps = Props<"figure"> & {
+    figure: {
+        align: string;
+        type: string;
+    };
+};
+export declare function Figure({ className, figure, ...props }: FigureProps): JSX.Element;
+export declare function Figcaption(props: Props<"figcaption">): JSX.Element;
+export declare function Subscript(props: Props<"sub">): JSX.Element;
+export declare function Superscript(props: Props<"sup">): JSX.Element;
+export declare function RichText({ tag, className, ...props }: Props<"div", {
+    tag?: React.ElementType;
+}>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+export {};

package/dist/devlink-engine/_Builtin/Typography.js

@@ -0,0 +1,38 @@
+import * as React from "react";
+export function Heading({ tag = "h1", ...props }) {
+    return React.createElement(tag, props);
+}
+export function Paragraph(props) {
+    return React.createElement("p", props);
+}
+export function Emphasized(props) {
+    return React.createElement("em", { ...props });
+}
+export function Strong(props) {
+    return React.createElement("strong", props);
+}
+export function Figure({ className = "", figure, ...props }) {
+    const { type, align } = figure;
+    if (align) {
+        className += `w-richtext-align-${align} `;
+    }
+    if (type) {
+        className += `w-richtext-align-${type} `;
+    }
+    return React.createElement("figure", { className: className, ...props });
+}
+export function Figcaption(props) {
+    return React.createElement("figcaption", { ...props });
+}
+export function Subscript(props) {
+    return React.createElement("sub", { ...props });
+}
+export function Superscript(props) {
+    return React.createElement("sup", { ...props });
+}
+export function RichText({ tag = "div", className = "", ...props }) {
+    return React.createElement(tag, {
+        className: className + " w-richtext",
+        ...props,
+    });
+}

package/dist/devlink-engine/_Builtin/Video.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { Embed } from "../types";
+type VideoProps = {
+    className?: string;
+    options: Embed.Video;
+};
+export declare function Video({ className, options, ...props }: VideoProps): JSX.Element;
+export {};

package/dist/devlink-engine/_Builtin/Video.js

@@ -0,0 +1,8 @@
+import React from "react";
+import { cj } from "../utils";
+const getAspectRatio = ({ width, height }) => height && width ? height / width : 0;
+export function Video({ className = "", options = { height: 0, width: 0, title: "", url: "" }, ...props }) {
+    const { height, title, url, width } = options;
+    return (React.createElement("div", { ...props, style: { paddingTop: `${getAspectRatio(options) * 100}%` }, className: cj("w-video", "w-embed", className) },
+        React.createElement("iframe", { className: "embedly-embed", src: url, width: width, height: height, title: title, allowFullScreen: true, scrolling: "no", frameBorder: "0" })));
+}

package/dist/devlink-engine/_Builtin/YouTubeVideo.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+type YouTubeVideoProps = {
+    className?: string;
+    title: string;
+    videoId: string;
+    aspectRatio?: number;
+    startAt?: number;
+    showAllRelatedVideos?: boolean;
+    controls?: boolean;
+    autoplay?: boolean;
+    muted?: boolean;
+    privacyMode?: boolean;
+};
+export declare function YouTubeVideo({ className, title, videoId, aspectRatio, startAt, showAllRelatedVideos, controls, autoplay, muted, privacyMode, ...props }: YouTubeVideoProps): JSX.Element;
+export {};

package/dist/devlink-engine/_Builtin/YouTubeVideo.js

@@ -0,0 +1,27 @@
+import * as React from "react";
+import { cj } from "../utils";
+const DEFAULT_16_9_RATIO = 0.5617021276595745;
+export function YouTubeVideo({ className = "", title, videoId, aspectRatio = DEFAULT_16_9_RATIO, startAt = 0, showAllRelatedVideos = false, controls = true, autoplay = false, muted = false, privacyMode = false, ...props }) {
+    const baseUrl = privacyMode
+        ? "https://www.youtube-nocookie.com/embed"
+        : "https://www.youtube.com/embed";
+    const urlParams = Object.entries({
+        startAt,
+        showAllRelatedVideos,
+        controls,
+        autoplay,
+        muted,
+    })
+        .map(([k, v]) => `${k}=${Number(v)}`)
+        .join("&");
+    const iframeStyle = {
+        position: "absolute",
+        left: 0,
+        top: 0,
+        width: "100%",
+        height: "100%",
+        pointerEvents: "auto",
+    };
+    return (React.createElement("div", { ...props, style: { paddingTop: `${aspectRatio * 100}%` }, className: cj("w-embed-youtubevideo", className) },
+        React.createElement("iframe", { src: `${baseUrl}/${videoId}?${urlParams}`, title: title, allowFullScreen: true, scrolling: "no", frameBorder: "0", allow: "accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share", style: iframeStyle })));
+}

package/dist/devlink-engine/_Builtin/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./Basic";
+export * from "./Tabs";
+export * from "./Dropdown";
+export * from "./Navbar";
+export * from "./Facebook";
+export * from "./Typography";
+export * from "./Twitter";
+export * from "./Form";
+export * from "./Map";
+export * from "./Slider";
+export * from "./Video";
+export * from "./YouTubeVideo";
+export * from "./BackgroundVideo";

package/dist/devlink-engine/_Builtin/index.js

@@ -0,0 +1,13 @@
+export * from "./Basic";
+export * from "./Tabs";
+export * from "./Dropdown";
+export * from "./Navbar";
+export * from "./Facebook";
+export * from "./Typography";
+export * from "./Twitter";
+export * from "./Form";
+export * from "./Map";
+export * from "./Slider";
+export * from "./Video";
+export * from "./YouTubeVideo";
+export * from "./BackgroundVideo";

package/dist/devlink-engine/interactions.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+import { CSSModules } from "./types";
+type IXData = any;
+type IXEngine = {
+    init: (data: IXData) => void;
+};
+type InteractionProviderProps = {
+    children: React.ReactNode;
+    createEngine: () => IXEngine;
+};
+export declare const InteractionsProvider: React.FC<InteractionProviderProps>;
+export declare const useInteractions: (data: IXData, styles: CSSModules, ...nodes: string[]) => void;
+export {};

package/dist/devlink-engine/interactions.js

@@ -0,0 +1,86 @@
+import * as React from "react";
+import { debounce, replaceSelector } from "./utils";
+const enhanceIXData = (data, styles) => {
+    const newIXData = structuredClone(data);
+    for (const id in newIXData.events) {
+        const { target, targets } = newIXData.events[id];
+        for (const t of [target, ...targets]) {
+            if (t.appliesTo !== "CLASS")
+                continue;
+            t.selector = replaceSelector(t.selector, styles);
+        }
+    }
+    for (const id in newIXData.actionLists) {
+        const { actionItemGroups, continuousParameterGroups } = newIXData.actionLists[id];
+        if (actionItemGroups) {
+            for (const { actionItems } of actionItemGroups) {
+                for (const { config } of actionItems) {
+                    const { selector } = config.target;
+                    if (!selector)
+                        continue;
+                    config.target.selector = replaceSelector(selector, styles);
+                }
+            }
+        }
+        if (continuousParameterGroups) {
+            for (const group of continuousParameterGroups) {
+                for (const { actionItems } of group.continuousActionGroups) {
+                    for (const { config } of actionItems) {
+                        const { selector } = config.target;
+                        if (!selector)
+                            continue;
+                        config.target.selector = replaceSelector(selector, styles);
+                    }
+                }
+            }
+        }
+    }
+    return newIXData;
+};
+const IXContext = React.createContext(null);
+export const InteractionsProvider = ({ children, createEngine, }) => {
+    const ixData = React.useRef({});
+    const ixEngine = React.useRef();
+    const debouncedInit = React.useRef(debounce((data) => {
+        if (!ixEngine.current)
+            ixEngine.current = createEngine();
+        ixEngine.current.init(data);
+        document.dispatchEvent(new CustomEvent("IX2_PAGE_UPDATE"));
+    }));
+    const initEngine = React.useCallback((data, styles) => {
+        const newIXData = enhanceIXData(data, styles);
+        if (!newIXData)
+            return;
+        if (!ixData.current.site) {
+            ixData.current.site = newIXData.site;
+        }
+        ixData.current.events = {
+            ...ixData.current.events,
+            ...newIXData.events,
+        };
+        ixData.current.actionLists = {
+            ...ixData.current.actionLists,
+            ...newIXData.actionLists,
+        };
+        debouncedInit.current(ixData.current);
+    }, []);
+    return React.createElement(IXContext.Provider, { value: initEngine }, children);
+};
+export const useInteractions = (data, styles, ...nodes) => {
+    const initEngine = React.useContext(IXContext);
+    React.useEffect(() => {
+        if (initEngine)
+            initEngine(data, styles, ...nodes);
+    }, [initEngine, data, nodes, styles]);
+    React.useEffect(() => {
+        if (document.querySelector("html")?.hasAttribute("data-wf-page"))
+            return;
+        const hasPageInteractions = Object.values(data.events).some((event) => event.target.appliesTo === "PAGE");
+        if (hasPageInteractions) {
+            document
+                .querySelector("html")
+                ?.setAttribute("data-wf-page", "wf-page-id");
+            document.dispatchEvent(new CustomEvent("IX2_PAGE_UPDATE"));
+        }
+    }, []);
+};

package/dist/devlink-engine/types.d.ts

@@ -0,0 +1,32 @@
+import * as React from "react";
+export type CSSModules = {
+    [sel: string]: string;
+};
+export declare namespace Basic {
+    type PreloadedLink = {
+        preload?: "prerender" | "prefetch" | "none";
+    };
+    type TargetedLink = {
+        target?: "_self" | "_blank";
+    };
+    type PreloadedAndTargetedLink = PreloadedLink & TargetedLink;
+    export type Link = {
+        href: string;
+    } & PreloadedAndTargetedLink;
+    export type RichTextChildren = React.ReactNode;
+    export {};
+}
+export declare namespace Asset {
+    type Image = string;
+}
+export declare namespace Embed {
+    type Video = {
+        height: number;
+        width: number;
+        title: string;
+        url: string;
+    };
+}
+export declare namespace Visibility {
+    type VisibilityConditions = boolean;
+}

package/dist/devlink-engine/types.js

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

package/dist/devlink-engine/utils.d.ts

@@ -0,0 +1,66 @@
+import * as React from "react";
+import { CSSModules } from "./types";
+export declare const cx: (style: CSSModules, ...classNames: string[]) => string;
+/**
+ * The cj function takes care of eliminting classes that don't exist and joining
+ * them with a white space.
+ */
+export declare const cj: (...classNames: (string | boolean | undefined)[]) => string;
+export declare const removeUnescaped: (value: string) => string;
+export declare const replaceSelector: (selector: string, styles: CSSModules) => string;
+export declare function debounce<T extends (...args: any[]) => void>(this: void, func: T, timeout?: number): (...args: Parameters<T>) => void;
+/**
+ * cubic bezier functions have been extracted from this repository:
+ * https://github.com/ai/easings.net
+ */
+export declare const EASING_FUNCTIONS: {
+    linear: string;
+    ease: string;
+    "ease-in": string;
+    "ease-out": string;
+    "ease-in-out": string;
+    "ease-in-sine": string;
+    "ease-out-sine": string;
+    "ease-in-out-sine": string;
+    "ease-in-quad": string;
+    "ease-out-quad": string;
+    "ease-in-out-quad": string;
+    "ease-in-cubic": string;
+    "ease-out-cubic": string;
+    "ease-in-out-cubic": string;
+    "ease-in-quart": string;
+    "ease-out-quart": string;
+    "ease-in-out-quart": string;
+    "ease-in-quint": string;
+    "ease-out-quint": string;
+    "ease-in-out-quint": string;
+    "ease-in-expo": string;
+    "ease-out-expo": string;
+    "ease-in-out-expo": string;
+    "ease-in-circ": string;
+    "ease-out-circ": string;
+    "ease-in-out-circ": string;
+    "ease-in-back": string;
+    "ease-out-back": string;
+    "ease-in-out-back": string;
+};
+export declare const isServer: boolean;
+export declare const useLayoutEffect: typeof React.useLayoutEffect;
+export declare function useResizeObserver(ref: React.RefObject<HTMLElement>, fn: (entry: ResizeObserverEntry) => void): void;
+export declare function isUrl(str: string): boolean;
+export declare function loadScript(src: string, options?: {
+    async?: boolean;
+    type?: string;
+    defer?: boolean;
+    cacheRegex?: RegExp;
+}): Promise<unknown>;
+export declare const KEY_CODES: {
+    ARROW_LEFT: string;
+    ARROW_UP: string;
+    ARROW_RIGHT: string;
+    ARROW_DOWN: string;
+    SPACE: string;
+    ENTER: string;
+    HOME: string;
+    END: string;
+};