@omnia/velcron 8.0.136-dev → 8.0.138-dev

package/actions/Alert.js

@@ -4,9 +4,7 @@ exports.alerter = void 0;
 exports.alerter = {
     name: "@alert",
     action: (action, value) => {
-        //value = VelcronData.dataBind(action, value)
-        //alert(value + nisse ? nisse : 'nullsiu');
         alert(`${value}`);
-        return Promise.resolve(null);
+        action.promise.resolve(null);
     }
 };

package/actions/Array.js

@@ -15,7 +15,7 @@ exports.arrayAppend = {
         else {
             existingArray.push(arrayToAppend);
         }
-        return Promise.resolve(new ActionResults_1.SkipSetValue());
+        action.promise.resolve(new ActionResults_1.SkipSetValue());
     }
 };
 exports.arrayTake = {
@@ -24,6 +24,6 @@ exports.arrayTake = {
         takeTemplate = VelcronData_1.VelcronData.dataBind(action, takeTemplate);
         const take = parseInt(takeTemplate);
         arr = arr.slice(0, take);
-        return Promise.resolve(arr);
+        action.promise.resolve(arr);
     }
 };

package/actions/Clone.js

@@ -5,7 +5,6 @@ const stores_1 = require("../stores");
 exports.objClone = {
     name: "@clone",
     action: (action, objToClone) => {
-        const path = action.path.replace("=", "").trim();
-        return Promise.resolve(stores_1.ReactivitySystem.makeReactive(JSON.parse(JSON.stringify(objToClone))));
+        action.promise.resolve(stores_1.ReactivitySystem.makeReactive(JSON.parse(JSON.stringify(objToClone))));
     }
 };

package/actions/Date.js

