@builder.io/sdk-react-native 0.0.4 → 0.0.6-0

package/package.json

@@ -1,14 +1,17 @@
 {
   "name": "@builder.io/sdk-react-native",
   "description": "Builder.io SDK for React Native",
-  "version": "0.0.4",
+  "version": "0.0.6-0",
   "main": "src/index.js",
   "scripts": {
     "release:patch": "npm version patch --no-git-tag-version && npm publish --access public",
     "release:dev": "npm version prerelease --no-git-tag-version && npm publish --tag dev --access public"
   },
   "dependencies": {
+    "@react-native-async-storage/async-storage": "^1.17.10",
+    "@react-native-cookies/cookies": "^6.2.1",
     "react-native-render-html": "^6.3.4",
+    "react-native-storage": "^1.0.1",
     "react-native-video": "^5.1.1"
   },
   "peerDependencies": {

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

@@ -36,9 +36,8 @@ function getBlockStyles(block) {
     return {};
   }
   const styles = getStyleForTarget(block.responsiveStyles);
-  console.log("rn styles", styles);
-  sanitizeBlockStyles(styles);
-  return styles;
+  const newStyles = sanitizeBlockStyles(styles);
+  return newStyles;
 }
 export {
   getBlockStyles

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

@@ -1,38 +1,84 @@
-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
-          });
-        }
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
       }
-      if (!set) {
-        Object.assign(item, {
-          testVariationId: item.id,
-          testVariationName: "Default"
-        });
+    };
+    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 {
+  getContentVariationCookie,
+  setContentVariationCookie
+} from "../../helpers/ab-tests.js";
+const getRandomTestGroupId = (variations) => {
+  let n = 0;
+  const random = Math.random();
+  for (const id in variations) {
+    const testRatio = variations[id].testRatio;
+    n += testRatio;
+    if (random < n) {
+      return id;
     }
   }
+  return void 0;
 };
+const getContentVariation = (_0) => __async(void 0, [_0], function* ({
+  item,
+  orgId
+}) {
+  if (!item.id || !item.variations || Object.keys(item.variations).length === 0) {
+    return;
+  }
+  const testGroupId = yield getContentVariationCookie({
+    canTrack: true,
+    contentId: item.id,
+    orgId
+  });
+  console.log("found test group id", testGroupId);
+  const variationValue = testGroupId ? item.variations[testGroupId] : void 0;
+  if (variationValue) {
+    return variationValue;
+  } else {
+    const randomTestGroupId = getRandomTestGroupId(item.variations);
+    if (randomTestGroupId) {
+      yield setContentVariationCookie({
+        contentId: item.id,
+        value: randomTestGroupId,
+        canTrack: true,
+        orgId
+      });
+    }
+    const randomVariationValue = randomTestGroupId ? item.variations[randomTestGroupId] : void 0;
+    return randomVariationValue;
+  }
+});
+const handleABTesting = (_0) => __async(void 0, [_0], function* ({
+  item,
+  orgId
+}) {
+  const variationValue = yield getContentVariation({ item, orgId });
+  const newValues = variationValue ? {
+    data: variationValue.data,
+    testVariationId: variationValue.id,
+    testVariationName: variationValue.name || (variationValue.id === item.id ? "Default" : "")
+  } : {
+    testVariationId: item.id,
+    testVariationName: "Default"
+  };
+  Object.assign(item, newValues);
+});
 export {
   handleABTesting
 };

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

@@ -80,10 +80,8 @@ function getAllContent(options) {
     const url = generateContentUrl(options);
     const fetch = yield getFetch();
     const content = yield fetch(url.href).then((res) => res.json());
-    if (options.testGroups) {
-      for (const item of content.results) {
-        handleABTesting(item, options.testGroups);
-      }
+    for (const item of content.results) {
+      yield handleABTesting({ item, orgId: options.apiKey });
     }
     return content;
   });

package/src/functions/sanitize-styles.js

@@ -1,31 +1,61 @@
+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));
 const propertiesThatMustBeNumber = new Set(["lineHeight"]);
 const displayValues = new Set(["flex", "none"]);
 const SHOW_WARNINGS = false;
