@builder.io/sdk-svelte 0.0.2 → 0.0.4

package/package/functions/extract-text-styles.js

@@ -0,0 +1,34 @@
+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'));
+};
+/**
+ * Extract styles that apply to text from a style object.
+ */
+export const extractTextStyles = (styles) => {
+    const textStyles = {};
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Object.entries(styles).forEach(([key, value]) => {
+        if (isTextStyle(key)) {
+            textStyles[key] = value;
+        }
+    });
+    return textStyles;
+};

package/package/functions/fast-clone.d.ts

@@ -0,0 +1,4 @@
+/**
+ * We need to serialize values to a string in case there are Proxy values, as is the case with SolidJS etc.
+ */
+export declare const fastClone: <T extends object>(obj: T) => T;

package/package/functions/fast-clone.js

@@ -0,0 +1,4 @@
+/**
+ * We need to serialize values to a string in case there are Proxy values, as is the case with SolidJS etc.
+ */
+export const fastClone = (obj) => JSON.parse(JSON.stringify(obj));

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

@@ -0,0 +1,5 @@
+import type { BuilderContextInterface } from '../context/types.js';
+import type { BuilderBlock } from '../types/builder-block.js';
+export declare function crateEventHandler(value: string, options: {
+    block: BuilderBlock;
+} & Pick<BuilderContextInterface, 'state' | 'context'>): (event: Event) => any;

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

@@ -0,0 +1,9 @@
+import { evaluate } from './evaluate.js';
+export function crateEventHandler(value, options) {
+    return (event) => evaluate({
+        code: value,
+        context: options.context,
+        state: options.state,
+        event,
+    });
+}

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

@@ -1,5 +1,5 @@
 import type { BuilderContextInterface } from '../context/types.js';
-import { BuilderBlock } from '../types/builder-block.js';
+import type { BuilderBlock } from '../types/builder-block.js';
 declare type Actions = {
     [index: string]: (event: Event) => any;
 };

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

@@ -1,6 +1,5 @@
-import '../types/builder-block.js';
-import { evaluate } from './evaluate.js';
 import { getEventHandlerName } from './event-handler-name.js';
+import { crateEventHandler } from './get-block-actions-handler.js';
 export function getBlockActions(options) {
     const obj = {};
     const optionActions = options.block.actions ?? {};
@@ -10,12 +9,7 @@ export function getBlockActions(options) {
             continue;
         }
         const value = optionActions[key];
-        obj[getEventHandlerName(key)] = (event) => evaluate({
-            code: value,
-            context: options.context,
-            state: options.state,
-            event,
-        });
+        obj[getEventHandlerName(key)] = crateEventHandler(value, options);
     }
     return obj;
 }

package/package/functions/get-block-component-options.d.ts

@@ -1,2 +1,2 @@
-import { BuilderBlock } from '../types/builder-block.js';
+import type { BuilderBlock } from '../types/builder-block.js';
 export declare function getBlockComponentOptions(block: BuilderBlock): any;

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

