@builder.io/sdk-react 0.4.5 → 0.5.0

package/dist/functions/evaluate/non-node-runtime.d.ts

@@ -0,0 +1,2 @@
+import type { ExecutorArgs } from './types';
+export declare const runInNonNode: ({ builder, context, event, rootState, localState, rootSetState, useCode }: ExecutorArgs) => any;

package/dist/functions/evaluate/non-node-runtime.js

@@ -0,0 +1,84 @@
+import { logger } from '../../helpers/logger';
+import { set } from '../set';
+import Interpreter from './interpreter.js';
+const processCode = (code) => {
+    return code.split('\n').map(line => {
+        const trimmed = line.trim();
+        // this async wrapper doesn't work in JS-interpreter, so we drop it.
+        if (line.includes('__awaiter'))
+            return undefined;
+        // we find all state setter expressions and append a call to setRootState afterwards
+        const isStateSetter = trimmed.startsWith('state.');
+        if (!isStateSetter)
+            return line;
+        const [lhs, rhs] = trimmed.split('=');
+        const setStr = lhs.replace('state.', '').trim();
+        const setExpr = `setRootState('${setStr}', ${rhs.trim()})`;
+        return `
+  ${line}
+  ${setExpr}
+  `;
+    }).filter(Boolean).join('\n');
+};
+const getJSONValName = (val) => val + 'JSON';
+export const runInNonNode = ({ builder, context, event, rootState, localState, rootSetState, useCode }) => {
+    const state = {
+        ...rootState,
+        ...localState
+    };
+    const properties = {
+        state,
+        Builder: builder,
+        builder,
+        context,
+        event
+    };
+    /**
+     * Deserialize all properties from JSON strings to JS objects
+     */
+    const prependedCode = Object.keys(properties).map(key => `var ${key} = JSON.parse(${getJSONValName(key)});`).join('\n');
+    const cleanedCode = processCode(useCode);
+    if (cleanedCode === '') {
+        logger.warn('Skipping evaluation of empty code block.');
+        return;
+    }
+    const transformed = `
+function theFunction() {
+  ${prependedCode}
+
+  ${cleanedCode}
+}
+theFunction();
+`;
+    const setRootState = (prop, value) => {
+        const newState = set(state, prop, value);
+        rootSetState?.(newState);
+    };
+    const initFunc = function (interpreter, globalObject) {
+        /**
+         * serialize all function args to JSON strings
+         */
+        Object.keys(properties).forEach(key => {
+            const val = properties[key] || {};
+            const jsonVal = JSON.stringify(val);
+            interpreter.setProperty(globalObject, getJSONValName(key), jsonVal);
+        });
+        /**
+         * Add a JavaScript function "setRootState" to the interpreter's global object, that will be called whenever a
+         * state property is set. This function will update the state object.
+         */
+        interpreter.setProperty(globalObject, 'setRootState', interpreter.createNativeFunction(setRootState));
+    };
+    try {
+        const myInterpreter = new Interpreter(transformed, initFunc);
+        myInterpreter.run();
+        const output = myInterpreter.pseudoToNative(myInterpreter.value);
+        return output;
+    }
+    catch (e) {
+        logger.warn('Custom code error in non-node runtime. SDK can only execute ES5 JavaScript.', {
+            e
+        });
+        return;
+    }
+};

package/dist/functions/evaluate/types.d.ts

@@ -0,0 +1,10 @@
+import type { BuilderContextInterface } from '../../context/types';
+export type ExecutorArgs = Pick<BuilderContextInterface, 'localState' | 'context' | 'rootState' | 'rootSetState'> & {
+    useCode: string;
+    builder: {
+        isEditing: boolean | undefined;
+        isBrowser: boolean | undefined;
+        isServer: boolean | undefined;
+    };
+    event: Event | undefined;
+};

package/dist/functions/evaluate.d.ts

