windmill-components 1.60.4 → 1.83.1

package/components/apps/components/helpers/RunnableComponent.svelte

@@ -1,37 +1,47 @@
 <script>import Alert from '../../../common/alert/Alert.svelte';
-import SchemaForm from '../../../SchemaForm.svelte';
+import LightweightSchemaForm from '../../../LightweightSchemaForm.svelte';
+import Popover from '../../../Popover.svelte';
 import TestJobLoader from '../../../TestJobLoader.svelte';
 import { AppService } from '../../../../gen';
-import { defaultIfEmptyString, emptySchema, sendUserToast } from '../../../../utils';
-import { getContext, onMount } from 'svelte';
-import { fieldTypeToTsType, schemaToInputsSpec } from '../../utils';
+import { classNames, defaultIfEmptyString, emptySchema, sendUserToast } from '../../../../utils';
+import { deepEqual } from 'fast-equals';
+import { Bug } from 'lucide-svelte';
+import { createEventDispatcher, getContext } from 'svelte';
+import { computeGlobalContext, eval_like } from './eval';
 import InputValue from './InputValue.svelte';
 import RefreshButton from './RefreshButton.svelte';
 // Component props
 export let id;
 export let fields;
 export let runnable;
+export let transformer;
 export let extraQueryParams = {};
 export let autoRefresh = true;
 export let result = undefined;
 export let forceSchemaDisplay = false;
-export let noMinH = false;
-export let defaultUserInput = false;
-export let flexWrap = false;
 export let wrapperClass = '';
