@builder.io/sdk-solid 0.12.6 → 0.12.8

package/dist/index.d.ts

@@ -6,6 +6,23 @@ interface JSONObject$1 {
 }
 interface JSONArray$1 extends Array<JSONValue$1> {
 }
+interface AnimationStep {
+    styles: {
+        [key: string]: string;
+    };
+    delay?: number;
+}
+interface BuilderAnimation {
+    elementId: string;
+    trigger: string;
+    steps: AnimationStep[];
+    duration: number;
+    delay?: number;
+    easing?: string;
+    id?: string;
+    repeat?: boolean;
+    thresholdPercent?: number;
+}
 /** @todo typedoc this */
 interface BuilderBlock {
     '@type': '@builder.io/sdk:Element';
@@ -54,7 +71,7 @@ interface BuilderBlock {
         collection: string;
         itemName?: string;
     } | null;
-    animations?: any[];
+    animations?: BuilderAnimation[];
     style?: Partial<CSSStyleDeclaration>;
     href?: string;
     /**
@@ -701,6 +718,86 @@ type Settings = {
 };
 declare function setEditorSettings(newSettings: Settings): void;
 
+type QueryObject = Record<string, string | string[]>;
+/**
+ * Receives a `URLSearchParams` object or a regular query object, and returns the subset of query params that are
+ * relevant to the Builder SDK.
+ *
+ * @returns
+ */
+declare const getBuilderSearchParams: (_options: QueryObject | URLSearchParams | undefined) => QueryObject;
+
+interface Event {
+    /**
+     * The type of your event.
+     *
+     * Examples: `click`, `conversion`, `pageview`, `impression`
+     */
+    type: string;
+    data: {
+        /**
+         * (Optional) The content's ID. Useful if this event pertains to a specific piece of content.
+         */
+        contentId?: string;
+        /**
+         * This is the ID of the space that the content belongs to.
+         */
+        ownerId: string;
+        /**
+         * (Optional) metadata that you want to provide with your event.
+         */
+        metadata?: Dictionary<any>;
+        /**
+         * Session ID of the user. This is provided by the SDK by checking session storage.
+         */
+        sessionId: string | undefined;
+        /**
+         * Visitor ID of the user. This is provided by the SDK by checking cookies.
+         */
+        visitorId: string | undefined;
+        /**
+         * (Optional) If running an A/B test, the ID of the variation that the user is in.
+         */
+        variationId?: string;
+        [index: string]: any;
+    };
+}
+type EventProperties = Pick<Event, 'type'> & Pick<Event['data'], 'contentId' | 'variationId' | 'metadata'> & {
+    /**
+     * Your organization's API key.
+     */
+    apiKey: Event['data']['ownerId'];
+    /**
+     * (Optional) Any additional (non-metadata) properties to add to the event.
+     */
+    [index: string]: any;
+};
+declare const track: (args: EventProperties) => Promise<void | Response>;
+
+type SubscribeToEditor = (
+/**
+ * The Builder `model` to subscribe to
+ */
+model: string, 
+/**
+ * The callback function to call when the content is updated.
+ */
+callback: (updatedContent: BuilderContent) => void, 
+/**
+ * Extra options for the listener.
+ */
+options?: {
+    /**
+     * List of hosts to allow editing content from.
+     */
+    trustedHosts?: string[] | undefined;
+}) => () => void;
+/**
+ * Subscribes to the Builder editor and listens to `content` updates of a certain `model`.
+ * Sends the updated `content` to the `callback` function.
+ */
+declare const subscribeToEditor: SubscribeToEditor;
+
 interface GetContentOptions {
     /** The model to get content for (required) */
     model: string;
@@ -844,88 +941,6 @@ interface GetContentOptions {
     includeUnpublished?: boolean;
 }
 
-/**
- * Returns the first content entry that matches the given options.
- */
-declare function fetchOneEntry(options: GetContentOptions): Promise<BuilderContent | null>;
-/**
- * @deprecated `getContent` was renamed to `fetchOneEntry`. This is a temporary alias to avoid breaking changes.
- *
- * NOTE: consider using `fetchBuilderProps` instead for easier setup.
- */
-declare const getContent: typeof fetchOneEntry;
-type ContentResults = {
-    results: BuilderContent[];
-};
-/**
- * @internal Exported only for testing purposes. Do not use.
- */
-declare const _processContentResult: (options: GetContentOptions, content: ContentResults, url?: URL) => Promise<BuilderContent[]>;
-/**
- * Returns a paginated array of entries that match the given options.
- */
-declare function fetchEntries(options: GetContentOptions): Promise<BuilderContent[]>;
-/**
- * @deprecated `getAllContent` was renamed to `fetchEntries`. This is a temporary alias to avoid breaking changes.
- */
-declare const getAllContent: typeof fetchEntries;
-
-type QueryObject = Record<string, string | string[]>;
-/**
- * Receives a `URLSearchParams` object or a regular query object, and returns the subset of query params that are
- * relevant to the Builder SDK.
- *
- * @returns
- */
-declare const getBuilderSearchParams: (_options: QueryObject | URLSearchParams | undefined) => QueryObject;
-
-interface Event {
-    /**
-     * The type of your event.
-     *
-     * Examples: `click`, `conversion`, `pageview`, `impression`
-     */
-    type: string;
-    data: {
-        /**
-         * (Optional) The content's ID. Useful if this event pertains to a specific piece of content.
-         */
-        contentId?: string;
-        /**
-         * This is the ID of the space that the content belongs to.
-         */
-        ownerId: string;
-        /**
-         * (Optional) metadata that you want to provide with your event.
-         */
-        metadata?: Dictionary<any>;
-        /**
-         * Session ID of the user. This is provided by the SDK by checking session storage.
-         */
-        sessionId: string | undefined;
-        /**
-         * Visitor ID of the user. This is provided by the SDK by checking cookies.
-         */
-        visitorId: string | undefined;
-        /**
-         * (Optional) If running an A/B test, the ID of the variation that the user is in.
-         */
-        variationId?: string;
-        [index: string]: any;
-    };
-}
-type EventProperties = Pick<Event, 'type'> & Pick<Event['data'], 'contentId' | 'variationId' | 'metadata'> & {
-    /**
-     * Your organization's API key.
-     */
-    apiKey: Event['data']['ownerId'];
-    /**
-     * (Optional) Any additional (non-metadata) properties to add to the event.
-     */
-    [index: string]: any;
-};
-declare const track: (args: EventProperties) => Promise<void | Response>;
-
 type GetBuilderPropsOptions = (Omit<GetContentOptions, 'model'> & {
     model?: string;
 }) & ({
@@ -976,4 +991,30 @@ type GetBuilderPropsOptions = (Omit<GetContentOptions, 'model'> & {
  */
 declare const fetchBuilderProps: (_args: GetBuilderPropsOptions) => Promise<ContentVariantsPrps>;
 
-export { Blocks, BlocksProps, Button, ButtonProps, ColumnProps, Columns, ComponentInfo, ContentVariants as Content, ContentVariantsPrps as ContentProps, FragmentComponent as Fragment, FragmentProps, Image, ImageProps, InsertMenuConfig, InsertMenuItem, RegisteredComponent, RenderBlocks, RenderContent, SectionComponent as Section, SectionProps, Settings, Symbol, SymbolProps, Text, TextProps, Video, VideoProps, _processContentResult, createRegisterComponentMessage, fetchBuilderProps, fetchEntries, fetchOneEntry, getAllContent, getBuilderSearchParams, getContent, isEditing, isPreviewing, register, setEditorSettings, track };
+/**
+ * Returns the first content entry that matches the given options.
+ */
+declare function fetchOneEntry(options: GetContentOptions): Promise<BuilderContent | null>;
+/**
+ * @deprecated `getContent` was renamed to `fetchOneEntry`. This is a temporary alias to avoid breaking changes.
+ *
+ * NOTE: consider using `fetchBuilderProps` instead for easier setup.
+ */
+declare const getContent: typeof fetchOneEntry;
+type ContentResults = {
+    results: BuilderContent[];
+};
+/**
+ * @internal Exported only for testing purposes. Do not use.
+ */
+declare const _processContentResult: (options: GetContentOptions, content: ContentResults, url?: URL) => Promise<BuilderContent[]>;
+/**
+ * Returns a paginated array of entries that match the given options.
+ */
+declare function fetchEntries(options: GetContentOptions): Promise<BuilderContent[]>;
+/**
+ * @deprecated `getAllContent` was renamed to `fetchEntries`. This is a temporary alias to avoid breaking changes.
+ */
+declare const getAllContent: typeof fetchEntries;
+
+export { Blocks, BlocksProps, BuilderBlock, BuilderContent, Button, ButtonProps, ColumnProps, Columns, ComponentInfo, ContentVariants as Content, ContentVariantsPrps as ContentProps, FragmentComponent as Fragment, FragmentProps, Image, ImageProps, InsertMenuConfig, InsertMenuItem, RegisteredComponent, RenderBlocks, RenderContent, SectionComponent as Section, SectionProps, Settings, Symbol, SymbolProps, Text, TextProps, Video, VideoProps, _processContentResult, createRegisterComponentMessage, fetchBuilderProps, fetchEntries, fetchOneEntry, getAllContent, getBuilderSearchParams, getContent, isEditing, isPreviewing, register, setEditorSettings, subscribeToEditor, track };

package/lib/browser/dev.js

@@ -423,6 +423,212 @@ function getProcessedBlock({
   }
 }
 
+// src/components/block/animator.ts
+function throttle(func, wait, options = {}) {
+  let context;
+  let args;
+  let result;
+  let timeout = null;
+  let previous = 0;
+  const later = function() {
+    previous = options.leading === false ? 0 : Date.now();
+    timeout = null;
+    result = func.apply(context, args);
+    if (!timeout)
+      context = args = null;
+  };
+  return function() {
+    const now = Date.now();
+    if (!previous && options.leading === false)
+      previous = now;
+    const remaining = wait - (now - previous);
+    context = this;
+    args = arguments;
+    if (remaining <= 0 || remaining > wait) {
+      if (timeout) {
+        clearTimeout(timeout);
+        timeout = null;
+      }
+      previous = now;
+      result = func.apply(context, args);
+      if (!timeout)
+        context = args = null;
+    } else if (!timeout && options.trailing !== false) {
+      timeout = setTimeout(later, remaining);
+    }
+    return result;
+  };
+}
+function assign(target, ..._args) {
+  const to = Object(target);
+  for (let index = 1; index < arguments.length; index++) {
+    const nextSource = arguments[index];
+    if (nextSource != null) {
+      for (const nextKey in nextSource) {
+        if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
+          to[nextKey] = nextSource[nextKey];
+        }
+      }
+    }
+  }
+  return to;
+}
+var camelCaseToKebabCase = (str) => str ? str.replace(/([A-Z])/g, (g) => `-${g[0].toLowerCase()}`) : "";
+function bindAnimations(animations) {
+  for (const animation of animations) {
+    switch (animation.trigger) {
+      case "pageLoad":
+        triggerAnimation(animation);
+        break;
+      case "hover":
+        bindHoverAnimation(animation);
+        break;
+      case "scrollInView":
+        bindScrollInViewAnimation(animation);
+        break;
+    }
+  }
+}
+function warnElementNotPresent(id) {
+  console.warn(`Cannot animate element: element with ID ${id} not found!`);
+}
+function augmentAnimation(animation, element) {
+  const stylesUsed = getAllStylesUsed(animation);
+  const computedStyle = getComputedStyle(element);
+  const firstStyles = animation.steps[0].styles;
+  const lastStyles = animation.steps[animation.steps.length - 1].styles;
+  const bothStyles = [firstStyles, lastStyles];
+  for (const styles of bothStyles) {
+    for (const style of stylesUsed) {
+      if (!(style in styles)) {
+        styles[style] = computedStyle[style];
+      }
+    }
+  }
+}
+function getAllStylesUsed(animation) {
+  const properties = [];
+  for (const step of animation.steps) {
+    for (const key in step.styles) {
+      if (properties.indexOf(key) === -1) {
+        properties.push(key);
+      }
+    }
+  }
+  return properties;
+}
+function triggerAnimation(animation) {
+  const elements = Array.prototype.slice.call(document.getElementsByClassName(animation.elementId || animation.id || ""));
+  if (!elements.length) {
+    warnElementNotPresent(animation.elementId || animation.id || "");
+    return;
+  }
+  Array.from(elements).forEach((element) => {
+    augmentAnimation(animation, element);
+    element.style.transition = "none";
+    element.style.transitionDelay = "0";
+    assign(element.style, animation.steps[0].styles);
+    setTimeout(() => {
+      element.style.transition = `all ${animation.duration}s ${camelCaseToKebabCase(animation.easing)}`;
+      if (animation.delay) {
+        element.style.transitionDelay = animation.delay + "s";
+      }
+      assign(element.style, animation.steps[1].styles);
+      setTimeout(() => {
+        element.style.transition = "";
+        element.style.transitionDelay = "";
+      }, (animation.delay || 0) * 1e3 + animation.duration * 1e3 + 100);
+    });
+  });
+}
+function bindHoverAnimation(animation) {
+  const elements = Array.prototype.slice.call(document.getElementsByClassName(animation.elementId || animation.id || ""));
+  if (!elements.length) {
+    warnElementNotPresent(animation.elementId || animation.id || "");
+    return;
+  }
+  Array.from(elements).forEach((element) => {
+    augmentAnimation(animation, element);
+    const defaultState = animation.steps[0].styles;
+    const hoverState = animation.steps[1].styles;
+    function attachDefaultState() {
+      assign(element.style, defaultState);
+    }
+    function attachHoverState() {
+      assign(element.style, hoverState);
+    }
+    attachDefaultState();
+    element.addEventListener("mouseenter", attachHoverState);
+    element.addEventListener("mouseleave", attachDefaultState);
+    setTimeout(() => {
+      element.style.transition = `all ${animation.duration}s ${camelCaseToKebabCase(animation.easing)}`;
+      if (animation.delay) {
+        element.style.transitionDelay = animation.delay + "s";
+      }
+    });
+  });
+}
+function bindScrollInViewAnimation(animation) {
+  const elements = Array.prototype.slice.call(document.getElementsByClassName(animation.elementId || animation.id || ""));
+  if (!elements.length) {
+    warnElementNotPresent(animation.elementId || animation.id || "");
+    return;
+  }
+  Array.from(elements).forEach((element) => {
+    augmentAnimation(animation, element);
+    let triggered = false;
+    let pendingAnimation = false;
+    function immediateOnScroll() {
+      if (!triggered && isScrolledIntoView(element)) {
+        triggered = true;
+        pendingAnimation = true;
+        setTimeout(() => {
+          assign(element.style, animation.steps[1].styles);
+          if (!animation.repeat) {
+            document.removeEventListener("scroll", onScroll);
+          }
+          setTimeout(() => {
+            pendingAnimation = false;
+            if (!animation.repeat) {
+              element.style.transition = "";
+              element.style.transitionDelay = "";
+            }
+          }, (animation.duration + (animation.delay || 0)) * 1e3 + 100);
+        });
+      } else if (animation.repeat && triggered && !pendingAnimation && !isScrolledIntoView(element)) {
+        triggered = false;
+        assign(element.style, animation.steps[0].styles);
+      }
+    }
+    const onScroll = throttle(immediateOnScroll, 200, {
+      leading: false
+    });
+    function isScrolledIntoView(elem) {
+      const rect = elem.getBoundingClientRect();
+      const windowHeight = window.innerHeight;
+      const thresholdPercent = (animation.thresholdPercent || 0) / 100;
+      const threshold = thresholdPercent * windowHeight;
+      return rect.bottom > threshold && rect.top < windowHeight - threshold;
+    }
+    const defaultState = animation.steps[0].styles;
+    function attachDefaultState() {
+      assign(element.style, defaultState);
+    }
+    attachDefaultState();
+    setTimeout(() => {
+      element.style.transition = `all ${animation.duration}s ${camelCaseToKebabCase(animation.easing)}`;
+      if (animation.delay) {
+        element.style.transitionDelay = animation.delay + "s";
+      }
+    });
+    document.addEventListener("scroll", onScroll, {
+      capture: true,
+      passive: true
+    });
+    immediateOnScroll();
+  });
+}
+
 // src/components/block/block.helpers.ts
 var getComponent = ({
   block,
@@ -998,6 +1204,16 @@ function Block(props) {
       isInteractive: !blockComponent()?.isRSC
     };
   }
+  onMount(() => {
+    const blockId = processedBlock().id;
+    const animations = processedBlock().animations;
+    if (animations && blockId) {
+      bindAnimations(animations.filter((item) => item.trigger !== "hover").map((animation) => ({
+        ...animation,
+        elementId: blockId
+      })));
+    }
+  });
   return createComponent(Show, {
     get when() {
       return canShowBlock();
@@ -3152,13 +3368,6 @@ async function fetchEntries(options) {
 }
 var getAllContent = fetchEntries;
 
-// src/functions/is-from-trusted-host.ts
-var DEFAULT_TRUSTED_HOSTS = ["*.beta.builder.io", "beta.builder.io", "builder.io", "localhost", "qa.builder.io"];
-function isFromTrustedHost(trustedHosts, e) {
-  const url = new URL(e.origin), hostname = url.hostname;
-  return (trustedHosts || DEFAULT_TRUSTED_HOSTS).findIndex((trustedHost) => trustedHost.startsWith("*.") ? hostname.endsWith(trustedHost.slice(1)) : trustedHost === hostname) > -1;
-}
-
 // src/functions/is-previewing.ts
 function isPreviewing() {
   if (!isBrowser()) {
@@ -3409,8 +3618,15 @@ var getInteractionPropertiesForEvent = (event) => {
   };
 };
 
+// src/functions/is-from-trusted-host.ts
+var DEFAULT_TRUSTED_HOSTS = ["*.beta.builder.io", "beta.builder.io", "builder.io", "localhost", "qa.builder.io"];
+function isFromTrustedHost(trustedHosts, e) {
+  const url = new URL(e.origin), hostname = url.hostname;
+  return (trustedHosts || DEFAULT_TRUSTED_HOSTS).findIndex((trustedHost) => trustedHost.startsWith("*.") ? hostname.endsWith(trustedHost.slice(1)) : trustedHost === hostname) > -1;
+}
+
 // src/constants/sdk-version.ts
-var SDK_VERSION = "0.12.6";
+var SDK_VERSION = "0.12.8";
 
 // src/functions/register.ts
 var registry = {};
@@ -3547,6 +3763,66 @@ var setupBrowserForEditing = (options = {}) => {
   }
 };
 
+// src/helpers/subscribe-to-editor.ts
+var createEditorListener = ({
+  model,
+  trustedHosts,
+  callbacks
+}) => {
+  return (event) => {
+    if (!isFromTrustedHost(trustedHosts, event)) {
+      return;
+    }
+    const {
+      data
+    } = event;
+    if (data) {
+      switch (data.type) {
+        case "builder.configureSdk": {
+          callbacks.configureSdk(data.data);
+          break;
+        }
+        case "builder.triggerAnimation": {
+          callbacks.animation(data.data);
+          break;
+        }
+        case "builder.contentUpdate": {
+          const messageContent = data.data;
+          const key = messageContent.key || messageContent.alias || messageContent.entry || messageContent.modelName;
+          const contentData = messageContent.data;
+          if (key === model) {
+            callbacks.contentUpdate(contentData);
+          }
+          break;
+        }
+      }
+    }
+  };
+};
+var subscribeToEditor = (model, callback, options) => {
+  if (!isBrowser) {
+    logger.warn("`subscribeToEditor` only works in the browser. It currently seems to be running on the server.");
+    return () => {
+    };
+  }
+  setupBrowserForEditing();
+  const listener = createEditorListener({
+    callbacks: {
+      contentUpdate: callback,
+      animation: () => {
+      },
+      configureSdk: () => {
+      }
+    },
+    model,
+    trustedHosts: options?.trustedHosts
+  });
+  window.addEventListener("message", listener);
+  return () => {
+    window.removeEventListener("message", listener);
+  };
+};
+
 // src/components/content/components/enable-editor.tsx
 function EnableEditor(props) {
   const [forceReRenderCount, setForceReRenderCount] = createSignal(0);
@@ -3590,16 +3866,11 @@ function EnableEditor(props) {
     }));
   }
   function processMessage(event) {
-    if (!isFromTrustedHost(props.trustedHosts, event)) {
-      return;
-    }
-    const {
-      data
-    } = event;
-    if (data) {
-      switch (data.type) {
-        case "builder.configureSdk": {
-          const messageContent = data.data;
+    return createEditorListener({
+      model: props.model,
+      trustedHosts: props.trustedHosts,
+      callbacks: {
+        configureSdk: (messageContent) => {
           const {
             breakpoints,
             contentId
@@ -3613,22 +3884,18 @@ function EnableEditor(props) {
                 breakpoints
               }
             });
-          }
-          setForceReRenderCount(forceReRenderCount() + 1);
-          break;
-        }
-        case "builder.contentUpdate": {
-          const messageContent = data.data;
-          const key = messageContent.key || messageContent.alias || messageContent.entry || messageContent.modelName;
-          const contentData = messageContent.data;
-          if (key === props.model) {
-            mergeNewContent(contentData);
             setForceReRenderCount(forceReRenderCount() + 1);
           }
-          break;
+        },
+        animation: (animation) => {
+          triggerAnimation(animation);
+        },
+        contentUpdate: (newContent) => {
+          mergeNewContent(newContent);
+          setForceReRenderCount(forceReRenderCount() + 1);
         }
       }
-    }
+    })(event);
   }
   function evaluateJsCode() {
     const jsCode = props.builderContextSignal.content?.data?.jsCode;
@@ -4472,4 +4739,4 @@ var fetchBuilderProps = async (_args) => {
   };
 };
 
-export { blocks_default as Blocks, button_default as Button, columns_default as Columns, content_variants_default as Content, fragment_default as Fragment, image_default as Image, RenderBlocks, RenderContent, section_default as Section, symbol_default as Symbol, text_default as Text, video_default as Video, _processContentResult, createRegisterComponentMessage, fetchBuilderProps, fetchEntries, fetchOneEntry, getAllContent, getBuilderSearchParams, getContent, isEditing, isPreviewing, register, setEditorSettings, track };
+export { blocks_default as Blocks, button_default as Button, columns_default as Columns, content_variants_default as Content, fragment_default as Fragment, image_default as Image, RenderBlocks, RenderContent, section_default as Section, symbol_default as Symbol, text_default as Text, video_default as Video, _processContentResult, createRegisterComponentMessage, fetchBuilderProps, fetchEntries, fetchOneEntry, getAllContent, getBuilderSearchParams, getContent, isEditing, isPreviewing, register, setEditorSettings, subscribeToEditor, track };