@builder.io/sdk-react 0.2.3 → 0.4.0

package/dist/sdk/components/render-content/wrap-component-ref.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Apply target-specific transformations to the component reference.
+ *
+ * See overrides/* for examples.
+ */
+export declare const wrapComponentRef: (component: any) => any;

package/dist/sdk/components/render-content/wrap-component-ref.js

@@ -0,0 +1,6 @@
+/**
+ * Apply target-specific transformations to the component reference.
+ *
+ * See overrides/* for examples.
+ */
+export const wrapComponentRef = (component) => component;

package/dist/sdk/components/render-content-variants/helpers.d.ts

@@ -0,0 +1,17 @@
+import type { Nullable } from '../../helpers/nullable';
+import type { BuilderContent } from '../../types/builder-content';
+export declare const getVariants: (content: Nullable<BuilderContent>) => import("../../types/builder-content").BuilderContentVariation[];
+export declare const checkShouldRunVariants: ({ canTrack, content, }: {
+    canTrack: Nullable<boolean>;
+    content: Nullable<BuilderContent>;
+}) => boolean;
+type VariantData = {
+    id: string;
+    testRatio?: number;
+};
+export declare const getVariantsScriptString: (variants: VariantData[], contentId: string) => string;
+export declare const getRenderContentScriptString: ({ parentContentId, contentId, }: {
+    contentId: string;
+    parentContentId: string;
+}) => string;
+export {};

package/dist/sdk/components/render-content-variants/helpers.js