+const normalizeNumber = (value) => {
+  if (Number.isNaN(value)) {
+    return void 0;
+  } else if (value < 0) {
+    return 0;
+  } else {
+    return value;
+  }
+};
 const sanitizeBlockStyles = (styles) => {
-  for (const key in styles) {
+  return Object.keys(styles).reduce((acc, key) => {
     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;
-      }
+      return acc;
     }
-    if (propertiesThatMustBeNumber.has(key) && typeof styles[key] !== "number") {
+    if (propertiesThatMustBeNumber.has(key) && typeof propertyValue !== "number") {
       if (SHOW_WARNINGS) {
         console.warn(`Style key ${key} must be a number, but had value \`${styles[key]}\``);
       }
-      delete styles[key];
+      return acc;
     }
-  }
+    if (typeof propertyValue === "string" && propertyValue.match(/^-?(\d*)(\.?)(\d*)*px/)) {
+      const newValue = parseFloat(propertyValue);
+      const normalizedValue = normalizeNumber(newValue);
+      if (normalizedValue) {
+        const valueWithUnits = propertyValue.endsWith("%") ? `${normalizedValue}%` : "";
+        return __spreadProps(__spreadValues({}, acc), { [key]: valueWithUnits });
+      } else {
+        return acc;
+      }
+    }
+    return __spreadProps(__spreadValues({}, acc), { [key]: propertyValue });
+  }, {});
 };
 export {
   sanitizeBlockStyles

package/src/functions/track.js

@@ -54,18 +54,21 @@ import { getSessionId } from "../helpers/sessionId.js";
 import { getVisitorId } from "../helpers/visitorId.js";
 import { isBrowser } from "./is-browser.js";
 import { isEditing } from "./is-editing.js";
-const getTrackingEventData = ({ canTrack }) => {
+const getTrackingEventData = (_0) => __async(void 0, [_0], function* ({
+  canTrack,
+  orgId
+}) {
   if (!canTrack) {
     return { visitorId: void 0, sessionId: void 0 };
   }
-  const sessionId = getSessionId({ canTrack });
+  const sessionId = yield getSessionId({ canTrack, orgId });
   const visitorId = getVisitorId({ canTrack });
   return {
     sessionId,
     visitorId
   };
-};
-const createEvent = (_a) => {
+});
+const createEvent = (_a) => __async(void 0, null, function* () {
   var _b = _a, {
     type: eventType,
     canTrack,
@@ -79,12 +82,12 @@ const createEvent = (_a) => {
   ]);
   return {
     type: eventType,
-    data: __spreadProps(__spreadValues(__spreadValues({}, properties), getTrackingEventData({ canTrack })), {
+    data: __spreadProps(__spreadValues(__spreadValues({}, properties), yield getTrackingEventData({ canTrack, orgId })), {
       ownerId: orgId,
       contentId
     })
   };
-};
+});
 function track(eventProps) {
   return __async(this, null, function* () {
     if (!eventProps.canTrack) {
@@ -99,7 +102,7 @@ function track(eventProps) {
     return fetch(`https://builder.io/api/v1/track`, {
       method: "POST",
       body: JSON.stringify({
-        events: [createEvent(eventProps)]
+        events: [yield createEvent(eventProps)]
       }),
       headers: {
         "content-type": "application/json"

package/src/helpers/ab-tests.js

@@ -0,0 +1,18 @@
+import { getCookie, setCookie } from "./cookie.js";
+const BUILDER_STORE_PREFIX = "builder.tests";
+const getContentTestKey = (id) => `${BUILDER_STORE_PREFIX}.${id}`;
+const getContentVariationCookie = ({
+  contentId,
+  canTrack,
+  orgId
+}) => getCookie({ name: getContentTestKey(contentId), canTrack, orgId });
+const setContentVariationCookie = ({
+  contentId,
+  canTrack,
+  value,
+  orgId
+}) => setCookie({ name: getContentTestKey(contentId), value, canTrack, orgId });
+export {
+  getContentVariationCookie,
+  setContentVariationCookie
+};

package/src/helpers/cookie.js

@@ -1,58 +1,56 @@
-import { isBrowser } from "../functions/is-browser.js";
-import { getTopLevelDomain } from "./url.js";
-const getCookie = ({
+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 storage from "./storage";
+const getCookie = (_0) => __async(void 0, [_0], function* ({
   name,
   canTrack
-}) => {
-  var _a;
+}) {
   try {
     if (!canTrack) {
       return void 0;
     }
-    return (_a = document.cookie.split("; ").find((row) => row.startsWith(`${name}=`))) == null ? void 0 : _a.split("=")[1];
+    const parsedName = name.replace(/_/g, ".");
+    const data = yield (yield storage).load(parsedName);
+    console.log("data", data);
+    return data.value;
   } catch (err) {
     console.debug("[COOKIE] GET error: ", err);
   }
-};
-const stringifyCookie = (cookie) => cookie.map(([key, value]) => value ? `${key}=${value}` : key).join("; ");
-const SECURE_CONFIG = [
-  ["secure", ""],
-  ["SameSite", "None"]
-];
-const createCookieString = ({
-  name,
-  value,
-  expires
-}) => {
-  const secure = isBrowser() ? location.protocol === "https:" : true;
-  const secureObj = secure ? SECURE_CONFIG : [[]];
-  const expiresObj = expires ? [["expires", expires.toUTCString()]] : [[]];
-  const cookieValue = [
-    [name, value],
-    ...expiresObj,
-    ["path", "/"],
-    ["domain", getTopLevelDomain(window.location.hostname)],
-    ...secureObj
-  ];
-  const cookie = stringifyCookie(cookieValue);
-  return cookie;
-};
-const setCookie = ({
+});
+const setCookie = (_0) => __async(void 0, [_0], function* ({
   name,
   value,
   expires,
   canTrack
-}) => {
+}) {
   try {
     if (!canTrack) {
       return void 0;
     }
-    const cookie = createCookieString({ name, value, expires });
-    document.cookie = cookie;
+    yield (yield storage).save({ key: name, data: { value }, expires });
+    console.log("data", yield storage);
   } catch (err) {
     console.warn("[COOKIE] SET error: ", err);
   }
-};
+});
 export {
   getCookie,
   setCookie

package/src/helpers/sessionId.js

@@ -1,24 +1,49 @@
+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 { getCookie, setCookie } from "./cookie.js";
 import { checkIsDefined } from "./nullable.js";
 import { uuid } from "./uuid.js";
 const SESSION_LOCAL_STORAGE_KEY = "builderSessionId";
-const getSessionId = ({ canTrack }) => {
+const getSessionId = (_0) => __async(void 0, [_0], function* ({ canTrack, orgId }) {
   if (!canTrack) {
     return void 0;
   }
-  const sessionId = getCookie({ name: SESSION_LOCAL_STORAGE_KEY, canTrack });
+  const sessionId = yield getCookie({
+    name: SESSION_LOCAL_STORAGE_KEY,
+    canTrack,
+    orgId
+  });
   if (checkIsDefined(sessionId)) {
     return sessionId;
   } else {
     const newSessionId = createSessionId();
-    setSessionId({ id: newSessionId, canTrack });
+    setSessionId({ id: newSessionId, canTrack, orgId });
   }
-};
+});
 const createSessionId = () => uuid();
 const setSessionId = ({
   id,
-  canTrack
-}) => setCookie({ name: SESSION_LOCAL_STORAGE_KEY, value: id, canTrack });
+  canTrack,
+  orgId
+}) => setCookie({ name: SESSION_LOCAL_STORAGE_KEY, value: id, canTrack, orgId });
 export {
   createSessionId,
   getSessionId,

package/src/helpers/storage.js

@@ -0,0 +1,37 @@
+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 Storage from "react-native-storage";
+import { isBrowser } from "../functions/is-browser.js";
+const ONE_DAY = 1e3 * 60 * 60 * 24;
+const initStorage = () => __async(void 0, null, function* () {
+  const backend = isBrowser() ? window.localStorage : yield import("@react-native-async-storage/async-storage");
+  const storage = new Storage({
+    size: 1e3,
+    storageBackend: backend,
+    defaultExpires: ONE_DAY * 30,
+    enableCache: true
+  });
+  return storage;
+});
+var stdin_default = initStorage();
+export {
+  stdin_default as default
+};