@@ -6,7 +6,7 @@ const dayjs_1 = tslib_1.__importDefault(require("dayjs"));
 exports.dateFormat = {
     name: "@date.format",
     action: (action, value) => {
-        return Promise.resolve((0, dayjs_1.default)().format(value));
+        return action.promise.resolve((0, dayjs_1.default)().format(value));
     }
 };
 exports.diff = {
@@ -16,7 +16,7 @@ exports.diff = {
         const futureDateTime = (0, dayjs_1.default)(date);
         const duration = past ? dayjs_1.default.duration(now.diff(futureDateTime)) : dayjs_1.default.duration(futureDateTime.diff(now));
         const expired = past ? false : duration.asMilliseconds() <= 0;
-        return Promise.resolve({
+        action.promise.resolve({
             years: duration.years(),
             months: duration.months(),
             days: duration.days(),

package/actions/Debounce.js

@@ -11,9 +11,9 @@ exports.debounce = {
         value = VelcronData_1.VelcronData.dataBind(action, value);
         const bounceDelayTime = parseInt(value);
         if (!debounces[action.id]) {
-            debounces[action.id] = debounceInternal(() => { Promise.resolve(); }, bounceDelayTime);
+            debounces[action.id] = debounceInternal(() => { action.promise.resolve(null); }, bounceDelayTime);
         }
-        return debounces[action.id]();
+        //return debounces[action.id]();
     }
 };
 function debounceInternal(inner, ms = 0) {

package/actions/Delay.js

@@ -7,8 +7,9 @@ exports.delay = {
     action: (action, value) => {
         value = VelcronData_1.VelcronData.dataBind(action, value);
         const delayTime = parseInt(value);
-        return new Promise(function (resolve) {
-            setTimeout(resolve.bind(null, null), delayTime);
-        });
+        setTimeout(action.promise.resolve.bind(null, null), delayTime);
+        // return new Promise(function (resolve) {
+        //     setTimeout(resolve.bind(null, null), delayTime);
+        // });
     }
 };

package/actions/Emit.js

@@ -20,6 +20,6 @@ exports.emit = {
         else {
             parser_1.VelcronLogger.logActionError("There is no incoming event handlers registered");
         }
-        return Promise.resolve(null);
+        return action.promise.resolve(null);
     }
 };

package/actions/Http.js

@@ -5,28 +5,26 @@ const parser_1 = require("../parser");
 exports.httpGet = {
     name: "@http.get",
     action: (action, incomingUrl) => {
-        return new Promise(function (resolve) {
-            incomingUrl = parser_1.VelcronData.dataBind(action, incomingUrl);
-            let requestInitLocal = { "method": "GET" };
-            const hookResult = parser_1.VelcronActions.tryTriggerBeforeActionHook("http.get", { url: incomingUrl, requestInit: requestInitLocal });
-            incomingUrl = hookResult?.url ?? incomingUrl;
-            requestInitLocal = hookResult?.requestInit ?? requestInitLocal;
-            fetch(incomingUrl, requestInitLocal)
-                .then(async (response) => {
-                const res = parser_1.VelcronActions.tryTriggerAfterActionHook("http.get", {
-                    json: await response.json(),
-                    response: response
-                });
-                return res.json;
-            })
-                .then((json) => {
-                resolve(json);
-            })
-                .catch((error) => {
-                //How do we handle errors?
-                console.error("Velcron @http.get error occurred:", error);
-                throw error;
+        incomingUrl = parser_1.VelcronData.dataBind(action, incomingUrl);
+        let requestInitLocal = { "method": "GET" };
+        const hookResult = parser_1.VelcronActions.tryTriggerBeforeActionHook("http.get", { url: incomingUrl, requestInit: requestInitLocal });
+        incomingUrl = hookResult?.url ?? incomingUrl;
+        requestInitLocal = hookResult?.requestInit ?? requestInitLocal;
+        fetch(incomingUrl, requestInitLocal)
+            .then(async (response) => {
+            const res = parser_1.VelcronActions.tryTriggerAfterActionHook("http.get", {
+                json: await response.json(),
+                response: response
             });
+            return res.json;
+        })
+            .then((json) => {
+            action.promise.resolve(json);
+        })
+            .catch((error) => {
+            //How do we handle errors?
+            console.error("Velcron @http.get error occurred:", error);
+            throw error;
         });
     }
 };

package/actions/IActionHandler.d.ts

@@ -1,6 +1,6 @@
 import { VelcronActionWithAutoAwait } from "../models";
 export interface IActionHandler {
     name: string;
-    action: (action: VelcronActionWithAutoAwait, ...parameters: any) => Promise<unknown>;
+    action: (action: VelcronActionWithAutoAwait, ...parameters: any) => void;
     dispose?: (action: VelcronActionWithAutoAwait) => () => void;
 }

package/actions/Log.js

@@ -5,6 +5,6 @@ exports.logInfo = {
     name: "@log.info",
     action: (action, value) => {
         console.dir(value);
-        return Promise.resolve(null);
+        return action.promise.resolve(null);
     }
 };

package/actions/MsGraph.js

@@ -4,13 +4,11 @@ exports.msGraphGet = void 0;
 const VelcronData_1 = require("../parser/VelcronData");
 exports.msGraphGet = {
     name: "@msgraph.get",
-    action: (action, value) => {
-        return new Promise(async function (resolve) {
-            //TODO Make it typed!
-            const client = await window.omniaScriptApi.m365.graphClient;
-            value = VelcronData_1.VelcronData.dataBind(action, value);
-            const res = await client.get(value);
-            resolve(res.data);
-        });
+    action: async (action, value) => {
+        //TODO Make it typed!
+        const client = await window.omniaScriptApi.m365.graphClient;
+        value = VelcronData_1.VelcronData.dataBind(action, value);
+        const res = await client.get(value);
+        action.promise.resolve(res.data);
     }
 };

package/actions/MsSharePoint.js

@@ -5,13 +5,11 @@ const VelcronData_1 = require("../parser/VelcronData");
 //TODO This should be pluggable from sharepoint package
 exports.msSp = {
     name: "@mssp.get",
-    action: (action, value) => {
-        return new Promise(async function (resolve) {
-            //TODO Make it typed!
-            const client = await window.omniaScriptApi.spfx.sharepointClient;
-            value = VelcronData_1.VelcronData.dataBind(action, value);
-            const res = await client.get(value);
-            resolve(res.data);
-        });
+    action: async (action, value) => {
+        //TODO Make it typed!
+        const client = await window.omniaScriptApi.spfx.sharepointClient;
+        value = VelcronData_1.VelcronData.dataBind(action, value);
+        const res = await client.get(value);
+        action.promise.resolve(res.data);
     }
 };

package/actions/Timer.js

@@ -21,7 +21,7 @@ exports.timerCreate = {
             //TODO: action.rootContext[path] validate it to be Array<string>
             action.rootContext[path] = new TimerInstance(action.rootContext[path], action, interval, autostart, immediate);
         }
-        return Promise.resolve(null);
+        action.promise.resolve(null);
     },
     dispose: (action) => {
         return () => {
@@ -39,7 +39,7 @@ exports.timerStart = {
             parser_1.VelcronLogger.logActionError(`Error in ${timerStartName} the timer does not exists. Did you use ${timerCreateName} to create the timer?`);
         }
         timer.start();
-        return Promise.resolve(null);
+        action.promise.resolve(null);
     }
 };
 const timerStopName = "@timer.stop";
@@ -50,7 +50,7 @@ exports.timerStop = {
             parser_1.VelcronLogger.logActionError(`Error in ${timerStopName} the timer does not exists. Did you use ${timerCreateName} to create the timer?`);
         }
         timer.stop();
-        return Promise.resolve(null);
+        action.promise.resolve(null);
     }
 };
 function getPath(path) {

package/internal-do-not-import-from-here/shared/models/theming/Blueprints.d.ts

@@ -39,6 +39,7 @@ export interface ComponentBlueprints extends Blueprints, BlueprintsReference {
     buttons?: ButtonBlueprints;
     tabs?: TabsBlueprints;
     blocks?: ChromeBlueprints;
+    icons?: IconBlueprints;
 }
 export interface SpacingBlueprint {
     layout: SpacingDefinition;
@@ -55,12 +56,18 @@ export declare enum VelcronBlueprintDefintionTypes {
     button = "button"
 }
 export interface Blueprint {
-    type: VelcronBlueprintDefintionType | WebBlueprintItemDefintionType;
 }
 export interface SearchBoxBlueprint extends Blueprint {
     borderRadius?: BoxDimensions;
     variant?: "outlined" | "solo" | "regular" | "plain" | "underlined";
 }
+export interface IconBlueprints extends Blueprints {
+    xs?: IconBlueprint;
+    s?: IconBlueprint;
+    m?: IconBlueprint;
+    l?: IconBlueprint;
+    xl?: IconBlueprint;
+}
 export interface ButtonBlueprint extends Blueprint {
     padding?: Spacing;
     background?: BackgroundDefinition;

package/internal-do-not-import-from-here/shared/models/theming/ThemeDefinitionV2.d.ts

@@ -1,5 +1,6 @@
-import { Guid } from "../Guid";
+import { GuidValue } from "../Guid";
 import { BoxDimensions, ComponentBlueprints, SpacingBlueprints, TypographyBlueprints } from "./Blueprints";
+export type ThemeContextType = "default" | "admin" | "preview" | "color-context";
 export interface ColorTypeResult<resultType> {
     base: resultType;
     baseTone: resultType;
@@ -42,7 +43,7 @@ export interface ColorSchemas extends ColorSchemasReference {
     notification: ColorSchema;
 }
 export interface BlueprintsReference {
-    id: Guid;
+    id: GuidValue;
 }
 export interface ColorSchemasReference {
     primary: BlueprintsReference;
@@ -58,7 +59,7 @@ export interface ColorSchemasReference {
     notification: BlueprintsReference;
 }
 export interface ThemeDefinitionReference {
-    id: Guid;
+    id: GuidValue;
     name?: string;
     colors: ColorSchemasReference;
     typography: BlueprintsReference;
@@ -72,7 +73,7 @@ export interface ThemeDefinitionV2 extends ThemeDefinitionReference {
     components: ComponentBlueprints;
 }
 export interface ITemplateRegistration<TTemplateType = any> {
-    id: Guid;
+    id: GuidValue;
     template: TTemplateType;
     hidden?: boolean;
     custom?: boolean;

package/internal-do-not-import-from-here/shared/models/theming/Typography.d.ts

@@ -1,8 +1,8 @@
-import { Guid } from "../Guid";
+import { GuidValue } from "../Guid";
 export interface TypographyBlueprint {
     name: string;
     font?: {
-        id: Guid;
+        id: GuidValue;
         family: string;
         cdn?: string;
     };

package/internal-do-not-import-from-here/shared/models/velcron/VelcronDefinition.d.ts

@@ -1,5 +1,5 @@
 import { DynamicState } from "../DynamicState";
-import { VelcronEvent, VelcronOnEditModeEvent, VelcronOnLoadEvent, VelcronOnSavingEvent } from "./VelcronEvents";
+import { VelcronEvent, VelcronOnEditModeEvent, VelcronOnLoadEvent, VelcronOnPersistingStateEvent, VelcronOnSavingEvent } from "./VelcronEvents";
 /**
  * Velcron definition base
  */
@@ -73,7 +73,7 @@ export interface VelcronAppDefinition<TState extends DynamicState = DynamicState
     version?: string;
     name?: string;
     body?: Array<VelcronDefinition>;
-    events?: VelcronOnLoadEvent & VelcronOnEditModeEvent & VelcronOnSavingEvent;
+    events?: VelcronOnLoadEvent & VelcronOnEditModeEvent & VelcronOnSavingEvent & VelcronOnPersistingStateEvent;
     actions?: {
         [name: string]: Array<string>;
     };

package/internal-do-not-import-from-here/shared/models/velcron/VelcronEvents.d.ts

@@ -7,6 +7,10 @@ export type VelcronOnLoadEvent = {
 export type VelcronOnSavingEvent = {
     onSaving?: Array<string>;
 };
+export type VelcronOnPersistingStateEvent = {
+    onPersistState?: Array<string>;
+    onRestoreState?: Array<string>;
+};
 export type VelcronOnEditModeEvent = {
     onEditMode?: Array<string>;
 };

package/models/VelcronDefinitions.d.ts

@@ -72,7 +72,12 @@ export interface VelcronRenderContextEventHandlers {
     emitting?: <T>(emitter: (i: T) => T) => T;
 }
 export interface VelcronRenderContextEventHandlersInstance extends VelcronRenderContextEventHandlers {
-    emitOnSaved: EventHook<Future<void>>;
+    emitOnSaved: EventHook<void>;
+    emitOnSavedPromises: Array<Future<unknown>>;
+    emitOnPersistState: EventHook<Future<DynamicState>>;
+    emitOnPersistStatePromises: Array<Future<unknown>>;
+    emitOnRestoreState: EventHook<unknown>;
+    emitOnRestoreStatePromises: Array<Future<unknown>>;
 }
 export interface VelcronRenderContextHooks {
     dialogVisibilityChanged?: ((visible: boolean) => void);
@@ -87,6 +92,7 @@ export interface VelcronContainerRenderer {
 }
 export interface VelcronAction extends VelcronRenderContext {
     type: VelcronActionTypes;
+    rootPromises?: Array<Future<void>>;
 }
 export interface VelcronActionGetOrSetValue extends VelcronAction {
     value?: unknown;
@@ -97,6 +103,7 @@ export interface VelcronActionGetOrSetValue extends VelcronAction {
 export interface VelcronActionWithAutoAwait extends VelcronActionGetOrSetValue {
     nowait: boolean;
     action: string;
+    promise: Future<unknown>;
 }
 export interface VelcronActionWithCondition extends VelcronActionWithAutoAwait {
     condition: string;

package/models/VelcronTypes.d.ts

@@ -3,8 +3,3 @@ export type VelcronPrimitiveType = string | number | boolean;
 export type VelcronArrayType<T> = Array<T>;
 export type VelcronObjectType<T extends Object> = T;
 export type VelcroncomponentArrayType = Array<VelcronDefinition>;
-export interface DeferredPromise<T> {
-    promise: Promise<T>;
-    resolve: (val: T) => void;
-    reject: () => void;
-}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@omnia/velcron",
   "license": "MIT",
-  "version": "8.0.136-dev",
+  "version": "8.0.138-dev",
   "description": "Provide Omnia Velcron Stuffs.",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"

package/parser/VelcronActions.d.ts

@@ -1,5 +1,6 @@
-import { VelcronAction, VelcronActionWithAutoAwait, VelcronRenderContext, DeferredPromise, VelcronActionHooks } from "../models";
+import { VelcronAction, VelcronActionWithAutoAwait, VelcronRenderContext, VelcronActionHooks } from "../models";
 import { IActionHandler } from "../actions";
+import { Future } from "internal/fx/shared";
 export declare class VelcronActions {
     static _actionHandlers: {
         [name: string]: IActionHandler;
@@ -10,7 +11,8 @@ export declare class VelcronActions {
     private static registeredBuiltInHandlers;
     static registerAction(handler: IActionHandler): void;
     static unregisterAction(name: string): void;
-    static parseAndExecuteActions(templates: Array<string>, renderContext: VelcronRenderContext, customActionContext?: VelcronCustomActionExecutionContext): void;
+    static actionArrayToString(templates: Array<string>): string;
+    static parseAndExecuteActions(templates: Array<string>, renderContext: VelcronRenderContext, customActionContext?: VelcronCustomActionExecutionContext): Future<unknown>;
     static parseFunction(target: {
         [name: string]: Array<string>;
     }, template: string, renderContext: VelcronRenderContext, params: Array<VelcronActionParameterValue>, foundCb: (name: string, params: {}) => void): void;
@@ -39,6 +41,6 @@ interface VelcronCustomActionExecutionContext {
     customAction: VelcronAction | null;
     parentAction: VelcronAction | VelcronRenderContext;
     variables: object;
-    returnValue: DeferredPromise<any>;
+    returnValue: Future<any>;
 }
 export {};

package/parser/VelcronActions.js

@@ -8,6 +8,7 @@ const VelcronData_1 = require("./VelcronData");
 const builtInHandlers = tslib_1.__importStar(require("../actions"));
 const ActionResults_1 = require("../actions/ActionResults");
 const VelcronLogger_1 = require("./VelcronLogger");
+const shared_1 = require("internal/fx/shared");
 class VelcronActions {
     static { this._actionHandlers = {}; }
     static { this.actionHooks = {}; }
@@ -26,12 +27,7 @@ class VelcronActions {
             delete this._actionHandlers[name];
         }
     }
-    static parseAndExecuteActions(templates, renderContext, customActionContext) {
-        if (!templates) {
-            VelcronLogger_1.VelcronLogger.logActionError("The event template is empty");
-            return;
-        }
-        const actions = [];
+    static actionArrayToString(templates) {
         let template = "";
         let count = 1;
         templates.forEach((temp) => {
@@ -42,14 +38,34 @@ class VelcronActions {
             template = template + temp + (count === templates.length ? "" : " => ");
             count++;
         });
+        return template;
+    }
+    //TODO this might need to be added back together with other code in the file code marked "Sub Action Resolver"    
+    //private static actionPromises: { [id: string]: Array<Future<void>> } = {};
+    static parseAndExecuteActions(templates, renderContext, customActionContext) {
+        if (!templates) {
+            VelcronLogger_1.VelcronLogger.logActionError("The event template is empty");
+            return;
+        }
+        let template = VelcronActions.actionArrayToString(templates);
+        const actions = [];
         const evIdEnd = template.indexOf(VelcronConstants_1.VelcronConstants.events.idTokenEnd);
         const evId = template.substring(VelcronConstants_1.VelcronConstants.events.idTokenStart.length, evIdEnd);
         template = template.substring(evIdEnd + 1);
+        //TODO this might need to be added back together with other code in the file code marked "Sub Action Resolver"
+        //let requiredPromises = 1;
         for (const partialTemplate of template.split("=>")) {
             if (partialTemplate) {
                 const res = VelcronActions.getActionFromTemplate(partialTemplate, evId, renderContext, customActionContext);
                 if (res) {
                     actions.push(res);
+                    //TODO this might need to be added back together with other code in the file code marked "Sub Action Resolver"
+                    // if(!customActionContext && renderContext.actions){ 
+                    //     const depth = VelcronActions.resolveActionsDepth(partialTemplate, renderContext);
+                    //     if(depth > requiredPromises){
+                    //         requiredPromises = depth;
+                    //     }
+                    // }
                 }
             }
         }
@@ -60,9 +76,29 @@ class VelcronActions {
                     VelcronData_1.VelcronData.setVariables(evId, customActionContext.variables);
                 }
             }
+            else {
+                //TODO this might need to be added back together with other code in the file code marked "Sub Action Resolver"
+                // VelcronActions.actionPromises[evId] = [];
+                // for (let i = 0; i < requiredPromises; i++) {
+                //     VelcronActions.actionPromises[evId].push(Future.new<void>());
+                // }
+                // Future.all(VelcronActions.actionPromises[evId]).then(() => {
+                //     console.dir("All promises resolved loveliiiii");
+                // });
+            }
             VelcronActions.executeActions(actions, 0, customActionContext);
             //Clean up temp variables after execution
             VelcronData_1.VelcronData.deleteVariables(evId);
+            //The returned promise will resolved when all sub async actions are resolved
+            return shared_1.Future.all(actions.filter(p => p.promise).map(a => a.promise));
+            //TODO this might need to be added back together with other code in the file code marked "Sub Action Resolver"
+            // return Future.all((actions as Array<VelcronActionWithAutoAwait>).filter(p => p.promise).map(a => a.promise)).then(() => {
+            //     const firstUnresolved = VelcronActions.actionPromises[customActionContext ? customActionContext.parentAction.id : evId].find(p => p && !p.resolved);
+            //     if (firstUnresolved) {
+            //         console.dir("RESOLVE");
+            //         firstUnresolved.resolve();
+            //     }
+            // }) as Future<void>;
         }
     }
     static parseFunction(target, template, renderContext, params, foundCb) {
@@ -182,27 +218,30 @@ class VelcronActions {
             }
             if (VelcronActions.valueIsAction(val)) {
                 //Action e.g await @http.get('https://localhost:4455/api/weather')
-                //All actions is auto awaited by default which i think should be the normal case 
-                //in a modern language :) you can use => nowait @http.get to not wait for the async
+                const castedResult = result;
+                castedResult.promise = shared_1.Future.new();
+                //All actions is auto awaited by default but you can use => nowait @http.get to not wait for the async
                 //operation to complete.
-                if (val.startsWith("nowait")) {
-                    result.nowait = true;
+                if (val.startsWith(VelcronConstants_1.VelcronConstants.async.noWaitToken)) {
+                    castedResult.nowait = true;
+                    castedResult.promise.resolve(null);
                     val = val.substring(6);
                 }
-                result.type = models_1.VelcronActionTypes.promise;
-                result.path = path;
-                result.action = val;
-                result.assignOperator = operator;
+                castedResult.type = models_1.VelcronActionTypes.promise;
+                castedResult.path = path;
+                castedResult.action = val;
+                castedResult.assignOperator = operator;
             }
             else if (partialTemplate.startsWith("return")) {
                 result.type = models_1.VelcronActionTypes.returnsValue;
                 result.value = partialTemplate.substring(6).trim();
             }
             else {
-                result.type = models_1.VelcronActionTypes.getOrSetValue;
-                result.path = path;
-                result.value = val;
-                result.assignOperator = operator;
+                const castedResult = result;
+                castedResult.type = models_1.VelcronActionTypes.getOrSetValue;
+                castedResult.path = path;
+                castedResult.value = val;
+                castedResult.assignOperator = operator;
             }
         }
         if (customActionContext?.parentAction) {
@@ -211,9 +250,11 @@ class VelcronActions {
         return result;
     }
     static valueIsAction(value) {
-        return value.startsWith("@") || value.startsWith("await");
+        return value.startsWith("@") || value.startsWith(VelcronConstants_1.VelcronConstants.async.noWaitToken);
     }
     static executeActions(arr, x, customActionContext) {
+        //start a timer
+        //console.dir(arr);
         //The Callback approach is to be able to wait for a promise to be finished
         //before the loop continues = await support
         VelcronActions.executeAction(arr[x], (continueExecution) => {
@@ -261,7 +302,7 @@ class VelcronActions {
             }
             const val = awAction.action.substring(awAction.action.indexOf("(") + 1).replace(")", "").trim();
             const params = VelcronActions.extractParameterValues(val, awAction);
-            let promise = null;
+            //let promise: Promise<any> | null = null;
             const actionName = awAction.action.substring(0, awAction.action.indexOf("(")).trim().toLowerCase();
             if (!VelcronActions.registeredBuiltInHandlers) {
                 Object.keys(builtInHandlers).forEach((key) => {
@@ -277,7 +318,7 @@ class VelcronActions {
             let hasCustomActionValue = false;
             if (VelcronActions._actionHandlers[actionName]) {
                 //Built in handler
-                promise = VelcronActions._actionHandlers[actionName].action(awAction, ...paramValues);
+                VelcronActions._actionHandlers[actionName].action(awAction, ...paramValues);
                 if (VelcronActions._actionHandlers[actionName].dispose) {
                     awAction.disposers.push(VelcronActions._actionHandlers[actionName].dispose(awAction));
                 }
@@ -294,15 +335,15 @@ class VelcronActions {
                         parentAction: awAction,
                         customAction: null,
                         variables: params,
-                        returnValue: VelcronData_1.VelcronData.createDeferredPromise()
+                        returnValue: shared_1.Future.new()
                     };
                     VelcronActions.parseAndExecuteActions(acArr, awAction, customActionContext);
-                    promise = customActionContext.returnValue.promise;
+                    awAction.promise = customActionContext.returnValue;
                     hasCustomActionValue = true;
                 });
             }
-            if (!awAction.nowait && promise || hasCustomActionValue && promise) {
-                promise.then((val) => {
+            if (!awAction.nowait && awAction.promise || hasCustomActionValue && awAction.promise) {
+                awAction.promise.then((val) => {
                     let continueExecution = true;
                     //If action returns StopProcedingActions class in promise we will not continue executing actions
                     if (val && val instanceof ActionResults_1.CancelProcedingActions) {
@@ -374,6 +415,29 @@ class VelcronActions {
         }
         return args;
     }
+    //TODO this might need to be added back together with other code in the file code marked "Sub Action Resolver"
+    // private static resolveActionsDepth(template, renderContext, currentDepth = 0) {
+    //     let maxDepth = currentDepth;
+    //     if (renderContext && renderContext.actions) {
+    //         for (const fullActionKey of Object.keys(renderContext.actions)) {
+    //             // Trim the action key to its base name (up to the first parenthesis)
+    //             const actionBaseName = fullActionKey.includes("(") ? fullActionKey.substring(0, fullActionKey.indexOf("(") + 1) : fullActionKey;
+    //             // Check if this base action name is present in the template string
+    //             if (template.includes(actionBaseName)) {
+    //                 // Increment depth for the current action
+    //                 const newDepth = currentDepth + 1;
+    //                 maxDepth = Math.max(maxDepth, newDepth);
+    //                 // Resolve nested actions if present
+    //                 const nestedTemplate = VelcronActions.actionArrayToString(renderContext.actions[fullActionKey]);
+    //                 if (nestedTemplate && typeof nestedTemplate === "string") {
+    //                     const nestedMaxDepth = VelcronActions.resolveActionsDepth(nestedTemplate, renderContext, newDepth);
+    //                     maxDepth = Math.max(maxDepth, nestedMaxDepth);
+    //                 }
+    //             }
+    //         }
+    //     }
+    //     return maxDepth;
+    // }
     static extractParameterValues(template, action) {
         const params = [];
         let hasMoreParams = true;

package/parser/VelcronConstants.d.ts

@@ -40,4 +40,7 @@ export declare const VelcronConstants: {
     context: {
         thisToken: string;
     };
+    async: {
+        noWaitToken: string;
+    };
 };

package/parser/VelcronConstants.js

@@ -42,5 +42,8 @@ exports.VelcronConstants = {
     },
     context: {
         thisToken: "$this"
+    },
+    async: {
+        noWaitToken: "nowait",
     }
 };

package/parser/VelcronData.d.ts

@@ -1,4 +1,4 @@
-import { VelcronRenderContext, DeferredPromise, VelcronBindableProp } from "../models";
+import { VelcronRenderContext, VelcronBindableProp } from "../models";
 import { VelcronAppDefinition, VelcronDefinition } from "..";
 export interface ParseResult<T> {
     is: boolean;
@@ -32,7 +32,6 @@ export declare class VelcronData {
     static ensureKeys(ui: VelcronDefinition | VelcronAppDefinition, generateNewKeys?: boolean): void;
     static removeKeys(ui: VelcronDefinition | VelcronAppDefinition): void;
     static generateId(): string;
-    static createDeferredPromise<T>(): DeferredPromise<T>;
 }
 interface ExtendArray extends Array<any> {
     take: (amount: number) => Array<any>;

package/parser/VelcronData.js

@@ -631,12 +631,5 @@ class VelcronData {
         const secondPart = (Math.random() * 46656) | 0;
         return (("000" + firstPart.toString(36)).slice(-3) + ("000" + secondPart.toString(36)).slice(-3)).toString();
     }
-    static createDeferredPromise() {
-        let resolve, reject;
-        const promise = new Promise((res, rej) => {
-            [resolve, reject] = [res, rej];
-        });
-        return { promise, reject, resolve };
-    }
 }
 exports.VelcronData = VelcronData;