@@ -0,0 +1,182 @@
+import { isBrowser } from '../../functions/is-browser';
+export const getVariants = (content) => Object.values(content?.variations || {});
+export const checkShouldRunVariants = ({ canTrack, content, }) => {
+    const hasVariants = getVariants(content).length > 0;
+    if (!hasVariants) {
+        return false;
+    }
+    if (!canTrack) {
+        return false;
+    }
+    if (isBrowser()) {
+        return false;
+    }
+    return true;
+};
+/**
+ * NOTE: when this function is stringified, single-line comments can cause weird issues when compiled by Sveltekit.
+ * Make sure to write multi-line comments only.
+ */
+function bldrAbTest(contentId, variants, isHydrationTarget) {
+    function getAndSetVariantId() {
+        function setCookie(name, value, days) {
+            let expires = '';
+            if (days) {
+                const date = new Date();
+                date.setTime(date.getTime() + days * 24 * 60 * 60 * 1000);
+                expires = '; expires=' + date.toUTCString();
+            }
+            document.cookie =
+                name +
+                    '=' +
+                    (value || '') +
+                    expires +
+                    '; path=/' +
+                    '; Secure; SameSite=None';
+        }
+        function getCookie(name) {
+            const nameEQ = name + '=';
+            const ca = document.cookie.split(';');
+            for (let i = 0; i < ca.length; i++) {
+                let c = ca[i];
+                while (c.charAt(0) === ' ')
+                    c = c.substring(1, c.length);
+                if (c.indexOf(nameEQ) === 0)
+                    return c.substring(nameEQ.length, c.length);
+            }
+            return null;
+        }
+        const cookieName = `builder.tests.${contentId}`;
+        const variantInCookie = getCookie(cookieName);
+        const availableIDs = variants.map((vr) => vr.id).concat(contentId);
+        /**
+         * cookie already exists
+         */
+        if (variantInCookie && availableIDs.includes(variantInCookie)) {
+            return variantInCookie;
+        }
+        /**
+         * no cookie exists, find variant
+         */
+        let n = 0;
+        const random = Math.random();
+        for (let i = 0; i < variants.length; i++) {
+            const variant = variants[i];
+            const testRatio = variant.testRatio;
+            n += testRatio;
+            if (random < n) {
+                setCookie(cookieName, variant.id);
+                return variant.id;
+            }
+        }
+        /**
+         * no variant found, assign default content
+         */
+        setCookie(cookieName, contentId);
+        return contentId;
+    }
+    const winningVariantId = getAndSetVariantId();
+    const styleEl = document.getElementById(`variants-styles-${contentId}`);
+    /**
+     * For React to work, we need hydration to match SSR, so we completely remove this node and the styles tag.
+     */
+    if (isHydrationTarget) {
+        styleEl.remove();
+        const thisScriptEl = document.getElementById(`variants-script-${contentId}`);
+        thisScriptEl?.remove();
+    }
+    else {
+        /* update styles to hide all variants except the winning variant */
+        const newStyleStr = variants
+            .concat({ id: contentId })
+            .filter((variant) => variant.id !== winningVariantId)
+            .map((value) => {
+            return `.variant-${value.id} {  display: none; }
+        `;
+        })
+            .join('');
+        /* TO-DO: check if this actually updates the style */
+        styleEl.innerHTML = newStyleStr;
+    }
+}
+/**
+ * NOTE: when this function is stringified, single-line comments can cause weird issues when compiled by Sveltekit.
+ * Make sure to write multi-line comments only.
+ */
+function bldrCntntScrpt(variantContentId, defaultContentId, isHydrationTarget) {
+    if (!navigator.cookieEnabled) {
+        return;
+    }
+    function getCookie(name) {
+        const nameEQ = name + '=';
+        const ca = document.cookie.split(';');
+        for (let i = 0; i < ca.length; i++) {
+            let c = ca[i];
+            while (c.charAt(0) === ' ')
+                c = c.substring(1, c.length);
+            if (c.indexOf(nameEQ) === 0)
+                return c.substring(nameEQ.length, c.length);
+        }
+        return null;
+    }
+    const cookieName = `builder.tests.${defaultContentId}`;
+    const variantId = getCookie(cookieName);
+    /** get parent div by searching on `builder-content-id` attr */
+    const parentDiv = document.querySelector(`[builder-content-id="${variantContentId}"]`);
+    const variantIsDefaultContent = variantContentId === defaultContentId;
+    if (variantId === variantContentId) {
+        if (variantIsDefaultContent) {
+            /** the default content is already visible, no need to do anything */
+            return;
+        }
+        /** this is the winning variant and not already visible: remove `hidden` and `aria-hidden` attr */
+        parentDiv?.removeAttribute('hidden');
+        parentDiv?.removeAttribute('aria-hidden');
+    }
+    else {
+        if (variantIsDefaultContent) {
+            if (isHydrationTarget) {
+                /**
+                 * For React to work, we need to support hydration, in which case the first CSR will have none of the hidden variants.
+                 * So we completely remove that node.
+                 */
+                parentDiv?.remove();
+            }
+            else {
+                /** this is not the winning variant, add `hidden` attr */
+                parentDiv?.setAttribute('hidden', 'true');
+                parentDiv?.setAttribute('aria-hidden', 'true');
+            }
+        }
+        /** This is not the winning variant, and it's not the default content.
+         * There's no need to hide it, because it's already hidden.
+         */
+        return;
+    }
+    return;
+}
+const isHydrationTarget = (target) => target === 'react' ||
+    target === 'reactNative' ||
+    target === 'vue3' ||
+    target === 'vue2';
+/**
+ * We hardcode explicit function names here, because the `.toString()` of a function can change depending on the bundler.
+ * Some bundlers will minify the fn name, etc.
+ *
+ * So we hardcode the function names here, and then use those names in the script string to make sure the function names are consistent.
+ */
+const AB_TEST_FN_NAME = 'bldrAbTest';
+const CONTENT_FN_NAME = 'bldrCntntScrpt';
+export const getVariantsScriptString = (variants, contentId) => {
+    const fnStr = bldrAbTest.toString().replace(/\s+/g, ' ');
+    const fnStr2 = bldrCntntScrpt.toString().replace(/\s+/g, ' ');
+    return `
+  const ${AB_TEST_FN_NAME} = ${fnStr}
+  const ${CONTENT_FN_NAME} = ${fnStr2}
+  ${AB_TEST_FN_NAME}("${contentId}", ${JSON.stringify(variants)}, ${isHydrationTarget})
+  `;
+};
+export const getRenderContentScriptString = ({ parentContentId, contentId, }) => {
+    return `
+  ${CONTENT_FN_NAME}("${contentId}", "${parentContentId}", ${isHydrationTarget})`;
+};

