@builder.io/sdk-react-native 0.0.1-35 → 0.0.1-39

package/src/functions/get-fetch.js

@@ -1,13 +1,11 @@
 import * as React from 'react';
-import { getGlobalThis } from "./get-global-this";
+import { getGlobalThis } from './get-global-this';
 function getFetch() {
   let fetch = getGlobalThis().fetch;
-  if (typeof fetch === "undefined" && typeof global !== "undefined") {
-    const _require = eval("require");
-    fetch = _require("node-fetch");
+  if (typeof fetch === 'undefined' && typeof global !== 'undefined') {
+    const _require = eval('require');
+    fetch = _require('node-fetch');
   }
   return fetch;
 }
-export {
-  getFetch
-};
+export { getFetch };

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

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

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

@@ -5,41 +5,47 @@ 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 __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 (__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]);
+      if (__propIsEnum.call(b, prop)) __defNormalProp(a, prop, b[prop]);
     }
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-import { evaluate } from "./evaluate";
-import { set } from "./set";
+import { evaluate } from './evaluate';
+import { set } from './set';
+import { transformBlock } from './transform-block';
 function getProcessedBlock(options) {
-  const { block, state, context } = options;
+  const { state, context } = options;
+  const block = transformBlock(options.block);
   if (!block.bindings) {
     return block;
   }
   const copied = __spreadProps(__spreadValues({}, block), {
     properties: __spreadValues({}, block.properties),
-    actions: __spreadValues({}, block.actions)
+    actions: __spreadValues({}, block.actions),
   });
   for (const binding in block.bindings) {
     const expression = block.bindings[binding];
     const value = evaluate({
       code: expression,
       state,
-      context
+      context,
     });
     set(copied, binding, value);
   }
   return copied;
 }
-export {
-  getProcessedBlock
-};
+export { getProcessedBlock };

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

@@ -1,27 +1,31 @@
 import * as React from 'react';