-const { worldStore, runnableComponents, workspace, appPath, isEditor, jobs, noBackend } = getContext('AppEditorContext');
-onMount(() => {
-    if (autoRefresh) {
-        $runnableComponents[id] = async () => {
-            await executeComponent(true);
-        };
-        executeComponent(true);
+export let wrapperStyle = '';
+export let initializing = undefined;
+export let render;
+export let outputs;
+export let extraKey = '';
+export let doNotRecomputeOnInputChanged = false;
+export let loading = false;
+export let recomputableByRefreshButton = true;
+const { worldStore, runnableComponents, workspace, appPath, isEditor, jobs, noBackend, errorByComponent, mode, stateId, state, componentControl } = getContext('AppViewerContext');
+const dispatch = createEventDispatcher();
+$runnableComponents[id] = {
+    autoRefresh: autoRefresh && recomputableByRefreshButton,
+    cb: async (inlineScript) => {
+        await executeComponent(true, inlineScript);
     }
-});
-let args = {};
+};
+$runnableComponents = $runnableComponents;
+let args = undefined;
 let testIsLoading = false;
 let runnableInputValues = {};
 let executeTimeout = undefined;
+$: outputs.loading?.set(loading);
 function setDebouncedExecute() {
     executeTimeout && clearTimeout(executeTimeout);
     executeTimeout = setTimeout(() => {
@@ -48,74 +58,32 @@ function computeStaticValues() {
 let lazyStaticValues = computeStaticValues();
 let currentStaticValues = lazyStaticValues;
 $: fields && (currentStaticValues = computeStaticValues());
-$: if (JSON.stringify(currentStaticValues) != JSON.stringify(lazyStaticValues)) {
+$: if (!deepEqual(currentStaticValues, lazyStaticValues)) {
     lazyStaticValues = currentStaticValues;
-    if (autoRefresh) {
+    refreshIfAutoRefresh('static changed');
+}
+$: (runnableInputValues || extraQueryParams || args) &&
+    testJobLoader &&
+    refreshIfAutoRefresh('arg changed');
+$: refreshOn =
+    runnable && runnable.type === 'runnableByName' ? runnable.inlineScript?.refreshOn ?? [] : [];
+function refreshIfAutoRefresh(_src) {
+    const refreshEnabled = autoRefresh && (!doNotRecomputeOnInputChanged || refreshOn?.length > 0);
+    if (refreshEnabled && $worldStore.initialized) {
         setDebouncedExecute();
     }
 }
-$: fields && (lazyStaticValues = computeStaticValues());
-$: runnableInputValues &&
-    extraQueryParams &&
-    args &&
-    autoRefresh &&
-    testJobLoader &&
-    setDebouncedExecute();
 // Test job internal state
 let testJob = undefined;
 let testJobLoader = undefined;
-$: outputs = $worldStore?.outputsById[id];
-$: if (outputs?.loading != undefined) {
-    outputs.loading.set(false, true);
-}
-$: outputs?.loading?.set(testIsLoading);
-$: runnable?.type === 'runnableByName' && loadSchemaAndInputsByName();
-async function loadSchemaAndInputsByName() {
-    if (runnable?.type === 'runnableByName') {
-        const { inlineScript } = runnable;
-        // Inline scripts directly provide the schema
-        if (inlineScript) {
-            const newSchema = inlineScript.schema;
-            const newFields = reloadInputs(newSchema);
-            if (JSON.stringify(newFields) !== JSON.stringify(fields)) {
-                setTimeout(() => {
-                    fields = newFields;
-                }, 0);
-            }
-        }
-    }
-}
-// When the schema is loaded, we need to update the inputs spec
-// in order to render the inputs the component panel
-function reloadInputs(schema) {
-    let schemaCopy = JSON.parse(JSON.stringify(schema));
-    const result = {};
-    const newInputs = schemaToInputsSpec(schemaCopy, defaultUserInput);
-    if (!fields) {
-        return newInputs;
+let schemaStripped = autoRefresh || forceSchemaDisplay ? emptySchema() : undefined;
+$: (autoRefresh || forceSchemaDisplay) &&
+    Object.keys(fields ?? {}).length > 0 &&
+    (schemaStripped = stripSchema(fields, $stateId));
+function stripSchema(inputs, s) {
+    if (inputs === undefined) {
+        return emptySchema();
     }
-    Object.keys(newInputs).forEach((key) => {
-        const newInput = newInputs[key];
-        const oldInput = fields[key];
-        // If the input is not present in the old inputs, add it
-        if (oldInput === undefined) {
-            result[key] = newInput;
-        }
-        else {
-            if (fieldTypeToTsType(newInput.fieldType) !== fieldTypeToTsType(oldInput.fieldType) ||
-                newInput.format !== oldInput.format ||
-                newInput.subFieldType !== oldInput.subFieldType) {
-                result[key] = newInput;
-            }
-            else {
-                result[key] = oldInput;
-            }
-        }
-    });
-    return result;
-}
-$: schemaStripped = runnable && stripSchema(fields);
-function stripSchema(inputs) {
     let schema = runnable?.type == 'runnableByName' ? runnable.inlineScript?.schema : runnable?.schema;
     try {
         schemaStripped = JSON.parse(JSON.stringify(schema));
@@ -136,13 +104,20 @@ function stripSchema(inputs) {
     });
     return schemaStripped;
 }
-$: disabledArgs = Object.keys(fields ?? {}).reduce((disabledArgsAccumulator, inputName) => {
-    if (fields[inputName].type === 'static') {
-        disabledArgsAccumulator = [...disabledArgsAccumulator, inputName];
+async function executeComponent(noToast = false, inlineScriptOverride) {
+    if (runnable?.type === 'runnableByName' && runnable.inlineScript?.language === 'frontend') {
+        loading = true;
+        try {
+            const r = await eval_like(runnable.inlineScript?.content, computeGlobalContext($worldStore, {}), false, $state, $mode == 'dnd', $componentControl, $worldStore, $runnableComponents);
+            await setResult(r);
+            $state = $state;
+        }
+        catch (e) {
+            sendUserToast('Error running frontend script: ' + e.message, true);
+        }
+        loading = false;
+        return;
     }
-    return disabledArgsAccumulator;
-}, []);
-async function executeComponent(noToast = false) {
     if (noBackend) {
         if (!noToast) {
             sendUserToast('This app is not connected to a windmill backend, it is a static preview');
@@ -152,121 +127,192 @@ async function executeComponent(noToast = false) {
     if (runnable?.type === 'runnableByName' && !runnable.inlineScript) {
         return;
     }
-    outputs?.loading?.set(true);
-    let njob = await testJobLoader?.abstractRun(() => {
-        const nonStaticRunnableInputs = {};
-        const staticRunnableInputs = {};
-        Object.keys(fields ?? {}).forEach((k) => {
-            let field = fields[k];
-            if (field?.type == 'static' && fields[k]) {
-                staticRunnableInputs[k] = field.value;
-            }
-            else if (field?.type == 'user') {
-                nonStaticRunnableInputs[k] = args[k];
+    loading = true;
+    try {
+        let njob = await testJobLoader?.abstractRun(() => {
+            const nonStaticRunnableInputs = {};
+            const staticRunnableInputs = {};
+            Object.keys(fields ?? {}).forEach((k) => {
+                let field = fields[k];
+                if (field?.type == 'static' && fields[k]) {
+                    staticRunnableInputs[k] = field.value;
+                }
+                else if (field?.type == 'user') {
+                    nonStaticRunnableInputs[k] = args?.[k];
+                }
+                else {
+                    nonStaticRunnableInputs[k] = runnableInputValues[k];
+                }
+            });
+            const requestBody = {
+                args: nonStaticRunnableInputs,
+                force_viewer_static_fields: !isEditor ? undefined : staticRunnableInputs
+            };
+            if (runnable?.type === 'runnableByName') {
+                const { inlineScript } = inlineScriptOverride
+                    ? { inlineScript: inlineScriptOverride }
+                    : runnable;
+                if (inlineScript) {
+                    requestBody['raw_code'] = {
+                        content: inlineScript.content,
+                        language: inlineScript.language,
+                        path: inlineScript.path
+                    };
+                }
             }
-            else {
-                nonStaticRunnableInputs[k] = runnableInputValues[k];
+            else if (runnable?.type === 'runnableByPath') {
+                const { path, runType } = runnable;
+                requestBody['path'] = runType !== 'hubscript' ? `${runType}/${path}` : `script/${path}`;
             }
+            return AppService.executeComponent({
+                workspace,
+                path: defaultIfEmptyString(appPath, 'newapp'),
+                requestBody
+            });
         });
-        const requestBody = {
-            args: nonStaticRunnableInputs,
-            force_viewer_static_fields: !isEditor ? undefined : staticRunnableInputs
-        };
-        if (runnable?.type === 'runnableByName') {
-            const { inlineScript } = runnable;
-            if (inlineScript) {
-                requestBody['raw_code'] = {
-                    content: inlineScript.content,
-                    language: inlineScript.language,
-                    path: inlineScript.path
-                };
-            }
-        }
-        else if (runnable?.type === 'runnableByPath') {
-            const { path, runType } = runnable;
-            requestBody['path'] = runType !== 'hubscript' ? `${runType}/${path}` : `script/${path}`;
+        if (njob) {
+            $jobs = [{ job: njob, component: id }, ...$jobs];
         }
-        return AppService.executeComponent({
-            workspace,
-            path: defaultIfEmptyString(appPath, 'newapp'),
-            requestBody
-        });
-    });
-    if (njob) {
-        $jobs = [{ job: njob, component: id }, ...$jobs];
+    }
+    catch (e) {
+        setResult({ error: e.body ?? e.message });
+        loading = false;
     }
 }
 export async function runComponent() {
-    await executeComponent();
+    try {
+        await executeComponent();
+    }
+    catch (e) {
+        setResult({ error: e.body ?? e.message });
+    }
 }
 let lastStartedAt = Date.now();
+function recordError(error) {
+    if (testJob) {
+        $errorByComponent[testJob.id] = {
+            error: error,
+            componentId: id
+        };
+    }
+}
+async function setResult(res) {
+    const hasRes = res !== undefined && res !== null;
+    if (transformer) {
+        $worldStore.newOutput(id, 'raw', res);
+        res = await eval_like(transformer.content, computeGlobalContext($worldStore, { result: res }), false, $state, $mode == 'dnd', $componentControl, $worldStore, $runnableComponents);
+        if (hasRes && res === undefined) {
+            res = {
+                error: {
+                    name: 'TransformerError',
+                    message: 'An error occured in the transformer',
+                    stack: 'Transformer returned undefined'
+                }
+            };
+        }
+    }
+    outputs.result?.set(res);
+    result = res;
+    if (res?.error) {
+        recordError(res.error);
+    }
+    else {
+        dispatch('success');
+    }
+    const previousJobId = Object.keys($errorByComponent).find((key) => $errorByComponent[key].componentId === id);
+    if (previousJobId && !result?.error) {
+        delete $errorByComponent[previousJobId];
+        $errorByComponent = $errorByComponent;
+    }
+}
 </script>
 
-{#each Object.entries(fields ?? {}) as [key, v]}
+{#each Object.entries(fields ?? {}) as [key, v] (key)}
 	{#if v.type != 'static' && v.type != 'user'}
 		<InputValue
+			key={key + extraKey}
 			{id}
 			input={fields[key]}
 			bind:value={runnableInputValues[key]}
-			row={extraQueryParams['row'] ?? {}}
 		/>
 	{/if}
 {/each}
 
+{#if runnable?.type == 'runnableByName' && runnable.inlineScript?.language == 'frontend'}
+	{#each runnable.inlineScript.refreshOn ?? [] as { id: tid, key } (`${tid}-${key}`)}
+		{@const fkey = `${tid}-${key}${extraKey}`}
+		<InputValue
+			{id}
+			key={fkey}
+			input={{ type: 'connected', connection: { componentId: tid, path: key }, fieldType: 'any' }}
+			bind:value={runnableInputValues[fkey]}
+		/>
+	{/each}
+{/if}
+
 <TestJobLoader
 	workspaceOverride={workspace}
 	on:done={(e) => {
-		if (testJob && outputs) {
+		if (testJob) {
 			const startedAt = new Date(testJob.started_at).getTime()
 			if (startedAt > lastStartedAt) {
 				lastStartedAt = startedAt
-				outputs.result?.set(testJob?.result)
-				result = testJob.result
+				setResult(e.detail.result)
 			}
 		}
+		loading = false
 	}}
 	bind:isLoading={testIsLoading}
 	bind:job={testJob}
 	bind:this={testJobLoader}
 />
 
-<div class="h-full flex relative flex-row flex-wrap {wrapperClass}">
-	{#if autoRefresh === true}
-		<div class="flex absolute top-1 right-1">
-			<RefreshButton componentId={id} />
-		</div>
-	{/if}
-	{#if schemaStripped && Object.keys(schemaStripped?.properties ?? {}).length > 0 && (autoRefresh || forceSchemaDisplay)}
-		<div class="px-2 h-fit min-h-0">
-			<SchemaForm
-				{flexWrap}
-				schema={schemaStripped}
-				bind:args
-				{disabledArgs}
-				shouldHideNoInputs
-				noVariablePicker
-			/>
-		</div>
-	{/if}
+{#if render}
+	<div class="h-full flex relative flex-row flex-wrap {wrapperClass}" style={wrapperStyle}>
+		{#if (autoRefresh || forceSchemaDisplay) && schemaStripped && Object.keys(schemaStripped?.properties ?? {}).length > 0}
+			<div class="px-2 h-fit min-h-0">
+				<LightweightSchemaForm schema={schemaStripped} bind:args />
+			</div>
+		{/if}
 
-	{#if !runnable && autoRefresh}
-		<Alert type="warning" size="xs" class="mt-2 px-1" title="Missing runnable">
-			Please select a runnable
-		</Alert>
-	{:else if result?.error}
-		<div class="p-2">
-			<Alert type="error" title="Error during execution">
-				See "Debug Runs" on the top right for more details
-				<pre
-					title={JSON.stringify(result.error, null, 4)}
-					class=" mt-2 text-2xs whitespace-pre-wrap">{JSON.stringify(result.error, null, 4)}</pre
-				>
+		{#if !runnable && autoRefresh}
+			<Alert type="warning" size="xs" class="mt-2 px-1" title="Missing runnable">
+				Please select a runnable
 			</Alert>
-			<slot />
-		</div>
-	{:else}
-		<div class="block w-full h-full">
-			<slot />
-		</div>
-	{/if}
-</div>
+		{:else if result?.error && $mode === 'preview'}
+			<div
+				title="Error"
+				class={classNames(
+					'text-red-500 px-1 text-2xs py-0.5 font-bold w-fit absolute border border-red-500 -bottom-2  shadow left-1/2 transform -translate-x-1/2 z-50 cursor-pointer',
+					'bg-red-100/80'
+				)}
+			>
+				<Popover notClickable placement="bottom" popupClass="!bg-white border w-96">
+					<Bug size={14} />
+					<span slot="text">
+						<div class="bg-white">
+							<Alert type="error" title="Error during execution">
+								<div class="flex flex-col gap-2">
+									An error occured, please contact the app author.
+									<span class="font-semibold">Job id: {testJob?.id}</span>
+								</div>
+							</Alert>
+						</div>
+					</span>
+				</Popover>
+			</div>
+			<div class="block grow w-full max-h-full border border-red-300 bg-red-50 relative">
+				<slot />
+			</div>
+		{:else}
+			<div class="block grow w-full max-h-full">
+				<slot />
+			</div>
+		{/if}
+		{#if !initializing && autoRefresh === true}
+			<div class="flex absolute top-1 right-1 z-50">
+				<RefreshButton {loading} componentId={id} />
+			</div>
+		{/if}
+	</div>
+{/if}

package/components/apps/components/helpers/RunnableComponent.svelte.d.ts

@@ -1,21 +1,36 @@
 import { SvelteComponentTyped } from "svelte";
 import type { AppInputs, Runnable } from '../../inputType';
+import type { Output } from '../../rx';
+import type { InlineScript } from '../../types';
 declare const __propDef: {
     props: {
         id: string;
         fields: AppInputs;
         runnable: Runnable;
+        transformer: (InlineScript & {
+            language: 'frontend';
+        }) | undefined;
         extraQueryParams?: Record<string, any> | undefined;
         autoRefresh?: boolean | undefined;
         result?: any;
         forceSchemaDisplay?: boolean | undefined;
-        noMinH?: boolean | undefined;
-        defaultUserInput?: boolean | undefined;
-        flexWrap?: boolean | undefined;
         wrapperClass?: string | undefined;
+        wrapperStyle?: string | undefined;
+        initializing?: boolean | undefined;
+        render: boolean;
+        outputs: {
+            result: Output<any>;
+            loading: Output<boolean>;
+        };
+        extraKey?: string | undefined;
+        doNotRecomputeOnInputChanged?: boolean | undefined;
+        loading?: boolean | undefined;
+        recomputableByRefreshButton?: boolean | undefined;
         runComponent?: (() => Promise<void>) | undefined;
     };
     events: {
+        success: CustomEvent<any>;
+    } & {
         [evt: string]: CustomEvent<any>;
     };
     slots: {

package/components/apps/components/helpers/RunnableWrapper.svelte

@@ -2,50 +2,100 @@
 import { isScriptByNameDefined, isScriptByPathDefined } from '../../utils';
 import NonRunnableComponent from './NonRunnableComponent.svelte';
 import RunnableComponent from './RunnableComponent.svelte';
+import { goto } from '$app/navigation';
+import { sendUserToast } from '../../../../utils';
 export let componentInput;
 export let id;
 export let result = undefined;
-export let noMinH = false;
+export let initializing = true;
+export let loading = false;
 export let extraQueryParams = {};
 export let autoRefresh = true;
 export let runnableComponent = undefined;
 export let forceSchemaDisplay = false;
-export let defaultUserInput = false;
-export let flexWrap = false;
 export let runnableClass = '';
-const { staticExporter, noBackend } = getContext('AppEditorContext');
+export let runnableStyle = '';
+export let doOnSuccess = undefined;
+export let render;
+export let recomputeIds = [];
+export let outputs;
+export let extraKey = undefined;
+const { staticExporter, noBackend, componentControl, runnableComponents } = getContext('AppViewerContext');
+$: if (initializing && result != undefined) {
+    initializing = false;
+}
 if (noBackend && componentInput?.type == 'runnable') {
     result = componentInput?.['value'];
 }
 onMount(() => {
     $staticExporter[id] = () => result;
 });
-function isRunnableDefined() {
+function isRunnableDefined(componentInput) {
     return isScriptByNameDefined(componentInput) || isScriptByPathDefined(componentInput);
 }
+export function onSuccess() {
+    if (recomputeIds) {
+        recomputeIds.forEach((id) => $runnableComponents?.[id]?.cb());
+    }
+    if (!doOnSuccess)
+        return;
+    if (doOnSuccess.selected == 'none')
+        return;
+    if (doOnSuccess.selected == 'setTab') {
+        if (Array.isArray(doOnSuccess.configuration.setTab.setTab)) {
+            doOnSuccess.configuration.setTab?.setTab?.forEach((tab) => {
+                if (tab) {
+                    const { id, index } = tab;
+                    $componentControl[id].setTab?.(index);
+                }
+            });
+        }
+    }
+    else if (doOnSuccess.selected == 'gotoUrl' &&
+        doOnSuccess.configuration.gotoUrl.url &&
+        doOnSuccess.configuration.gotoUrl.url != '') {
+        if (doOnSuccess.configuration.gotoUrl.newTab) {
+            window.open(doOnSuccess.configuration.gotoUrl.url, '_blank');
+        }
+        else {
+            goto(doOnSuccess.configuration.gotoUrl.url);
+        }
+    }
+    else if (doOnSuccess.selected == 'sendToast' &&
+        doOnSuccess.configuration.sendToast.message &&
+        doOnSuccess.configuration.sendToast.message != '') {
+        sendUserToast(doOnSuccess.configuration.sendToast.message);
+    }
+}
 </script>
 
 {#if componentInput === undefined}
 	<slot />
-{:else if componentInput.type === 'runnable' && isRunnableDefined()}
+{:else if componentInput.type === 'runnable' && isRunnableDefined(componentInput)}
 	<RunnableComponent
-		{flexWrap}
-		{defaultUserInput}
+		{extraKey}
+		bind:loading
 		bind:this={runnableComponent}
-		bind:fields={componentInput.fields}
+		fields={componentInput.fields}
 		bind:result
 		runnable={componentInput.runnable}
+		transformer={componentInput.transformer}
 		{autoRefresh}
+		bind:doNotRecomputeOnInputChanged={componentInput.doNotRecomputeOnInputChanged}
 		{id}
 		{extraQueryParams}
 		{forceSchemaDisplay}
-		{noMinH}
+		{initializing}
 		wrapperClass={runnableClass}
+		wrapperStyle={runnableStyle}
+		{render}
+		on:success={onSuccess}
+		{outputs}
 	>
 		<slot />
 	</RunnableComponent>
 {:else}
-	<NonRunnableComponent bind:result {id} {componentInput}>
+	<NonRunnableComponent {render} bind:result {id} {componentInput}>
 		<slot />
 	</NonRunnableComponent>
 {/if}

package/components/apps/components/helpers/RunnableWrapper.svelte.d.ts

@@ -1,19 +1,46 @@
 import { SvelteComponentTyped } from "svelte";
 import type { AppInput } from '../../inputType';
+import type { Output } from '../../rx';
 import RunnableComponent from './RunnableComponent.svelte';
 declare const __propDef: {
     props: {
         componentInput: AppInput | undefined;
         id: string;
         result?: any;
-        noMinH?: boolean | undefined;
+        initializing?: boolean | undefined;
+        loading?: boolean | undefined;
         extraQueryParams?: Record<string, any> | undefined;
         autoRefresh?: boolean | undefined;
         runnableComponent?: RunnableComponent | undefined;
         forceSchemaDisplay?: boolean | undefined;
-        defaultUserInput?: boolean | undefined;
-        flexWrap?: boolean | undefined;
         runnableClass?: string | undefined;
+        runnableStyle?: string | undefined;
+        doOnSuccess?: {
+            selected: 'gotoUrl' | 'none' | 'setTab' | 'sendToast';
+            configuration: {
+                gotoUrl: {
+                    url: string | undefined;
+                    newTab: boolean | undefined;
+                };
+                setTab: {
+                    setTab: {
+                        id: string;
+                        index: number;
+                    }[] | undefined;
+                };
+                sendToast: {
+                    message: string | undefined;
+                };
+            };
+        } | undefined;
+        render: boolean;
+        recomputeIds?: string[] | undefined;
+        outputs: {
+            result: Output<any>;
+            loading: Output<boolean>;
+        };
+        extraKey?: string | undefined;
+        onSuccess?: (() => void) | undefined;
     };
     events: {
         [evt: string]: CustomEvent<any>;
@@ -26,5 +53,6 @@ export type RunnableWrapperProps = typeof __propDef.props;
 export type RunnableWrapperEvents = typeof __propDef.events;
 export type RunnableWrapperSlots = typeof __propDef.slots;
 export default class RunnableWrapper extends SvelteComponentTyped<RunnableWrapperProps, RunnableWrapperEvents, RunnableWrapperSlots> {
+    get onSuccess(): () => void;
 }
 export {};

package/components/apps/components/helpers/eval.d.ts

@@ -0,0 +1,7 @@
+import type { World } from '../../rx';
+export declare function computeGlobalContext(world: World | undefined, extraContext?: any): any;
+export declare function eval_like(text: string, context: {} | undefined, noReturn: boolean, state: Record<string, any>, editor: boolean, controlComponents: Record<string, {
+    setTab?: (index: number) => void;
+}>, worldStore: World | undefined, runnableComponents: Record<string, {
+    cb?: () => void;
+}>): Promise<any>;