package/dist/sdk/components/render-content-variants/render-content-variants.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+type VariantsProviderProps = RenderContentProps;
+import type { RenderContentProps } from "../render-content/render-content.types";
+declare function RenderContentVariants(props: VariantsProviderProps): JSX.Element;
+export default RenderContentVariants;

package/dist/sdk/components/render-content-variants/render-content-variants.js

@@ -0,0 +1,37 @@
+'use client';
+import * as React from "react";
+import { useState } from "react";
+import { checkShouldRunVariants, getVariants, getVariantsScriptString, } from "./helpers";
+import RenderContent from "../render-content/render-content";
+import { getDefaultCanTrack } from "../../helpers/canTrack";
+import RenderInlinedStyles from "../render-inlined-styles";
+import { handleABTestingSync } from "../../helpers/ab-tests";
+function RenderContentVariants(props) {
+    const [variantScriptStr, setVariantScriptStr] = useState(() => getVariantsScriptString(getVariants(props.content).map((value) => ({
+        id: value.id,
+        testRatio: value.testRatio,
+    })), props.content?.id || ""));
+    const [shouldRenderVariants, setShouldRenderVariants] = useState(() => checkShouldRunVariants({
+        canTrack: getDefaultCanTrack(props.canTrack),
+        content: props.content,
+    }));
+    const [hideVariantsStyleString, setHideVariantsStyleString] = useState(() => getVariants(props.content)
+        .map((value) => `.variant-${value.id} { display: none; } `)
+        .join(""));
+    const [contentToRender, setContentToRender] = useState(() => checkShouldRunVariants({
+        canTrack: getDefaultCanTrack(props.canTrack),
+        content: props.content,
+    })
+        ? props.content
+        : handleABTestingSync({
+            item: props.content,
+            canTrack: getDefaultCanTrack(props.canTrack),
+        }));
+    return (React.createElement(React.Fragment, null,
+        shouldRenderVariants ? (React.createElement(React.Fragment, null,
+            React.createElement(RenderInlinedStyles, { id: `variants-styles-${props.content?.id}`, styles: hideVariantsStyleString }),
+            React.createElement("script", { id: `variants-script-${props.content?.id}`, dangerouslySetInnerHTML: { __html: variantScriptStr } }),
+            getVariants(props.content)?.map((variant) => (React.createElement(RenderContent, { key: variant.id, content: variant, apiKey: props.apiKey, apiVersion: props.apiVersion, canTrack: props.canTrack, customComponents: props.customComponents, hideContent: true, parentContentId: props.content?.id, isSsrAbTest: shouldRenderVariants }))))) : null,
+        React.createElement(RenderContent, { model: props.model, content: contentToRender, apiKey: props.apiKey, apiVersion: props.apiVersion, canTrack: props.canTrack, customComponents: props.customComponents, classNameProp: `variant-${props.content?.id}`, parentContentId: props.content?.id, isSsrAbTest: shouldRenderVariants })));
+}
+export default RenderContentVariants;

package/dist/sdk/components/render-inlined-styles.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="react" />
 interface Props {
     styles: string;
+    id?: string;
 }
 declare function RenderInlinedStyles(props: Props): JSX.Element;
 export default RenderInlinedStyles;

package/dist/sdk/components/render-inlined-styles.js

@@ -1,17 +1,6 @@
-"use client";
+'use client';
 import * as React from "react";
