@builder.io/sdk-react-native 0.0.1-6 → 0.0.1-62

package/src/functions/get-content/ab-testing.js

@@ -0,0 +1,39 @@
+import * as React from 'react';
+const handleABTesting = (item, testGroups) => {
+  if (item.variations && Object.keys(item.variations).length) {
+    const testGroup = item.id ? testGroups[item.id] : void 0;
+    const variationValue = testGroup ? item.variations[testGroup] : void 0;
+    if (testGroup && variationValue) {
+      item.data = variationValue.data;
+      item.testVariationId = variationValue.id;
+      item.testVariationName = variationValue.name;
+    } else {
+      let n = 0;
+      const random = Math.random();
+      let set = false;
+      for (const id in item.variations) {
+        const variation = item.variations[id];
+        const testRatio = variation.testRatio;
+        n += testRatio;
+        if (random < n) {
+          const variationName = variation.name || (variation.id === item.id ? "Default variation" : "");
+          set = true;
+          Object.assign(item, {
+            data: variation.data,
+            testVariationId: variation.id,
+            testVariationName: variationName
+          });
+        }
+      }
+      if (!set) {
+        Object.assign(item, {
+          testVariationId: item.id,
+          testVariationName: "Default"
+        });
+      }
+    }
+  }
+};
+export {
+  handleABTesting
+};

package/src/functions/get-content/fn.test.js

@@ -0,0 +1,32 @@
+import * as React from 'react';
+import { generateContentUrl } from ".";
+const testKey = "YJIGb4i01jvw0SRdL5Bt";
+const testModel = "page";
+const testId = "c1b81bab59704599b997574eb0736def";
+const options = {
+  cachebust: "true",
+  noCache: "true",
+  "overrides.037948e52eaf4743afed464f02c70da4": "037948e52eaf4743afed464f02c70da4",
+  "overrides.page": "037948e52eaf4743afed464f02c70da4",
+  "overrides.page:/": "037948e52eaf4743afed464f02c70da4",
+  preview: "page"
+};
+describe("Generate Content URL", () => {
+  test("generates the proper value for a simple query", () => {
+    const output = generateContentUrl({
+      apiKey: testKey,
+      model: testModel,
+      query: { id: testId }
+    });
+    expect(output).toMatchSnapshot();
+  });
+  test("Handles overrides correctly", () => {
+    const output = generateContentUrl({
+      apiKey: testKey,
+      model: testModel,
+      query: { id: testId },
+      options
+    });
+    expect(output).toMatchSnapshot();
+  });
+});

package/src/functions/get-content/index.js

@@ -0,0 +1,94 @@
+import * as React from 'react';
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { flatten } from "../../helpers/flatten.js";
+import { getFetch } from "../get-fetch.js";
+import { handleABTesting } from "./ab-testing.js";
+const fetch$ = getFetch();
+function getContent(options) {
+  return __async(this, null, function* () {
+    return (yield getAllContent(__spreadProps(__spreadValues({}, options), { limit: 1 }))).results[0] || null;
+  });
+}
+const generateContentUrl = (options) => {
+  const {
+    limit = 1,
+    userAttributes,
+    query,
+    noTraverse = false,
+    model,
+    apiKey
+  } = options;
+  const url = new URL(`https://cdn.builder.io/api/v2/content/${model}?apiKey=${apiKey}&limit=${limit}&noTraverse=${noTraverse}`);
+  if (options.options) {
+    const flattened = flatten(options.options);
+    for (const key in flattened) {
+      url.searchParams.set(key, String(flattened[key]));
+    }
+  }
+  if (userAttributes) {
+    url.searchParams.set("userAttributes", JSON.stringify(userAttributes));
+  }
+  if (query) {
+    const flattened = flatten({ query });
+    for (const key in flattened) {
+      url.searchParams.set(key, JSON.stringify(flattened[key]));
+    }
+  }
+  return url;
+};
+function getAllContent(options) {
+  return __async(this, null, function* () {
+    const url = generateContentUrl(options);
+    const fetch = yield fetch$;
+    const content = yield fetch(url.href).then((res) => res.json());
+    if (options.testGroups) {
+      for (const item of content.results) {
+        handleABTesting(item, options.testGroups);
+      }
+    }
+    return content;
+  });
+}
+export {
+  generateContentUrl,
+  getAllContent,
+  getContent
+};

package/src/functions/get-content/types.js

@@ -0,0 +1 @@
+import * as React from 'react';

package/src/functions/get-fetch.js

