@builder.io/sdk-react 0.4.5 → 0.5.0

package/dist/{sdk/functions → functions/evaluate}/evaluate.d.ts

@@ -1,7 +1,10 @@
-import type { BuilderContextInterface, BuilderRenderState } from '../context/types.js';
-export declare function evaluate({ code, context, localState, rootState, rootSetState, event, isExpression, }: {
+import type { BuilderContextInterface, BuilderRenderState } from '../../context/types.js';
+import type { ExecutorArgs } from './types.js';
+export declare function evaluate({ code, context, localState, rootState, rootSetState, event, isExpression }: {
     code: string;
     event?: Event;
     isExpression?: boolean;
 } & Pick<BuilderContextInterface, 'localState' | 'context' | 'rootState' | 'rootSetState'>): any;
+export declare const runInBrowser: ({ useCode, builder, context, event, localState, rootSetState, rootState }: ExecutorArgs) => any;
+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;

package/dist/functions/evaluate/evaluate.js

@@ -0,0 +1,70 @@
+import { logger } from '../../helpers/logger.js';
+import { isBrowser } from '../is-browser.js';
+import { isEditing } from '../is-editing.js';
+import { isNonNodeServer } from '../is-non-node-server.js';
+import { runInNonNode } from './non-node-runtime.js';
+export function evaluate({ code, context, localState, rootState, rootSetState, event, isExpression = true }) {
+    if (code === '') {
+        logger.warn('Skipping evaluation of empty code block.');
+        return;
+    }
+    const builder = {
+        isEditing: isEditing(),
+        isBrowser: 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 '));
+    const useCode = useReturn ? `return (${code});` : code;
+    const args = {
+        useCode,
+        builder,
+        context,
+        event,
+        rootSetState,
+        rootState,
+        localState
+    };
+    if (isBrowser())
+        return runInBrowser(args);
+    if (isNonNodeServer())
+        return runInNonNode(args);
+    return runInNode(args);
+}
+export const runInBrowser = ({ useCode, builder, context, event, localState, rootSetState, rootState }) => {
+    const state = flattenState(rootState, localState, rootSetState);
+    try {
+        return new Function('builder', 'Builder' /* <- legacy */, 'state', 'context', 'event', useCode)(builder, builder, state, context, event);
+    }
+    catch (e) {
+        logger.warn('Builder custom code error: \n While Evaluating: \n ', useCode, '\n', e);
+    }
+};
+export const runInNode = (args) => {
+    // TO-DO: use vm-isolate
+    return runInBrowser(args);
+};
+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/functions/evaluate/evaluate.test.js

@@ -0,0 +1,23 @@
+import { flattenState } from './evaluate.js';
+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/functions/evaluate/index.d.ts

@@ -0,0 +1 @@
+export { evaluate } from './evaluate';

package/dist/functions/evaluate/index.js

@@ -0,0 +1 @@
+export { evaluate } from './evaluate';

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

@@ -0,0 +1,2 @@
+declare const _default: Class;
+export default _default;