@omnia/velcron 8.0.141-dev → 8.0.142-dev

package/actions/Clone.d.ts

@@ -1,2 +1,3 @@
 import { IActionHandler } from "./IActionHandler";
 export declare const objClone: IActionHandler;
+export declare const objAssign: IActionHandler;

package/actions/Clone.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.objClone = void 0;
+exports.objAssign = exports.objClone = void 0;
 const stores_1 = require("../stores");
 exports.objClone = {
     name: "@clone",
@@ -8,3 +8,10 @@ exports.objClone = {
         action.promise.resolve(stores_1.ReactivitySystem.makeReactive(JSON.parse(JSON.stringify(objToClone))));
     }
 };
+exports.objAssign = {
+    name: "@assign",
+    action: (action, source, value) => {
+        //debugger;
+        action.promise.resolve(null);
+    }
+};

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

@@ -1,5 +1,5 @@
 import { GuidValue } from "../Guid";
-import { BoxDimensions, ComponentBlueprints, SpacingBlueprints, TypographyBlueprints } from "./Blueprints";
+import { BoxDimensions, ButtonBlueprint, ComponentBlueprints, SpacingBlueprints, TypographyBlueprints } from "./Blueprints";
 export type ThemeContextType = "default" | "admin" | "preview" | "color-context" | "designer";
 export interface ColorTypeResult<resultType> {
     base: resultType;
@@ -78,6 +78,22 @@ export interface ITemplateRegistration<TTemplateType = any> {
     hidden?: boolean;
     custom?: boolean;
 }
+export type RegistrationType = "button" | "chrome";
+export interface ITemplateRegistration2<TTemplateType = any, TType = RegistrationType> {
+    type: RegistrationType;
+    id: GuidValue;
+    template: TTemplateType;
+    hidden?: boolean;
+    custom?: boolean;
+}
+export interface ITemplateRegistration<TTemplateType = any> {
+    id: GuidValue;
+    template: TTemplateType;
+    hidden?: boolean;
+    custom?: boolean;
+}
+export interface ButtonBlueprintRegistration extends ITemplateRegistration2<ButtonBlueprint, "button"> {
+}
 export type ColorSchemaType = keyof typeof ColorSchemaTypes;
 export declare enum ColorSchemaTypes {
     primary = "primary",

package/package.json

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

package/parser/VelcronActions.d.ts

@@ -12,7 +12,10 @@ export declare class VelcronActions {
     static registerAction(handler: IActionHandler): void;
     static unregisterAction(name: string): void;
     static actionArrayToString(templates: Array<string>): string;
-    static parseAndExecuteActions(templates: Array<string>, renderContext: VelcronRenderContext, customActionContext?: VelcronCustomActionExecutionContext): Future<unknown>;
+    static parseAndExecuteActions(templates: Array<string>, renderContext: VelcronRenderContext, options?: {
+        customActionContext?: VelcronCustomActionExecutionContext;
+        variables?: object;
+    }): Future<unknown>;
     static parseFunction(target: {
         [name: string]: Array<string>;
     }, template: string, renderContext: VelcronRenderContext, params: Array<VelcronActionParameterValue>, foundCb: (name: string, params: {}) => void): void;

package/parser/VelcronActions.js

@@ -42,7 +42,7 @@ class VelcronActions {
     }
     //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) {
+    static parseAndExecuteActions(templates, renderContext, options) {
         if (!templates) {
             VelcronLogger_1.VelcronLogger.logActionError("The event template is empty");
             return;
@@ -52,11 +52,15 @@ class VelcronActions {
         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);
+        if (options?.variables) {
+            //Support settings event specific variables example in onPersistState/onRestoreState
+            VelcronData_1.VelcronData.setVariables(evId, options?.variables);
+        }
         //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);
+                const res = VelcronActions.getActionFromTemplate(partialTemplate, evId, renderContext, options?.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"
@@ -70,10 +74,10 @@ class VelcronActions {
             }
         }
         if (actions.length > 0) {
-            if (customActionContext) {
-                customActionContext.customAction = renderContext;
-                if (customActionContext.variables) {
-                    VelcronData_1.VelcronData.setVariables(evId, customActionContext.variables);
+            if (options?.customActionContext) {
+                options.customActionContext.customAction = renderContext;
+                if (options.customActionContext.variables) {
+                    VelcronData_1.VelcronData.setVariables(evId, options.customActionContext.variables);
                 }
             }
             else {
@@ -86,11 +90,13 @@ class VelcronActions {
                 //     console.dir("All promises resolved loveliiiii");
                 // });
             }
-            VelcronActions.executeActions(actions, 0, customActionContext);
-            //Clean up temp variables after execution
-            VelcronData_1.VelcronData.deleteVariables(evId);
+            VelcronActions.executeActions(actions, 0, options?.customActionContext);
             //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));
+            //return Future.all((actions as Array<VelcronActionWithAutoAwait>).filter(p => p.promise).map(a => a.promise)) as Future<unknown>;
+            return shared_1.Future.all(actions.filter(p => p.promise).map(a => a.promise)).then(() => {
+                //Clean up temp variables after execution
+                VelcronData_1.VelcronData.deleteVariables(evId);
+            });
             //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);
@@ -337,7 +343,7 @@ class VelcronActions {
                         variables: params,
                         returnValue: shared_1.Future.new()
                     };
-                    VelcronActions.parseAndExecuteActions(acArr, awAction, customActionContext);
+                    VelcronActions.parseAndExecuteActions(acArr, awAction, { customActionContext });
                     awAction.promise = customActionContext.returnValue;
                     hasCustomActionValue = true;
                 });

package/parser/VelcronConstants.d.ts

@@ -28,6 +28,7 @@ export declare const VelcronConstants: {
         idTokenStart: string;
         idTokenEnd: string;
         returnValueVariableName: string;
+        persistStateVariableName: string;
     };
     state: {
         stateRootToken: string;

package/parser/VelcronConstants.js

@@ -30,7 +30,8 @@ exports.VelcronConstants = {
     events: {
         idTokenStart: "$ev{",
         idTokenEnd: "}",
-        returnValueVariableName: "$returnValue"
+        returnValueVariableName: "$returnValue",
+        persistStateVariableName: "$persistedState"
     },
     state: {
         stateRootToken: "$state"

package/parser/VelcronData.d.ts

@@ -25,6 +25,7 @@ export declare class VelcronData {
     static isArray(obj: any): obj is ExtendArray;
     static isObject(value: any): boolean;
     static extendObject(obj: any): any;
+    static propertyPathExists(obj: object, path: string): boolean;
     static getOrSetObjectByPath<T>(object: Object, path: string, value?: any): T | null;
     static getOrSet<T>(renderContext: VelcronRenderContext, path: string, value?: any): T;
     static getTokens(template: any, removeBrackets: boolean): string[];

package/parser/VelcronData.js

@@ -112,12 +112,9 @@ class VelcronData {
         return result;
     }
     static setVariables(eventId, varsToSet) {
-        const variables = VelcronData.variables;
-        if (!variables[eventId]) {
-            variables[eventId] = {};
-        }
+        VelcronData.variables[eventId] ??= {};
         Object.keys(varsToSet).forEach((key) => {
-            variables[eventId][key] = varsToSet[key];
+            VelcronData.variables[eventId][key] = varsToSet[key];
         });
     }
     static evaluateSet(path, value, renderContext) {
@@ -180,16 +177,16 @@ class VelcronData {
         }
         else if (renderContext.id &&
             variables.hasOwnProperty(renderContext.id) &&
-            VelcronData.getOrSetObjectByPath(variables[renderContext.id], path) != undefined) {
+            VelcronData.propertyPathExists(variables[renderContext.id], path)) {
             variableReassignmentFromPath = true;
             //value = VelcronData.getOrSetObjectByPath(variables[renderContext.id], value);
         }
         else if (renderContext.id &&
             VelcronData.isString(value) &&
             variables.hasOwnProperty(renderContext.id) &&
-            VelcronData.getOrSetObjectByPath(variables[renderContext.id], value) != undefined) {
+            VelcronData.propertyPathExists(variables[renderContext.id], value)) {
             variableReassignmentFromValue = true;
-            if (variables[renderContext.id] && variables[renderContext.id][path] != undefined) {
+            if (VelcronData.propertyPathExists(variables[renderContext.id], path)) {
                 variableReassignmentFromValueIsFromVariable = true;
             }
         }
@@ -236,7 +233,8 @@ class VelcronData {
                 //variables[renderContext.parent.id][VelcronConstants.events.returnValueVariableName] = value;
             }
             else if (renderContext.id && !variableReassignmentFromValue) {
-                variables[renderContext.id][path.substring(pathSubLength)] = value;
+                VelcronData.getOrSetObjectByPath(variables[renderContext.id], path.substring(pathSubLength), value);
+                //variables[renderContext.id][path.substring(pathSubLength)] = value;
             }
             runEvaluation = false;
             runAssignment = false;
@@ -448,6 +446,19 @@ class VelcronData {
         }
         return obj;
     }
+    static propertyPathExists(obj, path) {
+        const keys = path.split(".");
+        let current = obj;
+        for (const key of keys) {
+            if (current[key] !== undefined) {
+                current = current[key];
+            }
+            else {
+                return false;
+            }
+        }
+        return true;
+    }
     static getOrSetObjectByPath(object, path, value = undefined) {
         if (typeof path !== "string") {
             return null;