-import { expect, test } from "@jest/globals";
-import { getProcessedBlock } from "./get-processed-block";
-test("Can process bindings", () => {
+import { expect, test } from '@jest/globals';
+import { getProcessedBlock } from './get-processed-block';
+test('Can process bindings', () => {
   const block = {
     properties: {
-      foo: "bar"
+      foo: 'bar',
     },
     bindings: {
-      "properties.foo": '"baz"',
-      "responsiveStyles.large.zIndex": "1 + 1",
-      "properties.test": "state.test",
-      "properties.block": `
+      'properties.foo': '"baz"',
+      'responsiveStyles.large.zIndex': '1 + 1',
+      'properties.test': 'state.test',
+      'properties.block': `
         const foo = 'bar';
         return foo;
       `,
-      "properties.isEditing": "builder.isEditing"
-    }
+      'properties.isEditing': 'builder.isEditing',
+    },
   };
-  const processed = getProcessedBlock({ block, context: {}, state: { test: "hello" } });
+  const processed = getProcessedBlock({
+    block,
+    context: {},
+    state: { test: 'hello' },
+  });
   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.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);
 });

package/src/functions/get-target.js

@@ -1,7 +1,5 @@
 import * as React from 'react';
 function getTarget(_) {
-  return "reactNative";
+  return 'reactNative';
 }
-export {
-  getTarget
-};
+export { getTarget };

package/src/functions/if-target.js

@@ -2,6 +2,4 @@ import * as React from 'react';
 function ifTarget(target, doThing, elseThing) {
   return doThing();
 }
-export {
-  ifTarget
-};
+export { ifTarget };

package/src/functions/is-browser.js

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

package/src/functions/is-editing.js

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

package/src/functions/is-iframe.js

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

package/src/functions/is-previewing.js

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

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

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

package/src/functions/macro-eval.js

@@ -1,6 +1,3 @@
 import * as React from 'react';
-function macroEval(items, string) {
-}
-export {
-  macroEval
-};
+function macroEval(items, string) {}
+export { macroEval };

package/src/functions/on-change.js

@@ -1,5 +1,5 @@
 import * as React from 'react';
-const onChangeProxySymbol = Symbol("onChangeProxySymbol");
+const onChangeProxySymbol = Symbol('onChangeProxySymbol');
 function onChange(obj, cb) {
   return new Proxy(obj, {
     get(target, key) {
@@ -7,7 +7,7 @@ function onChange(obj, cb) {
         return true;
       }
       const value = Reflect.get(target, key);
-      if (value && typeof value === "object") {
+      if (value && typeof value === 'object') {
         if (value[onChangeProxySymbol]) {
           return value;
         }
@@ -19,10 +19,7 @@ function onChange(obj, cb) {
       const returnValue = Reflect.set(target, key, value);
       cb();
       return returnValue;
-    }
+    },
   });
 }
-export {
-  onChange,
-  onChangeProxySymbol
-};
+export { onChange, onChangeProxySymbol };

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

@@ -1,21 +1,21 @@
 import * as React from 'react';
-import { expect, test } from "@jest/globals";
-import { onChange } from "./on-change";
-test("onChange can observe a shallow change", () => {
+import { expect, test } from '@jest/globals';
+import { onChange } from './on-change';
+test('onChange can observe a shallow change', () => {
   let changeHappend = false;
-  const obj = onChange({ foo: "hi" }, () => changeHappend = true);
-  obj.foo = "yo";
+  const obj = onChange({ foo: 'hi' }, () => (changeHappend = true));
+  obj.foo = 'yo';
   expect(changeHappend).toBe(true);
 });
-test("onChange can observe a deep change", () => {
+test('onChange can observe a deep change', () => {
   let changeHappend = false;
-  const obj = onChange({ foo: { bar: "hi" } }, () => changeHappend = true);
-  obj.foo.bar = "yo";
+  const obj = onChange({ foo: { bar: 'hi' } }, () => (changeHappend = true));
+  obj.foo.bar = 'yo';
   expect(changeHappend).toBe(true);
 });
-test("Smoke test: callback is not fired if no properties updated", () => {
+test('Smoke test: callback is not fired if no properties updated', () => {
   let changeHappend = false;
-  const obj = onChange({ foo: { bar: "hi" } }, () => changeHappend = true);
+  const obj = onChange({ foo: { bar: 'hi' } }, () => (changeHappend = true));
   obj.foo.bar;
   expect(changeHappend).toBe(false);
 });

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

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

package/src/functions/register-component.js

@@ -5,50 +5,61 @@ 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 __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 (__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]);
+      if (__propIsEnum.call(b, prop)) __defNormalProp(a, prop, b[prop]);
     }
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-import { isBrowser } from "./is-browser";
+import { isBrowser } from './is-browser';
 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
-    }, "*");
+    (_a = window.parent) == null
+      ? void 0
+      : _a.postMessage(
+          {
+            type: 'builder.registerComponent',
+            data: sendInfo,
+          },
+          '*'
+        );
   }
   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 __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;
-    })
-  });
+        return input;
+      }),
+    }
+  );
 }
-export {
-  components,
-  registerComponent
-};
+export { components, registerComponent };

package/src/functions/register.js

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

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

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

package/src/functions/set.js

@@ -3,10 +3,19 @@ const set = (obj, _path, value) => {
   if (Object(obj) !== obj) {
     return obj;
   }
-  const path = Array.isArray(_path) ? _path : _path.toString().match(/[^.[\]]+/g);
-  path.slice(0, -1).reduce((a, c, i) => Object(a[c]) === a[c] ? a[c] : a[c] = Math.abs(Number(path[i + 1])) >> 0 === +path[i + 1] ? [] : {}, obj)[path[path.length - 1]] = value;
+  const path = Array.isArray(_path)
+    ? _path
+    : _path.toString().match(/[^.[\]]+/g);
+  path
+    .slice(0, -1)
+    .reduce(
+      (a, c, i) =>
+        Object(a[c]) === a[c]
+          ? a[c]
+          : (a[c] =
+              Math.abs(Number(path[i + 1])) >> 0 === +path[i + 1] ? [] : {}),
+      obj
+    )[path[path.length - 1]] = value;
   return obj;
 };
-export {
-  set
-};
+export { set };

package/src/functions/set.test.js

@@ -1,18 +1,18 @@
 import * as React from 'react';
-import { expect, test } from "@jest/globals";
-import { set } from "./set";
-test("can shallow set a property", () => {
-  const obj = { foo: "bar" };
-  set(obj, "foo", "baz");
-  expect(obj.foo).toBe("baz");
+import { expect, test } from '@jest/globals';
+import { set } from './set';
+test('can shallow set a property', () => {
+  const obj = { foo: 'bar' };
+  set(obj, 'foo', 'baz');
+  expect(obj.foo).toBe('baz');
 });
-test("can deeply set a property", () => {
-  const obj = { foo: "bar" };
-  set(obj, "foo.bar", "baz");
-  expect(obj.foo.bar).toBe("baz");
+test('can deeply set a property', () => {
+  const obj = { foo: 'bar' };
+  set(obj, 'foo.bar', 'baz');
+  expect(obj.foo.bar).toBe('baz');
 });
-test("can deeply create arrays", () => {
-  const obj = { foo: "bar" };
-  set(obj, "foo.bar.0", "hi");
-  expect(obj.foo.bar).toEqual(["hi"]);
+test('can deeply create arrays', () => {
+  const obj = { foo: 'bar' };
+  set(obj, 'foo.bar.0', 'hi');
+  expect(obj.foo.bar).toEqual(['hi']);
 });

package/src/functions/track.js

@@ -1,19 +1,17 @@
 import * as React from 'react';
-import { isBrowser } from "./is-browser";
-import { isReactNative } from "./is-react-native";
+import { isBrowser } from './is-browser';
+import { isReactNative } from './is-react-native';
 function track(event, properties) {
   if (!isBrowser() || isReactNative()) {
     return;
   }
   return fetch(`https://builder.io/api/v1/track`, {
-    method: "POST",
+    method: 'POST',
     body: JSON.stringify({ events: [{ type: event, data: properties }] }),
     headers: {
-      "content-type": "application/json"
+      'content-type': 'application/json',
     },
-    mode: "cors"
+    mode: 'cors',
   });
 }
-export {
-  track
-};
+export { track };

package/src/functions/transform-block.js

@@ -0,0 +1,40 @@
+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-')) {
+    return __spreadProps(__spreadValues({}, block), {
+      component: {
+        name: 'Image',
+        options: {
+          image: block.properties.src,
+        },
+      },
+    });
+  }
+  return block;
+}
+export { transformBlock };