-import { TARGET } from "../constants/target.js";
 function RenderInlinedStyles(props) {
-    function tag() {
-        // NOTE: we have to obfusctate the name of the tag due to a limitation in the svelte-preprocessor plugin.
-        // https://github.com/sveltejs/vite-plugin-svelte/issues/315#issuecomment-1109000027
-        return "style";
-    }
-    function injectedStyleScript() {
-        return `<${tag()}>${props.styles}</${tag()}>`;
-    }
-    const TagRef = tag();
-    return (React.createElement(React.Fragment, null, TARGET === "svelte" || TARGET === "qwik" ? (React.createElement(React.Fragment, null,
-        React.createElement(TagRef, { dangerouslySetInnerHTML: { __html: props.styles } }))) : (React.createElement(TagRef, null, props.styles))));
+    return (React.createElement("style", { dangerouslySetInnerHTML: { __html: props.styles }, id: props.id }));
 }
 export default RenderInlinedStyles;

package/dist/sdk/constants/sdk-version.d.ts

@@ -0,0 +1 @@
+export declare const SDK_VERSION = "0.4.0";

package/dist/sdk/constants/sdk-version.js

@@ -0,0 +1 @@
+export const SDK_VERSION = "0.4.0";

package/dist/sdk/context/builder.context.js