@@ -0,0 +1,23 @@
+import type { BuilderContextInterface, BuilderRenderContext, BuilderRenderState } from '../context/types.js';
+export declare const isNode: () => boolean;
+export declare function evaluate({ code, context, localState, rootState, rootSetState, event, isExpression }: {
+    code: string;
+    event?: Event;
+    isExpression?: boolean;
+} & Pick<BuilderContextInterface, 'localState' | 'context' | 'rootState' | 'rootSetState'>): any;
+type ExecutorArgs = {
+    useCode: string;
+    builder: {
+        isEditing: boolean | undefined;
+        isBrowser: boolean | undefined;
+        isServer: boolean | undefined;
+    };
+    state: BuilderRenderState;
+    context: BuilderRenderContext;
+    event: Event | undefined;
+};
+export declare const runInBrowser: ({ useCode, builder, state, context, event }: ExecutorArgs) => any;
+export declare const runInNonNode: ({ useCode, builder, state, context, event }: ExecutorArgs) => void;
+export declare const runInNode: (args: ExecutorArgs) => any;
+export declare function flattenState(rootState: Record<string | symbol, any>, localState: Record<string | symbol, any> | undefined, rootSetState: ((rootState: BuilderRenderState) => void) | undefined): BuilderRenderState;
+export {};

package/dist/{sdk/functions → functions}/evaluate.js

@@ -1,6 +1,9 @@
 import { isBrowser } from './is-browser.js';
 import { isEditing } from './is-editing.js';
