@builder.io/sdk-react 0.1.1 → 0.1.3

package/dist/react/functions/get-content/ab-testing.js

@@ -0,0 +1,86 @@
+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 { getContentVariationCookie, setContentVariationCookie } from "../../helpers/ab-tests.js";
+import { checkIsDefined } from "../../helpers/nullable.js";
+const checkIsBuilderContentWithVariations = (item) => checkIsDefined(item.id) && checkIsDefined(item.variations) && Object.keys(item.variations).length > 0;
+const getRandomVariationId = ({ id, variations }) => {
+    var _a;
+    let n = 0;
+    const random = Math.random();
+    for (const id2 in variations) {
+        const testRatio = (_a = variations[id2]) == null ? void 0 : _a.testRatio;
+        n += testRatio;
+        if (random < n) {
+            return id2;
+        }
+    }
+    return id;
+};
+const getTestFields = ({ item, testGroupId }) => {
+    const variationValue = item.variations[testGroupId];
+    if (testGroupId === item.id || !variationValue) {
+        return {
+            testVariationId: item.id,
+            testVariationName: "Default"
+        };
+    }
+    else {
+        return {
+            data: variationValue.data,
+            testVariationId: variationValue.id,
+            testVariationName: variationValue.name || (variationValue.id === item.id ? "Default" : "")
+        };
+    }
+};
+const getContentVariation = (_0) => __async(void 0, [_0], function* ({ item, canTrack }) {
+    const testGroupId = yield getContentVariationCookie({
+        canTrack,
+        contentId: item.id
+    });
+    const testFields = testGroupId ? getTestFields({ item, testGroupId }) : void 0;
+    if (testFields) {
+        return testFields;
+    }
+    else {
+        const randomVariationId = getRandomVariationId({
+            variations: item.variations,
+            id: item.id
+        });
+        setContentVariationCookie({
+            contentId: item.id,
+            value: randomVariationId,
+            canTrack
+        }).catch((err) => {
+            console.error("could not store A/B test variation: ", err);
+        });
+        return getTestFields({ item, testGroupId: randomVariationId });
+    }
+});
+const handleABTesting = (_0) => __async(void 0, [_0], function* ({ item, canTrack }) {
+    if (!checkIsBuilderContentWithVariations(item)) {
+        return;
+    }
+    const variationValue = yield getContentVariation({ item, canTrack });
+    Object.assign(item, variationValue);
+});
+export { handleABTesting };

package/dist/react/functions/get-content/generate-content-url.js

@@ -0,0 +1,41 @@
+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 { flatten } from "../../helpers/flatten.js";
+import { getBuilderSearchParamsFromWindow, normalizeSearchParams } from "../get-builder-search-params/index.js";
+const generateContentUrl = (options) => {
+    const { limit = 30, userAttributes, query, noTraverse = false, model, apiKey, includeRefs = true, locale } = options;
+    if (!apiKey) {
+        throw new Error("Missing API key");
+    }
+    const url = new URL(`https://cdn.builder.io/api/v2/content/${model}?apiKey=${apiKey}&limit=${limit}&noTraverse=${noTraverse}&includeRefs=${includeRefs}${locale ? `&locale=${locale}` : ""}`);
+    const queryOptions = __spreadValues(__spreadValues({}, getBuilderSearchParamsFromWindow()), normalizeSearchParams(options.options || {}));
+    const flattened = flatten(queryOptions);
+    for (const key in flattened) {
+        url.searchParams.set(key, String(flattened[key]));
+    }
+    if (userAttributes) {
+        url.searchParams.set("userAttributes", JSON.stringify(userAttributes));
+    }
+    if (query) {
+        const flattened2 = flatten({ query });
+        for (const key in flattened2) {
+            url.searchParams.set(key, JSON.stringify(flattened2[key]));
+        }
+    }
+    return url;
+};
+export { generateContentUrl };

package/dist/react/functions/get-content/generate-content-url.test.js

@@ -0,0 +1,31 @@
+import { generateContentUrl } from "./generate-content-url";
+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/dist/react/functions/get-content/index.js

@@ -0,0 +1,64 @@
+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 { fetch } from "../get-fetch.js";
+import { handleABTesting } from "./ab-testing.js";
+import { generateContentUrl } from "./generate-content-url.js";
+function getContent(options) {
+    return __async(this, null, function* () {
+        return (yield getAllContent(__spreadProps(__spreadValues({}, options), { limit: 1 }))).results[0] || null;
+    });
+}
+function getAllContent(options) {
+    return __async(this, null, function* () {
+        const url = generateContentUrl(options);
+        const res = yield fetch(url.href);
+        const content = yield res.json();
+        const canTrack = options.canTrack !== false;
+        if (canTrack && Array.isArray(content.results)) {
+            for (const item of content.results) {
+                yield handleABTesting({ item, canTrack });
+            }
+        }
+        return content;
+    });
+}
+export { getAllContent, getContent };

package/dist/react/functions/get-content/types.js

@@ -0,0 +1 @@
+"use strict";

package/dist/react/functions/get-fetch.js