@@ -2,8 +2,9 @@ import { createContext } from "react";
 export default createContext({
     content: null,
     context: {},
-    state: {},
-    setState() { },
+    localState: undefined,
+    rootSetState() { },
+    rootState: {},
     apiKey: null,
     apiVersion: undefined,
     registeredComponents: {},

package/dist/sdk/context/types.d.ts

@@ -11,8 +11,23 @@ export type BuilderRenderContext = Record<string, unknown>;
 export interface BuilderContextInterface {
     content: Nullable<BuilderContent>;
     context: BuilderRenderContext;
-    state: BuilderRenderState;
-    setState?: (state: BuilderRenderState) => void;
+    /**
+     * The state of the application.
+     *
+     * NOTE: see `localState` below to understand how it is different from `rootState`.
+     */
+    rootState: BuilderRenderState;
+    /**
+     * Some frameworks have a `setState` function which needs to be invoked to notify
+     * the framework of state change. (other frameworks don't in which case it is `undefined')
+     */
+    rootSetState: ((rootState: BuilderRenderState) => void) | undefined;
+    /**
+     * The local state of the current component. This is different from `rootState` in that
+     * it can be a child state created by a repeater containing local state.
+     * The `rootState` is where all of the state mutations are actually stored.
+     */
+    localState: BuilderRenderState | undefined;
     apiKey: string | null;
     apiVersion: ApiVersion | undefined;
     registeredComponents: RegisteredComponents;

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

@@ -1,6 +1,7 @@
-import type { BuilderContextInterface } from '../context/types.js';
-export declare function evaluate({ code, context, state, event, isExpression, }: {
+import type { BuilderContextInterface, BuilderRenderState } from '../context/types.js';
+export declare function evaluate({ code, context, localState, rootState, rootSetState, event, isExpression, }: {
     code: string;
     event?: Event;
     isExpression?: boolean;
-} & Pick<BuilderContextInterface, 'state' | 'context'>): any;
+} & Pick<BuilderContextInterface, 'localState' | 'context' | 'rootState' | 'rootSetState'>): any;
+export declare function flattenState(rootState: Record<string | symbol, any>, localState: Record<string | symbol, any> | undefined, rootSetState: ((rootState: BuilderRenderState) => void) | undefined): BuilderRenderState;

package/dist/sdk/functions/evaluate.js

@@ -1,6 +1,6 @@
 import { isBrowser } from './is-browser.js';
 import { isEditing } from './is-editing.js';
-export function evaluate({ code, context, state, event, isExpression = true, }) {
+export function evaluate({ code, context, localState, rootState, rootSetState, event, isExpression = true, }) {
     if (code === '') {
         console.warn('Skipping evaluation of empty code block.');
         return;
@@ -20,9 +20,30 @@ export function evaluate({ code, context, state, event, isExpression = true, })
             code.trim().startsWith('return '));
     const useCode = useReturn ? `return (${code});` : code;
     try {
-        return new Function('builder', 'Builder' /* <- legacy */, 'state', 'context', 'event', useCode)(builder, builder, state, context, event);
+        return new Function('builder', 'Builder' /* <- legacy */, 'state', 'context', 'event', useCode)(builder, builder, flattenState(rootState, localState, rootSetState), context, event);
     }
     catch (e) {
         console.warn('Builder custom code error: \n While Evaluating: \n ', useCode, '\n', e);
     }
 }
+export function flattenState(rootState, localState, rootSetState) {
+    if (rootState === localState) {
+        throw new Error('rootState === localState');
+    }
+    return new Proxy(rootState, {
+        get: (_, prop) => {
+            if (localState && prop in localState) {
+                return localState[prop];
+            }
+            return rootState[prop];
+        },
+        set: (_, prop, value) => {
+            if (localState && prop in localState) {
+                throw new Error('Writing to local state is not allowed as it is read-only.');
+            }
+            rootState[prop] = value;
+            rootSetState?.(rootState);
+            return true;
+        },
+    });
+}

package/dist/sdk/functions/evaluate.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sdk/functions/evaluate.test.js

@@ -0,0 +1,17 @@
+import { flattenState } from './evaluate';
+describe('flatten state', () => {
+    it('should behave normally when no PROTO_STATE', () => {
+        const localState = {};
+        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 flattened = flattenState(rootState, localState, undefined);
+        expect(() => (flattened.foo = 'bar')).toThrow('Writing to local state is not allowed as it is read-only.');
+    });
+});

package/dist/sdk/functions/get-block-actions-handler.d.ts

@@ -2,7 +2,7 @@ import type { BuilderContextInterface } from '../context/types.js';
 import type { BuilderBlock } from '../types/builder-block.js';
 type Options = {
     block: BuilderBlock;
-} & Pick<BuilderContextInterface, 'state' | 'context'>;
+} & Pick<BuilderContextInterface, 'localState' | 'context' | 'rootState' | 'rootSetState'>;
 type EventHandler = (event: Event) => any;
 export declare const createEventHandler: (value: string, options: Options) => EventHandler;
 export {};

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

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

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

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

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

@@ -2,14 +2,14 @@ import { flatten } from '../../helpers/flatten.js';
 import { getBuilderSearchParamsFromWindow, normalizeSearchParams, } from '../get-builder-search-params/index.js';
 import { DEFAULT_API_VERSION } from '../../types/api-version';
 export const generateContentUrl = (options) => {
-    const { limit = 30, userAttributes, query, noTraverse = false, model, apiKey, includeRefs = true, 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');
     }
     if (!['v2', 'v3'].includes(apiVersion)) {
         throw new Error(`Invalid apiVersion: expected 'v2' or 'v3', received '${apiVersion}'`);
     }
-    const url = new URL(`https://cdn.builder.io/api/${apiVersion}/content/${model}?apiKey=${apiKey}&limit=${limit}&noTraverse=${noTraverse}&includeRefs=${includeRefs}${locale ? `&locale=${locale}` : ''}`);
+    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 || {}),

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

@@ -79,4 +79,19 @@ describe('Generate Content URL', () => {
             });
         }).toThrow(`Invalid apiVersion: expected 'v2' or 'v3', received 'INVALID_API_VERSION'`);
     });
+    test('generate content url with enrich option true', () => {
+        const output = generateContentUrl({
+            apiKey: testKey,
+            model: testModel,
+            enrich: true,
+        });
+        expect(output).toMatchSnapshot();
+    });
+    test('generate content url with enrich option not present', () => {
+        const output = generateContentUrl({
+            apiKey: testKey,
+            model: testModel,
+        });
+        expect(output).toMatchSnapshot();
+    });
 });

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