@@ -1,4 +1,3 @@
-import '../types/builder-block.js';
 export function getBlockComponentOptions(block) {
     return {
         ...block.component?.options,

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

@@ -1,4 +1,4 @@
-import { BuilderBlock } from '../types/builder-block.js';
+import type { BuilderBlock } from '../types/builder-block.js';
 export declare function getBlockProperties(block: BuilderBlock): {
     'builder-id': string | undefined;
     class: string;

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

@@ -1,4 +1,3 @@
-import '../types/builder-block.js';
 export function getBlockProperties(block) {
     return {
         ...block.properties,

package/package/functions/get-block-tag.d.ts

@@ -1,3 +1,3 @@
-import { BuilderBlock } from '../types/builder-block.js';
+import type { BuilderBlock } from '../types/builder-block.js';
 export declare type TagName = string;
 export declare function getBlockTag(block: BuilderBlock): TagName;

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

@@ -1,4 +1,3 @@
-import '../types/builder-block.js';
 export function getBlockTag(block) {
     return block.tagName || 'div';
 }

package/package/functions/get-builder-search-params/index.d.ts

@@ -1,6 +1,6 @@
 declare type QueryObject = Record<string, string>;
 export declare const convertSearchParamsToQueryObject: (searchParams: URLSearchParams) => QueryObject;
-export declare const getBuilderSearchParams: (options: QueryObject) => QueryObject;
+export declare const getBuilderSearchParams: (_options: QueryObject | URLSearchParams | undefined) => QueryObject;
 export declare const getBuilderSearchParamsFromWindow: () => QueryObject;
 export declare const normalizeSearchParams: (searchParams: QueryObject | URLSearchParams) => QueryObject;
 export {};

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

@@ -7,7 +7,11 @@ export const convertSearchParamsToQueryObject = (searchParams) => {
     });
     return options;
 };
-export const getBuilderSearchParams = (options) => {
+export const getBuilderSearchParams = (_options) => {
+    if (!_options) {
+        return {};
+    }
+    const options = normalizeSearchParams(_options);
     const newOptions = {};
     Object.keys(options).forEach((key) => {
         if (key.startsWith(BUILDER_SEARCHPARAMS_PREFIX)) {
@@ -22,7 +26,7 @@ export const getBuilderSearchParamsFromWindow = () => {
         return {};
     }
     const searchParams = new URLSearchParams(window.location.search);
-    return getBuilderSearchParams(convertSearchParamsToQueryObject(searchParams));
+    return getBuilderSearchParams(searchParams);
 };
 export const normalizeSearchParams = (searchParams) => searchParams instanceof URLSearchParams
     ? convertSearchParamsToQueryObject(searchParams)

package/package/functions/get-content/ab-testing.d.ts

@@ -1,3 +1,5 @@
-import { GetContentOptions } from './types.js';
-import { BuilderContent } from '../../types/builder-content.js';
-export declare const handleABTesting: (item: BuilderContent, testGroups: NonNullable<GetContentOptions['testGroups']>) => void;
+import type { BuilderContent } from '../../types/builder-content.js';
+import type { CanTrack } from '../../types/can-track.js';
+export declare const handleABTesting: ({ item, canTrack, }: {
+    item: BuilderContent;
+} & CanTrack) => Promise<void>;

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

@@ -1,40 +1,78 @@
-import './types.js';
-import '../../types/builder-content.js';
-export const handleABTesting = (item, testGroups) => {
-    if (item.variations && Object.keys(item.variations).length) {
-        const testGroup = item.id ? testGroups[item.id] : undefined;
-        const variationValue = testGroup ? item.variations[testGroup] : undefined;
-        if (testGroup && variationValue) {
-            item.data = variationValue.data;
-            item.testVariationId = variationValue.id;
-            item.testVariationName = variationValue.name;
-        }
-        else {
-            // TODO: a/b test iteration logic
-            let n = 0;
-            const random = Math.random();
-            let set = false;
-            for (const id in item.variations) {
-                const variation = item.variations[id];
-                const testRatio = variation.testRatio;
-                n += testRatio;
-                if (random < n) {
-                    const variationName = variation.name ||
-                        (variation.id === item.id ? 'Default variation' : '');
-                    set = true;
-                    Object.assign(item, {
-                        data: variation.data,
-                        testVariationId: variation.id,
-                        testVariationName: variationName,
-                    });
-                }
-            }
-            if (!set) {
-                Object.assign(item, {
-                    testVariationId: item.id,
-                    testVariationName: 'Default',
-                });
-            }
+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;
+/**
+ * Randomly assign a variation to this user and store it in cookies/storage
+ */
+const getRandomVariationId = ({ id, variations, }) => {
+    let n = 0;
+    const random = Math.random();
+    // loop over variations test ratios, incrementing a counter,
+    // until we find the variation that this user should be assigned to
+    for (const id in variations) {
+        const testRatio = variations[id]?.testRatio;
+        n += testRatio;
+        if (random < n) {
+            return id;
         }
     }
+    // `item.variations` does not include the default variation
+    // if we arrive here, then it means that the random number fits in the default variation bucket
+    return id;
+};
+const getTestFields = ({ item, testGroupId, }) => {
+    const variationValue = item.variations[testGroupId];
+    if (testGroupId === item.id ||
+        // handle edge-case where `testGroupId` points to non-existing variation
+        !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 = async ({ item, canTrack, }) => {
+    // try to find test variation in cookies/storage
+    const testGroupId = await getContentVariationCookie({
+        canTrack,
+        contentId: item.id,
+    });
+    const testFields = testGroupId
+        ? getTestFields({ item, testGroupId })
+        : undefined;
+    if (testFields) {
+        return testFields;
+    }
+    else {
+        // if variation not found in storage, assign a random variation to this user
+        const randomVariationId = getRandomVariationId({
+            variations: item.variations,
+            id: item.id,
+        });
+        // store variation in cookies/storage
+        setContentVariationCookie({
+            contentId: item.id,
+            value: randomVariationId,
+            canTrack,
+        }).catch((err) => {
+            console.error('could not store A/B test variation: ', err);
+        });
+        return getTestFields({ item, testGroupId: randomVariationId });
+    }
+};
+export const handleABTesting = async ({ item, canTrack, }) => {
+    if (!checkIsBuilderContentWithVariations(item)) {
+        return;
+    }
+    const variationValue = await getContentVariation({ item, canTrack });
+    Object.assign(item, variationValue);
 };

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

@@ -1,4 +1,4 @@
-import { BuilderContent } from '../../types/builder-content.js';
+import type { BuilderContent } from '../../types/builder-content.js';
 export declare type GetContentOptions = import('./types.js').GetContentOptions;
 export declare function getContent(options: GetContentOptions): Promise<BuilderContent | null>;
 export declare const generateContentUrl: (options: GetContentOptions) => URL;

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

@@ -1,9 +1,7 @@
 import { flatten } from '../../helpers/flatten.js';
-import '../../types/builder-content.js';
 import { getBuilderSearchParamsFromWindow, normalizeSearchParams, } from '../get-builder-search-params/index.js';
 import { getFetch } from '../get-fetch.js';
 import { handleABTesting } from './ab-testing.js';
-const fetch$ = getFetch();
 export async function getContent(options) {
     return (await getAllContent({ ...options, limit: 1 })).results[0] || null;
 }
@@ -31,11 +29,12 @@ export const generateContentUrl = (options) => {
 };
 export async function getAllContent(options) {
     const url = generateContentUrl(options);
-    const fetch = await fetch$;
+    const fetch = await getFetch();
     const content = await fetch(url.href).then((res) => res.json());
-    if (options.testGroups) {
+    const canTrack = options.canTrack !== false;
+    if (canTrack) {
         for (const item of content.results) {
-            handleABTesting(item, options.testGroups);
+            await handleABTesting({ item, canTrack });
         }
     }
     return content;

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

@@ -3,8 +3,6 @@ export interface GetContentOptions {
     model: string;
     /** Your public API key */
     apiKey: string;
-    /** A/B test groups the current visitor is in. Key is the content ID, value is the variation ID */
-    testGroups?: Record<string, string> | null;
     /** Number of items to fetch. Default is 1 */
     limit?: number;
     /** User attributes to target on, such as { urlPath: '/foo', device: 'mobile', ...etc } */
@@ -23,4 +21,11 @@ export interface GetContentOptions {
      * If set to `false`, it will render the entire content tree eagerly.
      */
     noTraverse?: boolean;
+    /**
+     * If set to `false`, it will not use cookies to target content. Therefore, A/B Testing will be disabled and
+     * only the default variation will be returned to every user.
+     *
+     * Defaults to `true`.
+     */
+    canTrack?: boolean;
 }

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

@@ -1,5 +1,5 @@
 import type { BuilderContextInterface } from '../context/types.js';
-import { BuilderBlock } from '../types/builder-block.js';
+import type { BuilderBlock } from '../types/builder-block.js';
 export declare function getProcessedBlock({ block, context, shouldEvaluateBindings, state, }: {
     block: BuilderBlock;
     /**

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

@@ -1,15 +1,16 @@
-import '../types/builder-block.js';
 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 = {
-        ...block,
-        properties: { ...block.properties },
-        actions: { ...block.actions },
+        ...copy,
+        properties: { ...copy.properties },
+        actions: { ...copy.actions },
     };
     for (const binding in block.bindings) {
         const expression = block.bindings[binding];

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

@@ -1,4 +1,3 @@
-import '../types/builder-block.js';
 import { getProcessedBlock } from './get-processed-block.js';
 test('Can process bindings', () => {
     const block = {

package/package/functions/get-react-native-block-styles.d.ts

@@ -0,0 +1,6 @@
+import type { BuilderContextInterface } from '../context/types.js';
+import type { BuilderBlock } from '../types/builder-block.js';
+export declare function getReactNativeBlockStyles({ block, context, }: {
+    block: BuilderBlock;
+    context: BuilderContextInterface;
+}): CSSStyleDeclaration | Record<string, string | undefined>;

package/package/functions/get-react-native-block-styles.js

@@ -0,0 +1,16 @@
+import { sanitizeReactNativeBlockStyles } from './sanitize-react-native-block-styles.js';
+export function getReactNativeBlockStyles({ block, context, }) {
+    const responsiveStyles = block.responsiveStyles;
+    if (!responsiveStyles) {
+        return {};
+    }
+    const styles = {
+        // recursively apply inherited styles so that they can be passed down to children `Text` blocks
+        ...context.inheritedStyles,
+        ...(responsiveStyles.large || {}),
+        ...(responsiveStyles.medium || {}),
+        ...(responsiveStyles.small || {}),
+    };
+    const newStyles = sanitizeReactNativeBlockStyles(styles);
+    return newStyles;
+}

package/package/functions/register-component.d.ts

@@ -1,4 +1,4 @@
-import { RegisteredComponent } from '../context/types.js';
+import type { RegisteredComponent } from '../context/types.js';
 import type { ComponentInfo } from '../types/components.js';
 /**
  * @deprecated.  Use the `customComponents` prop in RenderContent instead to provide your custom components to the builder SDK.
@@ -8,7 +8,7 @@ export declare const components: RegisteredComponent[];
  * @deprecated.  Use the `customComponents` prop in RenderContent instead to provide your custom components to the builder SDK.
  */
 export declare function registerComponent(component: any, info: ComponentInfo): void;
-export declare const createRegisterComponentMessage: ({ component, ...info }: RegisteredComponent) => {
+export declare const createRegisterComponentMessage: ({ component: _, ...info }: RegisteredComponent) => {
     type: string;
     data: ComponentInfo;
 };

package/package/functions/register-component.js

@@ -1,4 +1,4 @@
-import '../context/types.js';
+import { fastClone } from './fast-clone.js';
 /**
  * @deprecated.  Use the `customComponents` prop in RenderContent instead to provide your custom components to the builder SDK.
  */
@@ -15,10 +15,6 @@ export const createRegisterComponentMessage = ({ component: _, ...info }) => ({
     type: 'builder.registerComponent',
     data: prepareComponentInfoToSend(info),
 });
-/**
- * We need to serialize values to a string in case there are Proxy values, as is the case with SolidJS etc.
- */
-const fastClone = (obj) => JSON.parse(JSON.stringify(obj));
 const serializeValue = (value) => typeof value === 'function' ? serializeFn(value) : fastClone(value);
 /**
  * Input attributes that are functions must be converted to strings before being serialized to JSON.

package/package/functions/register.d.ts

@@ -1,5 +1,5 @@
-import { BuilderBlock } from '../types/builder-block.js';
-import { DeepPartial } from '../types/deep-partial.js';
+import type { BuilderBlock } from '../types/builder-block.js';
+import type { DeepPartial } from '../types/deep-partial.js';
 export interface InsertMenuItem {
     name: string;
     icon?: string;

package/package/functions/register.js

@@ -1,5 +1,3 @@
-import '../types/builder-block.js';
-import '../types/deep-partial.js';
 import { isBrowser } from './is-browser.js';
 const registry = {};
 export function register(type, info) {

package/package/functions/sanitize-react-native-block-styles.d.ts

@@ -0,0 +1,3 @@
+declare type Styles = Record<string, string | number>;
+export declare const sanitizeReactNativeBlockStyles: (styles: Styles) => Styles;
+export {};

package/package/functions/sanitize-react-native-block-styles.js

@@ -0,0 +1,53 @@
+const propertiesThatMustBeNumber = new Set(['lineHeight']);
+const displayValues = new Set(['flex', 'none']);
+const SHOW_WARNINGS = false;
+const normalizeNumber = (value) => {
+    if (Number.isNaN(value)) {
+        return undefined;
+    }
+    else if (value < 0) {
+        // TODO: why are negative values not allowed?
+        return 0;
+    }
+    else {
+        return value;
+    }
+};
+export 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') {
+            // `px` units need to be stripped and replaced with numbers
+            // https://regexr.com/6ualn
+            const isPixelUnit = propertyValue.match(/^-?(\d*)(\.?)(\d*)*px$/);
+            if (isPixelUnit) {
+                const newValue = parseFloat(propertyValue);
+                const normalizedValue = normalizeNumber(newValue);
+                if (normalizedValue) {
+                    return { ...acc, [key]: normalizedValue };
+                }
+                else {
+                    return acc;
+                }
+            }
+            else if (propertyValue === '0') {
+                // 0 edge case needs to be handled
+                return { ...acc, [key]: 0 };
+            }
+        }
+        return { ...acc, [key]: propertyValue };
+    }, {});
+};

package/package/functions/track.d.ts

@@ -1,4 +1,4 @@
-import { CanTrack } from '../types/can-track.js';
+import type { CanTrack } from '../types/can-track.js';
 interface Event {
     type: 'click' | 'impression';
     data: {

package/package/functions/track.js

@@ -1,25 +1,24 @@
 import { TARGET } from '../constants/target.js';
 import { getSessionId } from '../helpers/sessionId.js';
 import { getVisitorId } from '../helpers/visitorId.js';
-import '../types/can-track.js';
 import { isBrowser } from './is-browser.js';
 import { isEditing } from './is-editing.js';
-const getTrackingEventData = ({ canTrack }) => {
+const getTrackingEventData = async ({ canTrack, }) => {
     if (!canTrack) {
         return { visitorId: undefined, sessionId: undefined };
     }
-    const sessionId = getSessionId({ canTrack });
+    const sessionId = await getSessionId({ canTrack });
     const visitorId = getVisitorId({ canTrack });
     return {
         sessionId,
         visitorId,
     };
 };
-const createEvent = ({ type: eventType, canTrack, orgId, contentId, ...properties }) => ({
+const createEvent = async ({ type: eventType, canTrack, orgId, contentId, ...properties }) => ({
     type: eventType,
     data: {
         ...properties,
-        ...getTrackingEventData({ canTrack }),
+        ...(await getTrackingEventData({ canTrack })),
         ownerId: orgId,
         contentId,
     },
@@ -37,7 +36,7 @@ export async function track(eventProps) {
     return fetch(`https://builder.io/api/v1/track`, {
         method: 'POST',
         body: JSON.stringify({
-            events: [createEvent(eventProps)],
+            events: [await createEvent(eventProps)],
         }),
         headers: {
             'content-type': 'application/json',

package/package/functions/transform-block.d.ts

@@ -1,2 +1,2 @@
-import { BuilderBlock } from '../types/builder-block.js';
+import type { BuilderBlock } from '../types/builder-block.js';
 export declare function transformBlock(block: BuilderBlock): BuilderBlock;

package/package/functions/transform-block.js

@@ -1,4 +1,3 @@
-import '../types/builder-block.js';
 // Noope way for targets to make modifications to the block object if/as needed
 export function transformBlock(block) {
     return block;

package/package/helpers/ab-tests.d.ts

@@ -0,0 +1,8 @@
+import type { CanTrack } from '../types/can-track.js';
+export declare const getContentVariationCookie: ({ contentId, canTrack, }: {
+    contentId: string;
+} & CanTrack) => Promise<string | undefined>;
+export declare const setContentVariationCookie: ({ contentId, canTrack, value, }: {
+    contentId: string;
+    value: string;
+} & CanTrack) => Promise<undefined>;

package/package/helpers/ab-tests.js

@@ -0,0 +1,5 @@
+import { getCookie, setCookie } from './cookie.js';
+const BUILDER_STORE_PREFIX = 'builderio.variations';
+const getContentTestKey = (id) => `${BUILDER_STORE_PREFIX}.${id}`;
+export const getContentVariationCookie = ({ contentId, canTrack, }) => getCookie({ name: getContentTestKey(contentId), canTrack });
+export const setContentVariationCookie = ({ contentId, canTrack, value, }) => setCookie({ name: getContentTestKey(contentId), value, canTrack });

package/package/helpers/cookie.d.ts

@@ -1,9 +1,15 @@
-import { CanTrack } from '../types/can-track.js';
+import type { CanTrack } from '../types/can-track.js';
+/**
+ * NOTE: This function is `async` because its react-native override is async. Do not remove the `async` keyword!
+ */
 export declare const getCookie: ({ name, canTrack, }: {
     name: string;
-} & CanTrack) => string | undefined;
+} & CanTrack) => Promise<string | undefined>;
+/**
+ * NOTE: This function is `async` because its react-native override is async. Do not remove the `async` keyword!
+ */
 export declare const setCookie: ({ name, value, expires, canTrack, }: {
     name: string;
     value: string;
     expires?: Date | undefined;
-} & CanTrack) => undefined;
+} & CanTrack) => Promise<undefined>;

package/package/helpers/cookie.js

@@ -1,7 +1,9 @@
 import { isBrowser } from '../functions/is-browser.js';
-import '../types/can-track.js';
 import { getTopLevelDomain } from './url.js';
-export const getCookie = ({ name, canTrack, }) => {
+/**
+ * NOTE: This function is `async` because its react-native override is async. Do not remove the `async` keyword!
+ */
+export const getCookie = async ({ name, canTrack, }) => {
     try {
         if (!canTrack) {
             return undefined;
@@ -41,7 +43,10 @@ const createCookieString = ({ name, value, expires, }) => {
     const cookie = stringifyCookie(cookieValue);
     return cookie;
 };
-export const setCookie = ({ name, value, expires, canTrack, }) => {
+/**
+ * NOTE: This function is `async` because its react-native override is async. Do not remove the `async` keyword!
+ */
+export const setCookie = async ({ name, value, expires, canTrack, }) => {
     try {
         if (!canTrack) {
             return undefined;