@builder.io/sdk-solid 0.0.1

package/src/functions/get-block-component-options.js

@@ -0,0 +1,23 @@
+var __defProp = Object.defineProperty;
+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;
+};
+function getBlockComponentOptions(block) {
+  var _a;
+  return __spreadValues(__spreadValues({}, (_a = block.component) == null ? void 0 : _a.options), block.options);
+}
+export {
+  getBlockComponentOptions
+};

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

@@ -0,0 +1,29 @@
+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 getBlockProperties(block) {
+  var _a;
+  return __spreadProps(__spreadValues({}, block.properties), {
+    "builder-id": block.id,
+    class: [block.id, "builder-block", block.class, (_a = block.properties) == null ? void 0 : _a.class].filter(Boolean).join(" ")
+  });
+}
+export {
+  getBlockProperties
+};

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

@@ -0,0 +1,42 @@
+var __defProp = Object.defineProperty;
+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;
+};
+import { sizes } from "../constants/device-sizes";
+const camelCaseToDashCase = (str = "") => str.replace(/[A-Z]/g, (match) => "-" + match.toLowerCase());
+const convertStyleObject = (obj) => {
+  if (!obj) {
+    return obj;
+  }
+  const newObj = {};
+  for (const key in obj) {
+    newObj[camelCaseToDashCase(key)] = obj[key];
+  }
+  return newObj;
+};
+function getBlockStyles(block) {
+  var _a, _b, _c, _d, _e;
+  const styles = __spreadValues({}, convertStyleObject((_a = block.responsiveStyles) == null ? void 0 : _a.large));
+  if ((_b = block.responsiveStyles) == null ? void 0 : _b.medium) {
+    styles[`@media (max-width: ${sizes.medium})`] = convertStyleObject((_c = block.responsiveStyles) == null ? void 0 : _c.medium);
+  }
+  if ((_d = block.responsiveStyles) == null ? void 0 : _d.small) {
+    styles[`@media (max-width: ${sizes.small})`] = convertStyleObject((_e = block.responsiveStyles) == null ? void 0 : _e.small);
+  }
+  return styles;
+}
+export {
+  getBlockStyles
+};

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

@@ -0,0 +1,6 @@
+function getBlockTag(block) {
+  return block.tagName || "div";
+}
+export {
+  getBlockTag
+};

package/src/functions/get-builder-search-params/fn.test.js

@@ -0,0 +1,13 @@
+import { getBuilderSearchParams, convertSearchParamsToQueryObject } from ".";
+const querystring = "someotherValue=jklsjfdal&abc=klfdjklgfds&builder.cachebust=true&builder.preview=page&builder.noCache=true&__builder_editing__=true&builder.overrides.page=037948e52eaf4743afed464f02c70da4&builder.overrides.037948e52eaf4743afed464f02c70da4=037948e52eaf4743afed464f02c70da4&builder.overrides.page%3A%2F=037948e52eaf4743afed464f02c70da4&preview_theme_id=128854393017";
+const url = new URL(`localhost:3000/about-us?${querystring}`);
+describe("Get Builder SearchParams", () => {
+  test("correctly converts URLSearchParams to object", () => {
+    const output = convertSearchParamsToQueryObject(url.searchParams);
+    expect(output).toMatchSnapshot();
+  });
+  test("correctly extracts all builder params from a query object", () => {
+    const output = getBuilderSearchParams(convertSearchParamsToQueryObject(url.searchParams));
+    expect(output).toMatchSnapshot();
+  });
+});

package/src/functions/get-builder-search-params/index.js

@@ -0,0 +1,22 @@
+const BUILDER_SEARCHPARAMS_PREFIX = "builder.";
+const convertSearchParamsToQueryObject = (searchParams) => {
+  const options = {};
+  searchParams.forEach((value, key) => {
+    options[key] = value;
+  });
+  return options;
+};
+const getBuilderSearchParams = (options) => {
+  const newOptions = {};
+  Object.keys(options).forEach((key) => {
+    if (key.startsWith(BUILDER_SEARCHPARAMS_PREFIX)) {
+      const trimmedKey = key.replace(BUILDER_SEARCHPARAMS_PREFIX, "");
+      newOptions[trimmedKey] = options[key];
+    }
+  });
+  return newOptions;
+};
+export {
+  convertSearchParamsToQueryObject,
+  getBuilderSearchParams
+};

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

@@ -0,0 +1,31 @@
+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,137 @@
+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 { getFetch } from "../get-fetch";
+const fetch = getFetch();
+function flatten(object, path = null, separator = ".") {
+  return Object.keys(object).reduce((acc, key) => {
+    const value = object[key];
+    const newPath = [path, key].filter(Boolean).join(separator);
+    const isObject = [
+      typeof value === "object",
+      value !== null,
+      !(Array.isArray(value) && value.length === 0)
+    ].every(Boolean);
+    return isObject ? __spreadValues(__spreadValues({}, acc), flatten(value, newPath, separator)) : __spreadProps(__spreadValues({}, acc), { [newPath]: value });
+  }, {});
+}
+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;
+};
+const handleABTesting = (content, testGroups) => {
+  for (const item of content.results) {
+    if (item.variations && Object.keys(item.variations).length) {
+      const testGroup = testGroups[item.id];
+      const variationValue = item.variations[testGroup];
+      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"
+          });
+        }
+      }
+    }
+  }
+};
+function getAllContent(options) {
+  return __async(this, null, function* () {
+    const url = generateContentUrl(options);
+    const content = yield fetch(url.href).then((res) => res.json());
+    if (options.testGroups) {
+      handleABTesting(content, options.testGroups);
+    }
+    return content;
+  });
+}
+export {
+  generateContentUrl,
+  getAllContent,
+  getContent
+};

