@builder.io/sdk-svelte 1.0.11 → 1.0.12

package/src/constants/sdk-version.ts

@@ -1 +1 @@
-export const SDK_VERSION = "1.0.11"
+export const SDK_VERSION = "1.0.12"

package/src/functions/evaluate/browser-runtime/browser.ts

@@ -37,7 +37,7 @@ export function flattenState({
         return localState[prop];
       }
       const val = target[prop];
-      if (typeof val === 'object') {
+      if (typeof val === 'object' && val !== null) {
         return flattenState({
           rootState: val,
           localState: undefined,

package/src/functions/evaluate/evaluate.ts

@@ -2,6 +2,33 @@ import { logger } from '../../helpers/logger.js';
 import { chooseBrowserOrServerEval } from './choose-eval.js';
 import type { EvaluatorArgs, ExecutorArgs } from './helpers.js';
 import { getBuilderGlobals, parseCode } from './helpers.js';
+type EvalValue = unknown;
+class EvalCache {
+  static cacheLimit = 20;
+  static cache = new Map<string, {
+    value: EvalValue;
+  } | undefined>();
+  static getCacheKey(args: ExecutorArgs) {
+    return JSON.stringify({
+      ...args,
+      // replace the event with a random number to break cache
+      // thats because we can't serialize the event object due to circular refs in DOM node refs.
+      event: args.event ? Math.random() : undefined
+    });
+  }
+  static getCachedValue(key: string) {
+    const cachedVal = EvalCache.cache.get(key);
+    return cachedVal;
+  }
+  static setCachedValue(key: string, value: EvalValue) {
+    if (EvalCache.cache.size > 20) {
+      EvalCache.cache.delete(EvalCache.cache.keys().next().value);
+    }
+    EvalCache.cache.set(key, {
+      value
+    });
+  }
+}
 export function evaluate({
   code,
   context,
@@ -9,11 +36,12 @@ export function evaluate({
   rootState,
   rootSetState,
   event,
-  isExpression = true
-}: EvaluatorArgs): any {
+  isExpression = true,
+  enableCache
+}: EvaluatorArgs): EvalValue {
   if (code === '') {
     logger.warn('Skipping evaluation of empty code block.');
-    return;
+    return undefined;
   }
   const args: ExecutorArgs = {
     code: parseCode(code, {
@@ -26,8 +54,20 @@ export function evaluate({
     rootState,
     localState
   };
+  if (enableCache) {
+    const cacheKey = EvalCache.getCacheKey(args);
+    const cachedValue = EvalCache.getCachedValue(cacheKey);
+    if (cachedValue) {
+      return cachedValue.value;
+    }
+  }
   try {
-    return chooseBrowserOrServerEval(args);
+    const newEval = chooseBrowserOrServerEval(args);
+    if (enableCache) {
+      const cacheKey = EvalCache.getCacheKey(args);
+      EvalCache.setCachedValue(cacheKey, newEval);
+    }
+    return newEval;
   } catch (e: any) {
     logger.error('Failed code evaluation: ' + e.message, {
       code

package/src/functions/evaluate/helpers.ts

@@ -5,6 +5,7 @@ import { getUserAttributes } from '../track/helpers.js';
 export type EvaluatorArgs = Omit<ExecutorArgs, 'builder' | 'event'> & {
   event?: Event;
   isExpression?: boolean;
+  enableCache: boolean;
 };
 export type BuilderGlobals = {
   isEditing: boolean | undefined;

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

@@ -12,5 +12,6 @@ export const createEventHandler = (value: string, options: Options): EventHandle
   rootState: options.rootState,
   rootSetState: options.rootSetState,
   event,
-  isExpression: false
+  isExpression: false,
+  enableCache: true
 })

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

@@ -33,7 +33,8 @@ const evaluateBindings = ({
       localState,
       rootState,
       rootSetState,
-      context
+      context,
+      enableCache: true
     });
     set(copied, binding, value);
   }