@builder.io/sdk-svelte 5.2.15 → 5.3.0

package/lib/edge/functions/evaluate/should-force-browser-runtime-in-node.js

@@ -1,5 +1,6 @@
 import { logger } from '../../helpers/logger';
 import { isNodeRuntime } from '../is-node-runtime';
+let hasLoggedWarning = false;
 export const shouldForceBrowserRuntimeInNode = ({ shouldLogWarning }) => {
     if (!isNodeRuntime())
         return false;
@@ -7,7 +8,8 @@ export const shouldForceBrowserRuntimeInNode = ({ shouldLogWarning }) => {
     const isNode20 = process.version.startsWith('v20');
     const hasNoNodeSnapshotNodeOption = process.env.NODE_OPTIONS?.includes('--no-node-snapshot');
     if (isArm64 && isNode20 && !hasNoNodeSnapshotNodeOption) {
-        if (shouldLogWarning) {
+        if (shouldLogWarning && !hasLoggedWarning) {
+            hasLoggedWarning = true;
             logger.log(`Skipping usage of \`isolated-vm\` to avoid crashes in Node v20 on an arm64 machine.
     If you would like to use the \`isolated-vm\` package on this machine, please provide the \`NODE_OPTIONS=--no-node-snapshot\` config to your Node process.
     See https://github.com/BuilderIO/builder/blob/main/packages/sdks/README.md#node-v20--m1-macs-apple-silicon-support for more information.

package/lib/edge/functions/extract-localized-values.d.ts

@@ -1,2 +1,6 @@
 import type { BuilderBlock } from '../types/builder-block';
+/**
+ * Returns the block with localized values in `component.options` resolved.
+ * The block is returned unchanged (same object) when it has none.
+ */
 export declare function resolveLocalizedValues(block: BuilderBlock, locale: string | undefined): BuilderBlock;

package/lib/edge/functions/extract-localized-values.js

@@ -1,37 +1,76 @@
-import { traverse } from './traverse';
 function isLocalizedField(value) {
     return value && typeof value === 'object' && value['@type'] === '@builder.io/core:LocalizedValue';
 }
-function containsLocalizedValues(data) {
-    if (!data || !Object.getOwnPropertyNames(data).length) {
-        return false;
+const isPlainObjectOrArray = (value) => {
+    if (Array.isArray(value))
+        return true;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+};
+/**
+ * Returns `value` with every localized value replaced by its `locale` entry.
+ * Only the objects and arrays on the way to a replaced value are copied: the
+ * input is never mutated, and a value with nothing localized is returned as-is.
+ */
+function resolveLocalized(value, locale, seen) {
+    if (value === null || typeof value !== 'object')
+        return value;
+    if (isLocalizedField(value)) {
+        return resolveLocalized(value[locale] ?? undefined, locale, seen);
     }
-    let hasLocalizedValues = false;
-    traverse(data, value => {
-        if (isLocalizedField(value)) {
-            hasLocalizedValues = true;
-            return;
+    if (!isPlainObjectOrArray(value))
+        return value;
+    if (seen.has(value))
+        return seen.get(value);
+    seen.set(value, value);
+    let copy = null;
+    if (Array.isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+            const next = resolveLocalized(value[i], locale, seen);
+            if (next !== value[i]) {
+                if (!copy)
+                    copy = value.slice();
+                copy[i] = next;
+            }
         }
-    });
-    return hasLocalizedValues;
-}
-function extractLocalizedValues(data, locale) {
-    if (!data || !Object.getOwnPropertyNames(data).length) {
-        return {};
     }
-    traverse(data, (value, update) => {
-        if (isLocalizedField(value)) {
-            update(value[locale] ?? undefined);
+    else {
+        for (const key of Object.keys(value)) {
+            const next = resolveLocalized(value[key], locale, seen);
+            if (next !== value[key]) {
+                if (!copy)
+                    copy = {
+                        ...value
+                    };
+                copy[key] = next;
+            }
         }
-    });
-    return data;
+    }
+    const result = copy ?? value;
+    seen.set(value, result);
+    return result;
 }
+/**
+ * Returns the block with localized values in `component.options` resolved.
+ * The block is returned unchanged (same object) when it has none.
+ */
 export function resolveLocalizedValues(block, locale) {
-    if (block.component?.options && containsLocalizedValues(block.component?.options)) {
-        if (!locale) {
-            console.warn('[Builder.io] In order to use localized fields in Builder, you must pass a locale prop to the BuilderComponent or to options object while fetching the content to resolve localized fields. Learn more: https://www.builder.io/c/docs/localization-inline#targeting-and-inline-localization');
-        }
-        block.component.options = extractLocalizedValues(block.component.options, locale ?? 'Default');
+    const options = block.component?.options;
+    if (!options || typeof options !== 'object' || isLocalizedField(options)) {
+        return block;
     }
-    return block;
+    const resolvedOptions = resolveLocalized(options, locale ?? 'Default', new WeakMap());
+    if (resolvedOptions === options) {
+        return block;
+    }
+    if (!locale) {
+        console.warn('[Builder.io] In order to use localized fields in Builder, you must pass a locale prop to the BuilderComponent or to options object while fetching the content to resolve localized fields. Learn more: https://www.builder.io/c/docs/localization-inline#targeting-and-inline-localization');
+    }
+    return {
+        ...block,
+        component: {
+            ...block.component,
+            options: resolvedOptions
+        }
+    };
 }

package/lib/edge/functions/get-block-properties.js

@@ -34,9 +34,10 @@ const extractRelevantRootBlockProperties = (block) => {
     };
 };
 export function getBlockProperties({ block, context }) {
+    const { _newProperty, ...blockProperties } = block.properties || {};
     const properties = {
         ...extractRelevantRootBlockProperties(block),
-        ...block.properties,
+        ...blockProperties,
         'builder-id': block.id,
         style: getStyle({
             block,

package/lib/edge/functions/get-processed-block.d.ts

@@ -1,6 +1,5 @@
 import type { BuilderContextInterface } from '../context/types';
 import type { BuilderBlock } from '../types/builder-block';
-export declare function deepCloneWithConditions<T = any>(obj: T): T;
 export declare function getProcessedBlock({ block, context, localState, rootState, rootSetState }: {
     block: BuilderBlock;
 } & Pick<BuilderContextInterface, 'localState' | 'context' | 'rootState' | 'rootSetState'>): BuilderBlock;

package/lib/edge/functions/get-processed-block.js

@@ -1,64 +1,25 @@
-import { TARGET } from '../constants/target';
-import { omit } from '../helpers/omit';
 import { evaluate } from './evaluate/index';
 import { resolveLocalizedValues } from './extract-localized-values';
-import { fastClone } from './fast-clone';
-import { set } from './set';
+import { isEditingOrPreviewing } from './is-editing-or-previewing';
+import { setCopyOnWrite } from './set';
 import { transformBlock } from './transform-block';
-// Deep clone a block but without cloning any child blocks
-export function deepCloneWithConditions(obj) {
-    if (obj === null || typeof obj !== 'object') {
-        return obj;
-    }
-    if (Array.isArray(obj)) {
-        return obj.map((item) => deepCloneWithConditions(item));
-    }
-    if (obj['@type'] === '@builder.io/sdk:Element') {
-        return obj;
-    }
-    const clonedObj = {};
-    for (const key in obj) {
-        if (key !== 'meta' && Object.prototype.hasOwnProperty.call(obj, key)) {
-            clonedObj[key] = deepCloneWithConditions(obj[key]);
-        }
-    }
-    return clonedObj;
-}
-const IS_SDK_WITHOUT_CACHED_PROCESSED_BLOCK = ['svelte', 'vue', 'angular', 'qwik', 'solid'].includes(TARGET);
-const getCopy = (block) => {
-    if (IS_SDK_WITHOUT_CACHED_PROCESSED_BLOCK) {
-        const copy = fastClone(block);
-        const copied = {
-            ...copy,
-            properties: {
-                ...copy.properties
-            },
-            actions: {
-                ...copy.actions
-            }
-        };
-        return copied;
-    }
-    else {
-        const copy = deepCloneWithConditions(omit(block, 'children', 'meta'));
-        return {
-            ...copy,
-            properties: {
-                ...copy.properties
-            },
-            actions: {
-                ...copy.actions
-            },
-            children: block.children,
-            meta: block.meta
-        };
-    }
-};
 const evaluateBindings = ({ block, context, localState, rootState, rootSetState }) => {
     if (!block.bindings) {
         return block;
     }
-    const copied = getCopy(block);
+    // Only objects along a bound path are copied: the block (and content) passed in is never mutated.
+    const copied = new WeakSet();
+    const copy = {
+        ...block,
+        properties: {
+            ...block.properties
+        },
+        actions: {
+            ...block.actions
+        }
+    };
+    copied.add(copy.properties);
+    copied.add(copy.actions);
     for (const binding in block.bindings) {
         const expression = block.bindings[binding];
         const value = evaluate({
@@ -68,11 +29,32 @@ const evaluateBindings = ({ block, context, localState, rootState, rootSetState
             rootSetState,
             context
         });
-        set(copied, binding, value);
+        setCopyOnWrite(copy, binding, value, copied);
     }
-    return copied;
+    return copy;
+};
+/**
+ * A block without bindings processes to the same result for a given locale, so
+ * it is computed once per block object instead of on every render.
+ * Only the latest locale is kept, so a block holds at most one cached result.
+ */
+const PROCESSED_BLOCKS_WITHOUT_BINDINGS = new WeakMap();
+const hasBindings = (block) => {
+    if (!block.bindings)
+        return false;
+    for (const _ in block.bindings)
+        return true;
+    return false;
 };
 export function getProcessedBlock({ block, context, localState, rootState, rootSetState }) {
+    const locale = rootState.locale;
+    const canUseCache = !hasBindings(block) && typeof block === 'object' && block !== null && !isEditingOrPreviewing();
+    const cacheKey = locale ?? '';
+    if (canUseCache) {
+        const cached = PROCESSED_BLOCKS_WITHOUT_BINDINGS.get(block);
+        if (cached && cached.locale === cacheKey)
+            return cached.block;
+    }
     let transformedBlock = transformBlock(block);
     transformedBlock = evaluateBindings({
         block: transformedBlock,
@@ -81,6 +63,12 @@ export function getProcessedBlock({ block, context, localState, rootState, rootS
         rootSetState,
         context
     });
-    transformedBlock = resolveLocalizedValues(transformedBlock, rootState.locale);
+    transformedBlock = resolveLocalizedValues(transformedBlock, locale);
+    if (canUseCache) {
+        PROCESSED_BLOCKS_WITHOUT_BINDINGS.set(block, {
+            locale: cacheKey,
+            block: transformedBlock
+        });
+    }
     return transformedBlock;
 }

package/lib/edge/functions/is-editing-or-previewing.d.ts

@@ -0,0 +1 @@
+export declare const isEditingOrPreviewing: () => boolean;

package/lib/edge/functions/is-editing-or-previewing.js

@@ -0,0 +1,3 @@
+import { isEditing } from './is-editing';
+import { isPreviewing } from './is-previewing';
+export const isEditingOrPreviewing = () => isEditing() || isPreviewing();

package/lib/edge/functions/set.d.ts

@@ -2,6 +2,34 @@
  * Minimal implementation of lodash's _.set
  * https://lodash.com/docs/4.17.15#set
  *
- * See ./set.test.ts for usage examples
+ * Mutates `obj` in place, creating missing objects/arrays along the path:
+ *
+ *   const obj = { a: { b: 1 } };
+ *   set(obj, 'a.c', 2);      // obj is { a: { b: 1, c: 2 } }
+ *   set(obj, 'list.0', 'x'); // obj.list is ['x']
+ *
+ * See ./set.test.ts for more usage examples
  */
 export declare const set: (obj: any, _path: string | string[], value: any) => any;
+/**
+ * Like `set`, but every object or array along `path` that is not in `copied`
+ * is shallow-copied before being written to, so objects shared with the
+ * original are never mutated. `obj` itself must already be a copy.
+ *
+ *   const block = { options: { text: 'a' }, style: { color: 'red' } };
+ *   const copy = { ...block };
+ *   setCopyOnWrite(copy, 'options.text', 'b', new WeakSet());
+ *   // copy.options is a new object: { text: 'b' }
+ *   // block.options.text is still 'a'
+ *   // copy.style === block.style (untouched branches stay shared)
+ */
+export declare const setCopyOnWrite: (obj: any, _path: string, value: any, copied: WeakSet<object>) => any;
+/**
+ * Deletes the property at `path`, the inverse of `set` for an array path.
+ * Mutates `obj` in place and does nothing when a parent is missing:
+ *
+ *   const obj = { a: { b: 1, c: 2 } };
+ *   unset(obj, ['a', 'b']); // obj is { a: { c: 2 } }
+ *   unset(obj, ['x', 'y']); // no-op
+ */
+export declare const unset: (obj: any, path: string[]) => any;

package/lib/edge/functions/set.js

@@ -1,14 +1,98 @@
+const parsePath = (path) => path.toString().match(/[^.[\]]+/g);
+const isArrayIndex = (key) => Math.abs(Number(key)) >> 0 === +key;
+/**
+ * `__proto__` is never allowed. `constructor` and `prototype` are allowed only as
+ * the final key, where they are written as ordinary own properties.
+ */
+const hasUnsafeSegment = (path) => path.some((key, i) => key === '__proto__' || i < path.length - 1 && (key === 'constructor' || key === 'prototype'));
+/**
+ * Own properties only, so a path can never walk into a value shared through a
+ * prototype (e.g. `Object.prototype.toString`) and mutate it.
+ */
+const getOwn = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key) ? obj[key] : undefined;
 /**
  * Minimal implementation of lodash's _.set
  * https://lodash.com/docs/4.17.15#set
  *
- * See ./set.test.ts for usage examples
+ * Mutates `obj` in place, creating missing objects/arrays along the path:
+ *
+ *   const obj = { a: { b: 1 } };
+ *   set(obj, 'a.c', 2);      // obj is { a: { b: 1, c: 2 } }
+ *   set(obj, 'list.0', 'x'); // obj.list is ['x']
+ *
+ * See ./set.test.ts for more usage examples
  */
 export const set = (obj, _path, value) => {
     if (Object(obj) !== obj) {
         return obj;
     }
-    const path = Array.isArray(_path) ? _path : _path.toString().match(/[^.[\]]+/g);
-    path.slice(0, -1).reduce((a, c, i) => Object(a[c]) === a[c] ? a[c] : a[c] = Math.abs(Number(path[i + 1])) >> 0 === +path[i + 1] ? [] : {}, obj)[path[path.length - 1]] = value;
+    const path = Array.isArray(_path) ? _path : parsePath(_path);
+    if (!path || hasUnsafeSegment(path)) {
+        return obj;
+    }
+    path.slice(0, -1).reduce((a, c, i) => {
+        const next = getOwn(a, c);
+        return Object(next) === next ? next : a[c] = isArrayIndex(path[i + 1]) ? [] : {};
+    }, obj)[path[path.length - 1]] = value;
+    return obj;
+};
+/**
+ * Like `set`, but every object or array along `path` that is not in `copied`
+ * is shallow-copied before being written to, so objects shared with the
+ * original are never mutated. `obj` itself must already be a copy.
+ *
+ *   const block = { options: { text: 'a' }, style: { color: 'red' } };
+ *   const copy = { ...block };
+ *   setCopyOnWrite(copy, 'options.text', 'b', new WeakSet());
+ *   // copy.options is a new object: { text: 'b' }
+ *   // block.options.text is still 'a'
+ *   // copy.style === block.style (untouched branches stay shared)
+ */
+export const setCopyOnWrite = (obj, _path, value, copied) => {
+    if (Object(obj) !== obj) {
+        return obj;
+    }
+    const path = parsePath(_path);
+    if (!path || hasUnsafeSegment(path)) {
+        return obj;
+    }
+    copied.add(obj);
+    let current = obj;
+    for (let i = 0; i < path.length - 1; i++) {
+        const key = path[i];
+        let next = getOwn(current, key);
+        if (Object(next) !== next) {
+            next = isArrayIndex(path[i + 1]) ? [] : {};
+            copied.add(next);
+            current[key] = next;
+        }
+        else if (typeof next === 'object' && !copied.has(next)) {
+            next = Array.isArray(next) ? next.slice() : {
+                ...next
+            };
+            copied.add(next);
+            current[key] = next;
+        }
+        current = next;
+    }
+    current[path[path.length - 1]] = value;
+    return obj;
+};
+/**
+ * Deletes the property at `path`, the inverse of `set` for an array path.
+ * Mutates `obj` in place and does nothing when a parent is missing:
+ *
+ *   const obj = { a: { b: 1, c: 2 } };
+ *   unset(obj, ['a', 'b']); // obj is { a: { c: 2 } }
+ *   unset(obj, ['x', 'y']); // no-op
+ */
+export const unset = (obj, path) => {
+    if (Object(obj) !== obj || !path.length || hasUnsafeSegment(path)) {
+        return obj;
+    }
+    const parent = path.slice(0, -1).reduce((a, c) => Object(a) === a ? getOwn(a, c) : undefined, obj);
+    if (Object(parent) === parent) {
+        delete parent[path[path.length - 1]];
+    }
     return obj;
 };

package/lib/edge/helpers/bounded-cache.d.ts

@@ -0,0 +1,4 @@
+export declare const createBoundedCache: <V>(max: number) => {
+    get: (key: string) => V | undefined;
+    set: (key: string, value: V) => void;
+};

package/lib/edge/helpers/bounded-cache.js

@@ -0,0 +1,12 @@
+export const createBoundedCache = (max) => {
+    const map = new Map();
+    return {
+        get: (key) => map.get(key),
+        set: (key, value) => {
+            if (!map.has(key) && map.size >= max) {
+                map.delete(map.keys().next().value);
+            }
+            map.set(key, value);
+        }
+    };
+};

package/lib/edge/helpers/copy-plain-data.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Deep-copies plain objects and arrays (anything else is kept by reference), so
+ * that state writes made while rendering never reach the content object, which
+ * apps often cache and share between requests.
+ */
+export declare const copyPlainData: <T>(value: T, seen?: WeakMap<object, any>) => T;

package/lib/edge/helpers/copy-plain-data.js

@@ -0,0 +1,40 @@
+/**
+ * Deep-copies plain objects and arrays (anything else is kept by reference), so
+ * that state writes made while rendering never reach the content object, which
+ * apps often cache and share between requests.
+ */
+export const copyPlainData = (value, seen = new WeakMap()) => {
+    if (value === null || typeof value !== 'object')
+        return value;
+    if (seen.has(value))
+        return seen.get(value);
+    if (Array.isArray(value)) {
+        const copy = [];
+        seen.set(value, copy);
+        for (let i = 0; i < value.length; i++) {
+            copy[i] = copyPlainData(value[i], seen);
+        }
+        return copy;
+    }
+    const proto = Object.getPrototypeOf(value);
+    if (proto !== Object.prototype && proto !== null)
+        return value;
+    const copy = {};
+    seen.set(value, copy);
+    for (const key of Object.keys(value)) {
+        const copied = copyPlainData(value[key], seen);
+        if (key === '__proto__') {
+            // Assigning would call the prototype setter; JSON can carry `__proto__` as an own key.
+            Object.defineProperty(copy, key, {
+                value: copied,
+                enumerable: true,
+                writable: true,
+                configurable: true
+            });
+        }
+        else {
+            copy[key] = copied;
+        }
+    }
+    return copy;
+};

package/lib/node/components/block/block.helpers.d.ts

@@ -22,9 +22,7 @@ export declare const provideLinkComponent: (block: RegisteredComponent | null |
     builderLinkComponent?: undefined;
 };
 export declare const provideRegisteredComponents: (block: RegisteredComponent | null | undefined, registeredComponents: RegisteredComponents, model: string) => {
-    builderComponents: {
-        [k: string]: RegisteredComponent;
-    };
+    builderComponents: RegisteredComponents;
 } | {
     builderComponents?: undefined;
 };

package/lib/node/components/block/block.helpers.js

@@ -1,6 +1,7 @@
 import { evaluate } from '../../functions/evaluate/index';
 import { extractTextStyles } from '../../functions/extract-text-styles';
 import { getStyle } from '../../functions/get-style';
+import { isEditingOrPreviewing } from '../../functions/is-editing-or-previewing';
 const checkIsComponentRestricted = (component, model) => {
     if (!component)
         return true;
@@ -25,12 +26,27 @@ export const getComponent = ({ block, registeredComponents, model }) => {
         return ref;
     }
 };
+// Reused per block so repeated items keep a stable block identity across renders.
+const BLOCKS_WITHOUT_REPEAT = new WeakMap();
+const getBlockWithoutRepeat = (block) => {
+    if (isEditingOrPreviewing()) {
+        const { repeat: _repeat, ...rest } = block;
+        return rest;
+    }
+    let blockWithoutRepeat = BLOCKS_WITHOUT_REPEAT.get(block);
+    if (!blockWithoutRepeat) {
+        const { repeat: _repeat, ...rest } = block;
+        blockWithoutRepeat = rest;
+        BLOCKS_WITHOUT_REPEAT.set(block, blockWithoutRepeat);
+    }
+    return blockWithoutRepeat;
+};
 export const getRepeatItemData = ({ block, context }) => {
     /**
      * we don't use `state.processedBlock` here because the processing done within its logic includes evaluating the block's bindings,
      * which will not work if there is a repeat.
      */
-    const { repeat, ...blockWithoutRepeat } = block;
+    const { repeat } = block;
     if (!repeat?.collection) {
         return undefined;
     }
@@ -46,6 +62,7 @@ export const getRepeatItemData = ({ block, context }) => {
     }
     const collectionName = repeat.collection.split('.').pop();
     const itemNameToUse = repeat.itemName || (collectionName ? collectionName + 'Item' : 'item');
+    const blockWithoutRepeat = getBlockWithoutRepeat(block);
     const repeatArray = itemsArray.map((item, index) => ({
         context: {
             ...context,
@@ -78,11 +95,21 @@ export const provideLinkComponent = (block, linkComponent) => {
         };
     return {};
 };
+const FILTERED_REGISTERED_COMPONENTS = new WeakMap();
 export const provideRegisteredComponents = (block, registeredComponents, model) => {
     if (block?.shouldReceiveBuilderProps?.builderComponents) {
-        const filteredRegisteredComponents = Object.fromEntries(Object.entries(registeredComponents).filter(([_, component]) => {
-            return !checkIsComponentRestricted(component, model);
-        }));
+        let byModel = FILTERED_REGISTERED_COMPONENTS.get(registeredComponents);
+        if (!byModel) {
+            byModel = new Map();
+            FILTERED_REGISTERED_COMPONENTS.set(registeredComponents, byModel);
+        }
+        let filteredRegisteredComponents = byModel.get(model);
+        if (!filteredRegisteredComponents) {
+            filteredRegisteredComponents = Object.fromEntries(Object.entries(registeredComponents).filter(([_, component]) => {
+                return !checkIsComponentRestricted(component, model);
+            }));
+            byModel.set(model, filteredRegisteredComponents);
+        }
         return {
             builderComponents: filteredRegisteredComponents
         };

package/lib/node/components/block/block.svelte

@@ -73,7 +73,15 @@ $: childrenWithoutParentComponent = () => {
         : [];
 };
 $: componentRefProps = () => {
-    return {
+    const deps = [
+        processedBlock(),
+        $context,
+        $context.rootState,
+        $context.localState,
+        registeredComponents,
+        linkComponent,
+    ];
+    const componentRefProps = {
         blockChildren: processedBlock().children ?? [],
         componentRef: blockComponent?.()?.component,
         componentOptions: {
@@ -90,11 +98,16 @@ $: componentRefProps = () => {
         includeBlockProps: blockComponent?.()?.noWrap === true,
         isInteractive: !(blockComponent?.()?.isRSC && TARGET === "rsc"),
     };
+    return componentRefProps;
 };
 let _processedBlock = {
     value: null,
     update: false,
 };
+let _componentRefProps = {
+    value: null,
+    deps: [],
+};
 onMount(() => {
     const blockId = processedBlock().id;
     const animations = processedBlock().animations;

package/lib/node/components/content/components/styles.helpers.d.ts

@@ -13,5 +13,5 @@ export declare const getCss: ({ cssCode, contentId }: {
     cssCode?: string | undefined;
     contentId?: string | undefined;
 }) => string;
-export declare const getDefaultStyles: (isNested: boolean | undefined) => "" | "\n.builder-button {\n  all: unset;\n}\n\n.builder-text > p:first-of-type, .builder-text > .builder-paragraph:first-of-type {\n  margin: 0;\n}\n.builder-text > p, .builder-text > .builder-paragraph {\n  color: inherit;\n  line-height: inherit;\n  letter-spacing: inherit;\n  font-weight: inherit;\n  font-size: inherit;\n  text-align: inherit;\n  font-family: inherit;\n}\n";
+export declare const getDefaultStyles: (isNested: boolean | undefined) => "" | "\n:where(.builder-button) {\n  all: unset;\n}\n\n.builder-text > p:first-of-type, .builder-text > .builder-paragraph:first-of-type {\n  margin: 0;\n}\n.builder-text > p, .builder-text > .builder-paragraph {\n  color: inherit;\n  line-height: inherit;\n  letter-spacing: inherit;\n  font-weight: inherit;\n  font-size: inherit;\n  text-align: inherit;\n  font-family: inherit;\n}\n";
 export declare const getWrapperClassName: (variationId?: string) => string;

package/lib/node/components/content/components/styles.helpers.js

@@ -57,7 +57,7 @@ export const getCss = ({ cssCode, contentId }) => {
     return cssCode?.replace(/&/g, `div[builder-content-id="${contentId}"]`) || '';
 };
 const DEFAULT_STYLES = `
-.builder-button {
+:where(.builder-button) {
   all: unset;
 }
 

package/lib/node/components/content/content.helpers.d.ts

@@ -1,6 +1,10 @@
+import type { RegisteredComponent, RegisteredComponents } from '../../context/types';
 import type { BuilderContent } from '../../types/builder-content';
-import type { Nullable } from '../../types/typescript';
+import type { ComponentInfo } from '../../types/components';
+import type { Dictionary, Nullable } from '../../types/typescript';
 import type { ContentProps } from './content.types';
+export declare const getRegisteredComponents: (registrations: RegisteredComponent[], wrapComponent: (component: any) => any) => RegisteredComponents;
+export declare const getComponentInfos: (registrations: RegisteredComponent[]) => Dictionary<ComponentInfo>;
 export declare const getRootStateInitialValue: ({ content, data, locale }: Pick<ContentProps, 'content' | 'data' | 'locale'>) => {
     locale?: string | undefined;
 };