@@ -0,0 +1,12 @@
+import { getGlobalThis } from "./get-global-this.js";
+function getFetch() {
+    const globalFetch = getGlobalThis().fetch;
+    if (typeof globalFetch === "undefined") {
+        console.warn(`Builder SDK could not find a global fetch function. Make sure you have a polyfill for fetch in your project. 
+      For more information, read https://github.com/BuilderIO/this-package-uses-fetch`);
+        throw new Error("Builder SDK could not find a global `fetch` function");
+    }
+    return globalFetch;
+}
+const fetch = getFetch();
+export { fetch };

package/dist/react/functions/get-global-this.js

@@ -0,0 +1,16 @@
+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 globalThis;
+}
+export { getGlobalThis };

package/dist/react/functions/get-processed-block.js

@@ -0,0 +1,49 @@
+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.js";
+import { fastClone } from "./fast-clone.js";
+import { set } from "./set.js";
+import { transformBlock } from "./transform-block.js";
+const evaluateBindings = ({ block, context, state }) => {
+    if (!block.bindings) {
+        return block;
+    }
+    const copy = fastClone(block);
+    const copied = __spreadProps(__spreadValues({}, copy), {
+        properties: __spreadValues({}, copy.properties),
+        actions: __spreadValues({}, copy.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;
+};
+function getProcessedBlock({ block, context, shouldEvaluateBindings, state }) {
+    const transformedBlock = transformBlock(block);
+    if (shouldEvaluateBindings) {
+        return evaluateBindings({ block: transformedBlock, state, context });
+    }
+    else {
+        return transformedBlock;
+    }
+}
+export { getProcessedBlock };

package/dist/react/functions/get-processed-block.test.js

@@ -0,0 +1,32 @@
+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"
+        },
+        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" },
+        shouldEvaluateBindings: true
+    });
+    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/dist/react/functions/get-react-native-block-styles.js

@@ -0,0 +1,27 @@
+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 { sanitizeReactNativeBlockStyles } from "./sanitize-react-native-block-styles.js";
+function getReactNativeBlockStyles({ block, context, blockStyles }) {
+    const responsiveStyles = block.responsiveStyles;
+    if (!responsiveStyles) {
+        return {};
+    }
+    const styles = __spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, context.inheritedStyles), responsiveStyles.large || {}), responsiveStyles.medium || {}), responsiveStyles.small || {}), blockStyles);
+    const newStyles = sanitizeReactNativeBlockStyles(styles);
+    return newStyles;
+}
+export { getReactNativeBlockStyles };

package/dist/react/functions/if-target.js

@@ -0,0 +1,10 @@
+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/dist/react/functions/is-browser.js

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

package/dist/react/functions/is-editing.js

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

package/dist/react/functions/is-iframe.js

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

package/dist/react/functions/is-previewing.js

@@ -0,0 +1,12 @@
+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/dist/react/functions/on-change.js

@@ -0,0 +1,24 @@
+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/dist/react/functions/on-change.test.js

@@ -0,0 +1,19 @@
+import { onChange } from "./on-change.js";
+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/dist/react/functions/register-component.js

@@ -0,0 +1,60 @@
+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 __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;
+};
+import { serializeFn } from "../blocks/util.js";
+import { fastClone } from "./fast-clone.js";
+const components = [];
+function registerComponent(component, info) {
+    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;
+}
+const createRegisterComponentMessage = (_a) => {
+    var _b = _a, { component: _ } = _b, info = __objRest(_b, [
+        "component"
+    ]);
+    return {
+        type: "builder.registerComponent",
+        data: prepareComponentInfoToSend(info)
+    };
+};
+const serializeValue = (value) => typeof value === "function" ? serializeFn(value) : fastClone(value);
+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/dist/react/functions/register.js

@@ -0,0 +1,28 @@
+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/dist/react/functions/sanitize-react-native-block-styles.js

@@ -0,0 +1,68 @@
+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 sanitizeReactNativeBlockStyles = (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}`);
+            }
+            return acc;
+        }
+        if (propertiesThatMustBeNumber.has(key) && typeof propertyValue !== "number") {
+            if (SHOW_WARNINGS) {
+                console.warn(`Style key ${key} must be a number, but had value \`${styles[key]}\``);
+            }
+            return acc;
+        }
+        if (typeof propertyValue === "string") {
+            const isPixelUnit = propertyValue.match(/^-?(\d*)(\.?)(\d*)*px$/);
+            if (isPixelUnit) {
+                const newValue = parseFloat(propertyValue);
+                const normalizedValue = normalizeNumber(newValue);
+                if (normalizedValue) {
+                    return __spreadProps(__spreadValues({}, acc), { [key]: normalizedValue });
+                }
+                else {
+                    return acc;
+                }
+            }
+            else if (propertyValue === "0") {
+                return __spreadProps(__spreadValues({}, acc), { [key]: 0 });
+            }
+        }
+        return __spreadProps(__spreadValues({}, acc), { [key]: propertyValue });
+    }, {});
+};
+export { sanitizeReactNativeBlockStyles };

package/dist/react/functions/set-editor-settings.js

@@ -0,0 +1,13 @@
+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/dist/react/functions/set.js

@@ -0,0 +1,9 @@
+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 };

package/dist/react/functions/set.test.js

@@ -0,0 +1,16 @@
+import { set } from "./set.js";
+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 create arrays", () => {
+    const obj = { foo: "bar" };
+    set(obj, "foo.bar.0", "hi");
+    expect(obj.foo.bar).toEqual(["hi"]);
+});