@@ -1,11 +1,16 @@
 import type { BuilderContent } from '../../types/builder-content.js';
 import type { GetContentOptions } from './types.js';
 export declare function getContent(options: GetContentOptions): Promise<BuilderContent | null>;
-type ContentResponse = {
+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 {};

package/dist/sdk/functions/get-content/index.js

@@ -1,37 +1,60 @@
+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 { fetch } from '../get-fetch.js';
-import { handleABTesting } from './ab-testing.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 && 'results' in allContent) {
-        return allContent?.results[0] || null;
+    if (allContent && checkContentHasResults(allContent)) {
+        return allContent.results[0] || null;
     }
     return null;
 }
+const fetchContent = async (options) => {
+    const url = generateContentUrl(options);
+    const res = await fetch(url.href);
+    const content = await res.json();
+    return content;
+};
+/**
+ * Exported only for testing purposes. Should not be used directly.
+ */
+export const processContentResult = async (options, content) => {
+    const canTrack = getDefaultCanTrack(options.canTrack);
+    if (!canTrack)
+        return content;
+    if (!(isBrowser() || TARGET === 'reactNative'))
+        return content;
+    /**
+     * For client-side navigations, it is ideal to handle AB testing at this point instead of using our
+     * complex multi-rendering variants approach, which is only needed for SSR'd content.
+     *
+     * This is also where react-native would handle AB testing.
+     */
+    try {
+        const newResults = [];
+        for (const item of content.results) {
+            newResults.push(await handleABTesting({ item, canTrack }));
+        }
+        content.results = newResults;
+    }
+    catch (e) {
+        logger.error('Could not process A/B tests. ', e);
+    }
+    return content;
+};
 export async function getAllContent(options) {
     try {
         const url = generateContentUrl(options);
-        const res = await fetch(url.href);
-        const content = await res.json();
-        if ('status' in content && !('results' in content)) {
+        const content = await fetchContent(options);
+        if (!checkContentHasResults(content)) {
             logger.error('Error fetching data. ', { url, content, options });
             return content;
         }
-        const canTrack = options.canTrack !== false;
-        try {
-            if (canTrack &&
-                // This makes sure we have a non-error response with the results array.
-                Array.isArray(content.results)) {
-                for (const item of content.results) {
-                    await handleABTesting({ item, canTrack });
-                }
-            }
-        }
-        catch (e) {
-            logger.error('Could not setup A/B testing. ', e);
-        }
-        return content;
+        return processContentResult(options, content);
     }
     catch (error) {
         logger.error('Error fetching data. ', error);

package/dist/sdk/functions/get-content/types.d.ts

@@ -19,6 +19,7 @@ export interface GetContentOptions {
     /**
      * If set to `true`, it will lazy load symbols/references.
      * If set to `false`, it will render the entire content tree eagerly.
+     * @deprecated use `enrich` instead
      */
     noTraverse?: boolean;
     /**
@@ -30,8 +31,13 @@ export interface GetContentOptions {
     canTrack?: boolean;
     /**
      * Include references in the response. Defaults to `true`.
+     * @deprecated use `enrich` instead
      */
     includeRefs?: boolean;
+    /**
+     * Include multilevel references in the response.
+     */
+    enrich?: boolean;
     /**
      * If provided, the API will auto-resolve localized objects to the value of this `locale` key.
      */

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

@@ -1,10 +1,10 @@
 import type { BuilderContextInterface } from '../context/types.js';
 import type { BuilderBlock } from '../types/builder-block.js';
-export declare function getProcessedBlock({ block, context, shouldEvaluateBindings, state, }: {
+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
      * also sometimes too early to consider bindings, e.g. when we might be looking at a repeated block.
      */
     shouldEvaluateBindings: boolean;
-} & Pick<BuilderContextInterface, 'state' | 'context'>): BuilderBlock;
+} & Pick<BuilderContextInterface, 'localState' | 'context' | 'rootState' | 'rootSetState'>): BuilderBlock;