-export function evaluate({ code, context, localState, rootState, rootSetState, event, isExpression = true, }) {
+export const isNode = () => {
+    return typeof window === 'undefined';
+};
+export function evaluate({ code, context, localState, rootState, rootSetState, event, isExpression = true }) {
     if (code === '') {
         console.warn('Skipping evaluation of empty code block.');
         return;
@@ -8,24 +11,40 @@ export function evaluate({ code, context, localState, rootState, rootSetState, e
     const builder = {
         isEditing: isEditing(),
         isBrowser: isBrowser(),
-        isServer: !isBrowser(),
+        isServer: !isBrowser()
     };
     // Be able to handle simple expressions like "state.foo" or "1 + 1"
     // as well as full blocks like "var foo = "bar"; return foo"
     const useReturn = 
     // we disable this for cases where we definitely don't want a return
-    isExpression &&
-        !(code.includes(';') ||
-            code.includes(' return ') ||
-            code.trim().startsWith('return '));
+    isExpression && !(code.includes(';') || code.includes(' return ') || code.trim().startsWith('return '));
     const useCode = useReturn ? `return (${code});` : code;
+    const state = flattenState(rootState, localState, rootSetState);
+    const args = {
+        useCode,
+        builder,
+        state,
+        context,
+        event
+    };
+    if (isBrowser())
+        return runInBrowser(args);
+    if (isNode())
+        return runInNode(args);
+    return runInBrowser(args);
+}
+export const runInBrowser = ({ useCode, builder, state, context, event }) => {
     try {
-        return new Function('builder', 'Builder' /* <- legacy */, 'state', 'context', 'event', useCode)(builder, builder, flattenState(rootState, localState, rootSetState), context, event);
+        return new Function('builder', 'Builder' /* <- legacy */, 'state', 'context', 'event', useCode)(builder, builder, state, context, event);
     }
     catch (e) {
         console.warn('Builder custom code error: \n While Evaluating: \n ', useCode, '\n', e);
     }
-}
+};
+export const runInNonNode = ({ useCode, builder, state, context, event }) => { };
+export const runInNode = (args) => {
+    return runInBrowser(args);
+};
 export function flattenState(rootState, localState, rootSetState) {
     if (rootState === localState) {
         throw new Error('rootState === localState');
@@ -44,6 +63,6 @@ export function flattenState(rootState, localState, rootSetState) {
             rootState[prop] = value;
             rootSetState?.(rootState);
             return true;
-        },
+        }
     });
 }

package/dist/{sdk/functions → functions}/evaluate.test.js

@@ -1,17 +1,23 @@
-import { flattenState } from './evaluate';
+import { flattenState } from './evaluate.js';
 describe('flatten state', () => {
     it('should behave normally when no PROTO_STATE', () => {
         const localState = {};
-        const rootState = { foo: 'bar' };
+        const rootState = {
+            foo: 'bar'
+        };
         const flattened = flattenState(rootState, localState, undefined);
         expect(flattened.foo).toEqual('bar');
         flattened.foo = 'baz';
         expect(rootState.foo).toEqual('baz');
     });
     it('should shadow write ', () => {
-        const rootState = { foo: 'foo' };
-        const localState = { foo: 'baz' };
+        const rootState = {
+            foo: 'foo'
+        };
+        const localState = {
+            foo: 'baz'
+        };
         const flattened = flattenState(rootState, localState, undefined);
-        expect(() => (flattened.foo = 'bar')).toThrow('Writing to local state is not allowed as it is read-only.');
+        expect(() => flattened.foo = 'bar').toThrow('Writing to local state is not allowed as it is read-only.');
     });
 });

package/dist/{sdk/functions → functions}/extract-text-styles.js

@@ -1,23 +1,11 @@
-const TEXT_STYLE_KEYS = [
-    'color',
-    'whiteSpace',
-    'direction',
-    'hyphens',
-    'overflowWrap',
-];
+const TEXT_STYLE_KEYS = ['color', 'whiteSpace', 'direction', 'hyphens', 'overflowWrap'];
 /**
  * Check if the key represent a CSS style property that applies to text
  * See MDN docs for refrence of what properties apply to text.
  * https://developer.mozilla.org/en-US/docs/Learn/CSS/Styling_text/Fundamentals#summary
  */
 const isTextStyle = (key) => {
-    return (TEXT_STYLE_KEYS.includes(key) ||
-        key.startsWith('font') ||
-        key.startsWith('text') ||
-        key.startsWith('letter') ||
-        key.startsWith('line') ||
-        key.startsWith('word') ||
-        key.startsWith('writing'));
+    return TEXT_STYLE_KEYS.includes(key) || key.startsWith('font') || key.startsWith('text') || key.startsWith('letter') || key.startsWith('line') || key.startsWith('word') || key.startsWith('writing');
 };
 /**
  * Extract styles that apply to text from a style object.

package/dist/{sdk/functions → functions}/get-block-actions-handler.js

@@ -1,10 +1,10 @@
-import { evaluate } from './evaluate.js';
-export const createEventHandler = (value, options) => (event) => evaluate({
+import { evaluate } from './evaluate';
+export const createEventHandler = (value, options) => event => evaluate({
     code: value,
     context: options.context,
     localState: options.localState,
     rootState: options.rootState,
     rootSetState: options.rootSetState,
     event,
-    isExpression: false,
+    isExpression: false
 });

package/dist/{sdk/functions → functions}/get-block-actions.d.ts

@@ -5,5 +5,6 @@ type Actions = {
 };
 export declare function getBlockActions(options: {
     block: BuilderBlock;
+    stripPrefix?: boolean;
 } & Pick<BuilderContextInterface, 'localState' | 'context' | 'rootState' | 'rootSetState'>): Actions;
 export {};

package/dist/functions/get-block-actions.js

@@ -0,0 +1,28 @@
+import { TARGET } from '../constants/target.js';
+import { getEventHandlerName } from './event-handler-name.js';
+import { createEventHandler } from './get-block-actions-handler.js';
+export function getBlockActions(options) {
+    const obj = {};
+    const optionActions = options.block.actions ?? {};
+    for (const key in optionActions) {
+        // eslint-disable-next-line no-prototype-builtins
+        if (!optionActions.hasOwnProperty(key)) {
+            continue;
+        }
+        const value = optionActions[key];
+        let eventHandlerName = getEventHandlerName(key);
+        if (options.stripPrefix) {
+            switch (TARGET) {
+                case 'vue2':
+                case 'vue3':
+                    eventHandlerName = eventHandlerName.replace('v-on:', '');
+                    break;
+                case 'svelte':
+                    eventHandlerName = eventHandlerName.replace('on:', '');
+                    break;
+            }
+        }
+        obj[eventHandlerName] = createEventHandler(value, options);
+    }
+    return obj;
+}

package/dist/{sdk/functions → functions}/get-block-component-options.js

@@ -5,6 +5,6 @@ export function getBlockComponentOptions(block) {
         /**
          * Our built-in components frequently make use of the block, so we provide all of it under `builderBlock`
          */
-        builderBlock: block,
+        builderBlock: block
     };
 }

package/dist/functions/get-block-properties.d.ts

@@ -0,0 +1,6 @@
+import type { BuilderContextInterface } from '../context/types.js';
+import type { BuilderBlock } from '../types/builder-block.js';
+export declare function getBlockProperties({ block, context }: {
+    block: BuilderBlock;
+    context: BuilderContextInterface;
+}): any;

package/dist/{sdk/functions → functions}/get-block-properties.js

@@ -1,5 +1,6 @@
 import { TARGET } from '../constants/target.js';
 import { convertStyleMapToCSSArray } from '../helpers/css.js';