package/src/functions/get-fetch.js

@@ -0,0 +1,12 @@
+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");
+  }
+  return fetch;
+}
+export {
+  getFetch
+};

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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,46 @@
+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));
+import { evaluate } from "./evaluate";
+import { set } from "./set";
+import { transformBlock } from "./transform-block";
+function getProcessedBlock(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)
+  });
+  for (const binding in block.bindings) {
+    const expression = block.bindings[binding];
+    const value = evaluate({
+      code: expression,
+      state,
+      context
+    });
+    set(copied, binding, value);
+  }
+  return copied;
+}
+export {
+  getProcessedBlock
+};

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

@@ -0,0 +1,31 @@
+import { getProcessedBlock } from "./get-processed-block";
+test("Can process bindings", () => {
+  var _a, _b, _c, _d, _e, _f;
+  const block = {
+    "@type": "@builder.io/sdk:Element",
+    properties: {
+      foo: "bar"
+    },
+    bindings: {
+      "properties.foo": '"baz"',
+      "responsiveStyles.large.zIndex": "1 + 1",
+      "properties.test": "state.test",
+      "properties.block": `
+        const foo = 'bar';
+        return foo;
+      `,
+      "properties.isEditing": "builder.isEditing"
+    }
+  };
+  const processed = getProcessedBlock({
+    block,
+    context: {},
+    state: { test: "hello" }
+  });
+  expect(processed).not.toEqual(block);
+  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/get-target.js

@@ -0,0 +1,6 @@
+function getTarget(_) {
+  return "reactNative";
+}
+export {
+  getTarget
+};

package/src/functions/if-target.js

@@ -0,0 +1,6 @@
+function ifTarget(target, doThing, elseThing) {
+  return doThing();
+}
+export {
+  ifTarget
+};

package/src/functions/is-browser.js

@@ -0,0 +1,6 @@
+function isBrowser() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+export {
+  isBrowser
+};

package/src/functions/is-editing.js

@@ -0,0 +1,7 @@
+import { isIframe } from "./is-iframe";
+function isEditing() {
+  return isIframe() && window.location.search.indexOf("builder.frameEditing=") !== -1;
+}
+export {
+  isEditing
+};

package/src/functions/is-iframe.js

@@ -0,0 +1,7 @@
+import { isBrowser } from "./is-browser";
+function isIframe() {
+  return isBrowser() && window.self !== window.top;
+}
+export {
+  isIframe
+};

package/src/functions/is-previewing.js

@@ -0,0 +1,14 @@
+import { isBrowser } from "./is-browser";
+import { isEditing } from "./is-editing";
+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

@@ -0,0 +1,6 @@
+function isReactNative() {
+  return false;
+}
+export {
+  isReactNative
+};

package/src/functions/macro-eval.js

@@ -0,0 +1,5 @@
+function macroEval(items, string) {
+}
+export {
+  macroEval
+};

package/src/functions/on-change.js

@@ -0,0 +1,27 @@
+const onChangeProxySymbol = Symbol("onChangeProxySymbol");
+function onChange(obj, cb) {
+  return new Proxy(obj, {
+    get(target, key) {
+      if (key === onChangeProxySymbol) {
+        return true;
+      }
+      const value = Reflect.get(target, key);
+      if (value && typeof value === "object") {
+        if (value[onChangeProxySymbol]) {
+          return value;
+        }
+        return onChange(value, cb);
+      }
+      return value;
+    },
+    set(target, key, value) {
+      const returnValue = Reflect.set(target, key, value);
+      cb();
+      return returnValue;
+    }
+  });
+}
+export {
+  onChange,
+  onChangeProxySymbol
+};

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

@@ -0,0 +1,19 @@
+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";
+  expect(changeHappend).toBe(true);
+});
+test("onChange can observe a deep change", () => {
+  let changeHappend = false;
+  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", () => {
+  let changeHappend = false;
+  const obj = onChange({ foo: { bar: "hi" } }, () => changeHappend = true);
+  obj.foo.bar;
+  expect(changeHappend).toBe(false);
+});

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

@@ -0,0 +1,11 @@
+import { isPreviewing } from "./is-previewing";
+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

@@ -0,0 +1,53 @@
+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));
+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
+    }, "*");
+  }
+  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;
+    })
+  });
+}
+export {
+  components,
+  registerComponent
+};

package/src/functions/register.js

@@ -0,0 +1,29 @@
+import { isBrowser } from "./is-browser";
+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/set-editor-settings.js

@@ -0,0 +1,15 @@
+import { isBrowser } from "./is-browser";
+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.js

@@ -0,0 +1,11 @@
+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;
+  return obj;
+};
+export {
+  set
+};