@@ -0,0 +1,35 @@
+import * as React from 'react';
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { getGlobalThis } from "./get-global-this.js";
+function getFetch() {
+  return __async(this, null, function* () {
+    const globalFetch = getGlobalThis().fetch;
+    if (typeof globalFetch === "undefined" && typeof global !== "undefined") {
+      const nodeFetch = import("node-fetch").then((d) => d.default);
+      return nodeFetch;
+    }
+    return globalFetch;
+  });
+}
+export {
+  getFetch
+};

package/src/functions/get-global-this.js

@@ -0,0 +1,19 @@
+import * as React from 'react';
+function getGlobalThis() {
+  if (typeof globalThis !== "undefined") {
+    return globalThis;
+  }
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof global !== "undefined") {
+    return global;
+  }
+  if (typeof self !== "undefined") {
+    return self;
+  }
+  return null;
+}
+export {
+  getGlobalThis
+};

package/src/functions/get-processed-block.js

@@ -18,10 +18,14 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-import { evaluate } from "./evaluate";
-import { set } from "./set";
-function getProcessedBlock(options) {
-  const { block, state, context } = options;
+import { evaluate } from "./evaluate.js";
+import { set } from "./set.js";
+import { transformBlock } from "./transform-block.js";
+const evaluateBindings = ({
+  block,
+  context,
+  state
+}) => {
   if (!block.bindings) {
     return block;
   }
@@ -31,14 +35,19 @@ function getProcessedBlock(options) {
   });
   for (const binding in block.bindings) {
     const expression = block.bindings[binding];
-    const value = evaluate({
-      code: expression,
-      state,
-      context
-    });
+    const value = evaluate({ code: expression, state, context });
     set(copied, binding, value);
   }
   return copied;
+};
+function getProcessedBlock(options) {
+  const { state, context } = options;
+  const block = transformBlock(options.block);
+  if (evaluateBindings) {
+    return evaluateBindings({ block, state, context });
+  } else {
+    return block;
+  }
 }
 export {
   getProcessedBlock

package/src/functions/get-processed-block.test.js

@@ -1,8 +1,9 @@
 import * as React from 'react';
-import { expect, test } from "@jest/globals";
-import { getProcessedBlock } from "./get-processed-block";
+import { getProcessedBlock } from "./get-processed-block.js";
 test("Can process bindings", () => {
+  var _a, _b, _c, _d, _e, _f;
   const block = {
+    "@type": "@builder.io/sdk:Element",
     properties: {
       foo: "bar"
     },
@@ -17,11 +18,16 @@ test("Can process bindings", () => {
       "properties.isEditing": "builder.isEditing"
     }
   };
-  const processed = getProcessedBlock({ block, context: {}, state: { test: "hello" } });
+  const processed = getProcessedBlock({
+    block,
+    context: {},
+    state: { test: "hello" },
+    evaluateBindings: true
+  });
   expect(processed).not.toEqual(block);
-  expect(processed.properties.foo).toEqual("baz");
-  expect(processed.properties.test).toEqual("hello");
-  expect(processed.properties.block).toEqual("bar");
-  expect(processed.properties.isEditing).toEqual(false);
-  expect(processed.responsiveStyles.large.zIndex).toEqual(2);
+  expect((_a = processed.properties) == null ? void 0 : _a.foo).toEqual("baz");
+  expect((_b = processed.properties) == null ? void 0 : _b.test).toEqual("hello");
+  expect((_c = processed.properties) == null ? void 0 : _c.block).toEqual("bar");
+  expect((_d = processed.properties) == null ? void 0 : _d.isEditing).toEqual(false);
+  expect((_f = (_e = processed.responsiveStyles) == null ? void 0 : _e.large) == null ? void 0 : _f.zIndex).toEqual(2);
 });

package/src/functions/if-target.js

@@ -1,6 +1,15 @@
 import * as React from 'react';
-function ifTarget(target, doThing, elseThing) {
-  return doThing();
+import { TARGET } from "../constants/target.js";
+function ifTarget({
+  targets,
+  doThing,
+  elseThing
+}) {
+  if (TARGET && targets.includes(TARGET)) {
+    return doThing();
+  } else {
+    return elseThing == null ? void 0 : elseThing();
+  }
 }
 export {
   ifTarget

package/src/functions/is-browser.js

@@ -1,7 +1,6 @@
 import * as React from 'react';
-import { isReactNative } from "./is-react-native";
 function isBrowser() {
-  return typeof window !== "undefined" && typeof document !== "undefined" && !isReactNative();
+  return typeof window !== "undefined" && typeof document !== "undefined";
 }
 export {
   isBrowser

package/src/functions/is-editing.js

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { isIframe } from "./is-iframe";
+import { isIframe } from "./is-iframe.js";
 function isEditing() {
   return isIframe() && window.location.search.indexOf("builder.frameEditing=") !== -1;
 }

package/src/functions/is-iframe.js

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { isBrowser } from "./is-browser";
+import { isBrowser } from "./is-browser.js";
 function isIframe() {
   return isBrowser() && window.self !== window.top;
 }

package/src/functions/is-previewing.js

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import { isBrowser } from "./is-browser.js";
+import { isEditing } from "./is-editing.js";
+function isPreviewing() {
+  if (!isBrowser()) {
+    return false;
+  }
+  if (isEditing()) {
+    return false;
+  }
+  return Boolean(location.search.indexOf("builder.preview=") !== -1);
+}
+export {
+  isPreviewing
+};

package/src/functions/is-react-native.js

@@ -1,6 +1,6 @@
 import * as React from 'react';
 function isReactNative() {
-  return typeof navigator === "object" && navigator.product === "ReactNative";
+  return true;
 }
 export {
   isReactNative

package/src/functions/on-change.test.js

@@ -1,6 +1,5 @@
 import * as React from 'react';
-import { expect, test } from "@jest/globals";
-import { onChange } from "./on-change";
+import { onChange } from "./on-change.js";
 test("onChange can observe a shallow change", () => {
   let changeHappend = false;
   const obj = onChange({ foo: "hi" }, () => changeHappend = true);

package/src/functions/previewing-model-name.js

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { isPreviewing } from "./is-previewing.js";
+function previewingModelName() {
+  if (!isPreviewing()) {
+    return null;
+  }
+  const url = new URL(location.href);
+  return url.searchParams.get("builder.preview");
+}
+export {
+  previewingModelName
+};

package/src/functions/register-component.js

@@ -18,36 +18,56 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-import { isBrowser } from "./is-browser";
-const components = {};
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+const components = [];
 function registerComponent(component, info) {
-  var _a;
-  components[info.name] = { component, info };
-  if (isBrowser()) {
-    const sendInfo = prepareComponentInfoToSend(info);
-    (_a = window.parent) == null ? void 0 : _a.postMessage({
-      type: "builder.registerComponent",
-      data: sendInfo
-    }, "*");
-  }
+  components.push(__spreadValues({ component }, info));
+  console.warn("registerComponent is deprecated. Use the `customComponents` prop in RenderContent instead to provide your custom components to the builder SDK.");
+  return component;
 }
-function prepareComponentInfoToSend(info) {
-  return __spreadValues(__spreadValues({}, info), info.inputs && {
-    inputs: info.inputs.map((input) => {
-      const keysToConvertFnToString = ["onChange", "showIf"];
-      for (const key of keysToConvertFnToString) {
-        if (input[key] && typeof input[key] === "function") {
-          const fn = input[key];
-          input = __spreadProps(__spreadValues({}, input), {
-            [key]: `return (${fn.toString()}).apply(this, arguments)`
-          });
-        }
-      }
-      return input;
-    })
+const createRegisterComponentMessage = (_a) => {
+  var _b = _a, {
+    component: _
+  } = _b, info = __objRest(_b, [
+    "component"
+  ]);
+  return {
+    type: "builder.registerComponent",
+    data: prepareComponentInfoToSend(info)
+  };
+};
+const fastClone = (obj) => JSON.parse(JSON.stringify(obj));
+const serializeValue = (value) => typeof value === "function" ? serializeFn(value) : fastClone(value);
+const serializeFn = (fnValue) => {
+  const fnStr = fnValue.toString().trim();
+  const appendFunction = !fnStr.startsWith("function") && !fnStr.startsWith("(");
+  return `return (${appendFunction ? "function " : ""}${fnStr}).apply(this, arguments)`;
+};
+const prepareComponentInfoToSend = (_c) => {
+  var _d = _c, {
+    inputs
+  } = _d, info = __objRest(_d, [
+    "inputs"
+  ]);
+  return __spreadProps(__spreadValues({}, fastClone(info)), {
+    inputs: inputs == null ? void 0 : inputs.map((input) => Object.entries(input).reduce((acc, [key, value]) => __spreadProps(__spreadValues({}, acc), {
+      [key]: serializeValue(value)
+    }), {}))
   });
-}
+};
 export {
   components,
+  createRegisterComponentMessage,
   registerComponent
 };

package/src/functions/register.js

@@ -0,0 +1,30 @@
+import * as React from 'react';
+import { isBrowser } from "./is-browser.js";
+const registry = {};
+function register(type, info) {
+  let typeList = registry[type];
+  if (!typeList) {
+    typeList = registry[type] = [];
+  }
+  typeList.push(info);
+  if (isBrowser()) {
+    const message = {
+      type: "builder.register",
+      data: {
+        type,
+        info
+      }
+    };
+    try {
+      parent.postMessage(message, "*");
+      if (parent !== window) {
+        window.postMessage(message, "*");
+      }
+    } catch (err) {
+      console.debug("Could not postmessage", err);
+    }
+  }
+}
+export {
+  register
+};

package/src/functions/sanitize-styles.js

@@ -0,0 +1,33 @@
+import * as React from 'react';
+const propertiesThatMustBeNumber = new Set(["lineHeight"]);
+const displayValues = new Set(["flex", "none"]);
+const SHOW_WARNINGS = false;
+const sanitizeBlockStyles = (styles) => {
+  for (const key in styles) {
+    const propertyValue = styles[key];
+    if (key === "display" && !displayValues.has(propertyValue)) {
+      if (SHOW_WARNINGS) {
+        console.warn(`Style value for key "display" must be "flex" or "none" but had ${propertyValue}`);
+      }
+      delete styles[key];
+    }
+    if (typeof propertyValue === "string" && propertyValue.match(/^-?\d/)) {
+      const newValue = parseFloat(propertyValue);
+      if (!isNaN(newValue)) {
+        styles[key] = newValue;
+      }
+      if (typeof newValue === "number" && newValue < 0) {
+        styles[key] = 0;
+      }
+    }
+    if (propertiesThatMustBeNumber.has(key) && typeof styles[key] !== "number") {
+      if (SHOW_WARNINGS) {
+        console.warn(`Style key ${key} must be a number, but had value \`${styles[key]}\``);
+      }
+      delete styles[key];
+    }
+  }
+};
+export {
+  sanitizeBlockStyles
+};

package/src/functions/set-editor-settings.js

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { isBrowser } from "./is-browser.js";
+const settings = {};
+function setEditorSettings(newSettings) {
+  if (isBrowser()) {
+    Object.assign(settings, newSettings);
+    const message = {
+      type: "builder.settingsChange",
+      data: settings
+    };
+    parent.postMessage(message, "*");
+  }
+}
+export {
+  setEditorSettings
+};

package/src/functions/set.test.js

@@ -1,6 +1,5 @@
 import * as React from 'react';
-import { expect, test } from "@jest/globals";
-import { set } from "./set";
+import { set } from "./set.js";
 test("can shallow set a property", () => {
   const obj = { foo: "bar" };
   set(obj, "foo", "baz");

package/src/functions/track.js

@@ -1,8 +1,12 @@
 import * as React from 'react';
-import { isBrowser } from "./is-browser";
-import { isReactNative } from "./is-react-native";
+import { TARGET } from "../constants/target.js";
+import { isBrowser } from "./is-browser.js";
+import { isEditing } from "./is-editing.js";
 function track(event, properties) {
-  if (!isBrowser() || isReactNative()) {
+  if (isEditing()) {
+    return;
+  }
+  if (!(isBrowser() || TARGET === "reactNative")) {
     return;
   }
   return fetch(`https://builder.io/api/v1/track`, {

package/src/functions/transform-block.js

@@ -0,0 +1,38 @@
+import * as React from 'react';
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+function transformBlock(block) {
+  if (block.id.startsWith("builder-pixel-") && !block.component) {
+    return __spreadProps(__spreadValues({}, block), {
+      component: {
+        name: "Image",
+        options: {
+          image: block.properties.src,
+          width: 1,
+          height: 1
+        }
+      }
+    });
+  }
+  return block;
+}
+export {
+  transformBlock
+};

package/src/helpers/css.js

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { camelToKebabCase } from "../functions/camel-to-kebab-case";
+const convertStyleMaptoCSS = (style) => {
+  const cssProps = Object.entries(style).map(([key, value]) => {
+    if (typeof value === "string") {
+      return `${camelToKebabCase(key)}: ${value};`;
+    }
+  });
+  return cssProps.join("\n");
+};
+export {
+  convertStyleMaptoCSS
+};