+import { getReactNativeBlockStyles } from './get-react-native-block-styles.js';
 import { transformBlockProperties } from './transform-block-properties.js';
 const extractRelevantRootBlockProperties = (block) => {
     // currently we are only spreading the `href` property
@@ -29,18 +30,25 @@ const extractRelevantRootBlockProperties = (block) => {
     //   // anything set by dynamic bindings outside of predefined `BuilderBlock` properties
     //   ...remainingBlockProperties
     // } = block;
-    return { href: block.href };
+    return {
+        href: block.href
+    };
 };
-export function getBlockProperties(block) {
+export function getBlockProperties({ block, context }) {
     const properties = {
         ...extractRelevantRootBlockProperties(block),
         ...block.properties,
         'builder-id': block.id,
-        style: getStyleAttribute(block.style),
-        class: [block.id, 'builder-block', block.class, block.properties?.class]
-            .filter(Boolean)
-            .join(' '),
+        style: block.style ? getStyleAttribute(block.style) : undefined,
+        class: [block.id, 'builder-block', block.class, block.properties?.class].filter(Boolean).join(' ')
     };
+    if (TARGET === 'reactNative') {
+        properties.style = getReactNativeBlockStyles({
+            block,
+            context,
+            blockStyles: properties.style
+        });
+    }
     return transformBlockProperties(properties);
 }
 /**
@@ -49,9 +57,6 @@ export function getBlockProperties(block) {
  * Additionally, Svelte, Vue and other frameworks use kebab-case styles, so we need to convert them.
  */
 function getStyleAttribute(style) {
-    if (!style) {
-        return undefined;
-    }
     switch (TARGET) {
         case 'svelte':
         case 'vue2':
@@ -61,6 +66,7 @@ function getStyleAttribute(style) {
         case 'qwik':
         case 'reactNative':
         case 'react':
+        case 'rsc':
             return style;
     }
 }

package/dist/{sdk/functions → functions}/get-builder-search-params/fn.test.js

@@ -1,4 +1,4 @@
-import { convertSearchParamsToQueryObject, getBuilderSearchParams } from '.';
+import { convertSearchParamsToQueryObject, getBuilderSearchParams } from './index.js';
 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', () => {

package/dist/{sdk/functions → functions}/get-builder-search-params/index.js

@@ -20,11 +20,9 @@ export const getBuilderSearchParams = (_options) => {
     }
     const options = normalizeSearchParams(_options);
     const newOptions = {};
-    Object.keys(options).forEach((key) => {
+    Object.keys(options).forEach(key => {
         if (key.startsWith(BUILDER_SEARCHPARAMS_PREFIX)) {
-            const trimmedKey = key
-                .replace(BUILDER_SEARCHPARAMS_PREFIX, '')
-                .replace(BUILDER_OPTIONS_PREFIX, '');
+            const trimmedKey = key.replace(BUILDER_SEARCHPARAMS_PREFIX, '').replace(BUILDER_OPTIONS_PREFIX, '');
             newOptions[trimmedKey] = options[key];
         }
     });
@@ -37,6 +35,4 @@ export const getBuilderSearchParamsFromWindow = () => {
     const searchParams = new URLSearchParams(window.location.search);
     return getBuilderSearchParams(searchParams);
 };
-export const normalizeSearchParams = (searchParams) => searchParams instanceof URLSearchParams
-    ? convertSearchParamsToQueryObject(searchParams)
-    : searchParams;
+export const normalizeSearchParams = (searchParams) => searchParams instanceof URLSearchParams ? convertSearchParamsToQueryObject(searchParams) : searchParams;

package/dist/{sdk/functions → functions}/get-content/generate-content-url.js

@@ -1,8 +1,8 @@
 import { flatten } from '../../helpers/flatten.js';
-import { getBuilderSearchParamsFromWindow, normalizeSearchParams, } from '../get-builder-search-params/index.js';
-import { DEFAULT_API_VERSION } from '../../types/api-version';
+import { getBuilderSearchParamsFromWindow, normalizeSearchParams } from '../get-builder-search-params/index.js';
+import { DEFAULT_API_VERSION } from '../../types/api-version.js';
 export const generateContentUrl = (options) => {
-    const { limit = 30, userAttributes, query, noTraverse = false, model, apiKey, includeRefs = true, enrich, locale, apiVersion = DEFAULT_API_VERSION, } = options;
+    const { limit = 30, userAttributes, query, noTraverse = false, model, apiKey, includeRefs = true, enrich, locale, apiVersion = DEFAULT_API_VERSION } = options;
     if (!apiKey) {
         throw new Error('Missing API key');
     }
@@ -12,7 +12,7 @@ export const generateContentUrl = (options) => {
     const url = new URL(`https://cdn.builder.io/api/${apiVersion}/content/${model}?apiKey=${apiKey}&limit=${limit}&noTraverse=${noTraverse}&includeRefs=${includeRefs}${locale ? `&locale=${locale}` : ''}${enrich ? `&enrich=${enrich}` : ''}`);
     const queryOptions = {
         ...getBuilderSearchParamsFromWindow(),
-        ...normalizeSearchParams(options.options || {}),
+        ...normalizeSearchParams(options.options || {})
     };
     const flattened = flatten(queryOptions);
     for (const key in flattened) {
@@ -22,7 +22,9 @@ export const generateContentUrl = (options) => {
         url.searchParams.set('userAttributes', JSON.stringify(userAttributes));
     }
     if (query) {
-        const flattened = flatten({ query });
+        const flattened = flatten({
+            query
+        });
         for (const key in flattened) {
             url.searchParams.set(key, JSON.stringify(flattened[key]));
         }

package/dist/{sdk/functions → functions}/get-content/generate-content-url.test.js

@@ -1,4 +1,4 @@
-import { generateContentUrl } from './generate-content-url';
+import { generateContentUrl } from './generate-content-url.js';
 const testKey = 'YJIGb4i01jvw0SRdL5Bt';
 const testModel = 'page';
 const testId = 'c1b81bab59704599b997574eb0736def';
@@ -8,14 +8,16 @@ const options = {
     'overrides.037948e52eaf4743afed464f02c70da4': '037948e52eaf4743afed464f02c70da4',
     'overrides.page': '037948e52eaf4743afed464f02c70da4',
     'overrides.page:/': '037948e52eaf4743afed464f02c70da4',
-    preview: 'page',
+    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 },
+            query: {
+                id: testId
+            }
         });
         expect(output).toMatchSnapshot();
     });
@@ -23,8 +25,10 @@ describe('Generate Content URL', () => {
         const output = generateContentUrl({
             apiKey: testKey,
             model: testModel,
-            query: { id: testId },
-            options,
+            query: {
+                id: testId
+            },
+            options
         });
         expect(output).toMatchSnapshot();
     });
@@ -32,8 +36,10 @@ describe('Generate Content URL', () => {
         const output = generateContentUrl({
             apiKey: testKey,
             model: testModel,
-            query: { id: testId },
-            options,
+            query: {
+                id: testId
+            },
+            options
         });
         expect(output).toMatchSnapshot();
     });
@@ -41,9 +47,11 @@ describe('Generate Content URL', () => {
         const output = generateContentUrl({
             apiKey: testKey,
             model: testModel,
-            query: { id: testId },
+            query: {
+                id: testId
+            },
             options,
-            apiVersion: 'v2',
+            apiVersion: 'v2'
         });
         expect(output).toMatchSnapshot();
     });
@@ -51,9 +59,11 @@ describe('Generate Content URL', () => {
         const output = generateContentUrl({
             apiKey: testKey,
             model: testModel,
-            query: { id: testId },
+            query: {
+                id: testId
+            },
             options,
-            apiVersion: 'v3',
+            apiVersion: 'v3'
         });
         expect(output).toMatchSnapshot();
     });
@@ -62,9 +72,11 @@ describe('Generate Content URL', () => {
             generateContentUrl({
                 apiKey: testKey,
                 model: testModel,
-                query: { id: testId },
+                query: {
+                    id: testId
+                },
                 options,
-                apiVersion: 'v1',
+                apiVersion: 'v1'
             });
         }).toThrow(`Invalid apiVersion: expected 'v2' or 'v3', received 'v1'`);
     });
@@ -73,9 +85,11 @@ describe('Generate Content URL', () => {
             generateContentUrl({
                 apiKey: testKey,
                 model: testModel,
-                query: { id: testId },
+                query: {
+                    id: testId
+                },
                 options,
-                apiVersion: 'INVALID_API_VERSION',
+                apiVersion: 'INVALID_API_VERSION'
             });
         }).toThrow(`Invalid apiVersion: expected 'v2' or 'v3', received 'INVALID_API_VERSION'`);
     });
@@ -83,14 +97,14 @@ describe('Generate Content URL', () => {
         const output = generateContentUrl({
             apiKey: testKey,
             model: testModel,
-            enrich: true,
+            enrich: true
         });
         expect(output).toMatchSnapshot();
     });
     test('generate content url with enrich option not present', () => {
         const output = generateContentUrl({
             apiKey: testKey,
-            model: testModel,
+            model: testModel
         });
         expect(output).toMatchSnapshot();
     });

package/dist/{sdk/functions → functions}/get-content/index.d.ts

@@ -4,13 +4,9 @@ export declare function getContent(options: GetContentOptions): Promise<BuilderC
 type ContentResults = {
     results: BuilderContent[];
 };
-type ContentResponse = ContentResults | {
-    status: number;
-    message: string;
-};
 /**
  * Exported only for testing purposes. Should not be used directly.
  */
-export declare const processContentResult: (options: GetContentOptions, content: ContentResults) => Promise<ContentResults>;
-export declare function getAllContent(options: GetContentOptions): Promise<ContentResponse | null>;
+export declare const processContentResult: (options: GetContentOptions, content: ContentResults, url?: URL) => Promise<ContentResults>;
+export declare function getAllContent(options: GetContentOptions): Promise<ContentResults>;
 export {};

package/dist/{sdk/functions → functions}/get-content/index.js

@@ -2,13 +2,17 @@ import { TARGET } from '../../constants/target.js';
 import { handleABTesting } from '../../helpers/ab-tests.js';
 import { getDefaultCanTrack } from '../../helpers/canTrack.js';
 import { logger } from '../../helpers/logger.js';
+import { getPreviewContent } from '../../helpers/preview-lru-cache/get.js';
 import { fetch } from '../get-fetch.js';
 import { isBrowser } from '../is-browser.js';
 import { generateContentUrl } from './generate-content-url.js';
 const checkContentHasResults = (content) => 'results' in content;
 export async function getContent(options) {
-    const allContent = await getAllContent({ ...options, limit: 1 });
-    if (allContent && checkContentHasResults(allContent)) {
+    const allContent = await getAllContent({
+        ...options,
+        limit: 1
+    });
+    if (allContent) {
         return allContent.results[0] || null;
     }
     return null;
@@ -22,8 +26,17 @@ const fetchContent = async (options) => {
 /**
  * Exported only for testing purposes. Should not be used directly.
  */
-export const processContentResult = async (options, content) => {
+export const processContentResult = async (options, content, url = generateContentUrl(options)) => {
     const canTrack = getDefaultCanTrack(options.canTrack);
+    const isPreviewing = url.search.includes(`preview=`);
+    if (TARGET === 'rsc' && isPreviewing) {
+        const newResults = [];
+        for (const item of content.results) {
+            const previewContent = getPreviewContent(url.searchParams);
+            newResults.push(previewContent || item);
+        }
+        content.results = newResults;
+    }
     if (!canTrack)
         return content;
     if (!(isBrowser() || TARGET === 'reactNative'))
@@ -37,7 +50,10 @@ export const processContentResult = async (options, content) => {
     try {
         const newResults = [];
         for (const item of content.results) {
-            newResults.push(await handleABTesting({ item, canTrack }));
+            newResults.push(await handleABTesting({
+                item,
+                canTrack
+            }));
         }
         content.results = newResults;
     }
@@ -51,8 +67,12 @@ export async function getAllContent(options) {
         const url = generateContentUrl(options);
         const content = await fetchContent(options);
         if (!checkContentHasResults(content)) {
-            logger.error('Error fetching data. ', { url, content, options });
-            return content;
+            logger.error('Error fetching data. ', {
+                url,
+                content,
+                options
+            });
+            return null;
         }
         return processContentResult(options, content);
     }

package/dist/functions/get-content/processCookies.d.ts

@@ -0,0 +1,2 @@
+import type { BuilderContent } from '../../types/builder-content.js';
+export declare const processCookies: (content: BuilderContent) => BuilderContent;

package/dist/functions/get-content/processCookies.js

@@ -0,0 +1,3 @@
+export const processCookies = (content) => {
+    return content;
+};

package/dist/{sdk/functions → functions}/get-processed-block.d.ts

@@ -1,6 +1,6 @@
 import type { BuilderContextInterface } from '../context/types.js';
 import type { BuilderBlock } from '../types/builder-block.js';
-export declare function getProcessedBlock({ block, context, shouldEvaluateBindings, localState, rootState, rootSetState, }: {
+export declare function getProcessedBlock({ block, context, shouldEvaluateBindings, localState, rootState, rootSetState }: {
     block: BuilderBlock;
     /**
      * In some cases, we want to avoid evaluating bindings and only want framework-specific block transformation. It is