@omnia/velcron 8.0.96-vnext → 8.0.97-vnext

package/actions/Alert.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.alerter = void 0;
 exports.alerter = {
     name: "@alert",
-    action: (action, value, nisse) => {
+    action: (action, value) => {
         //value = VelcronData.dataBind(action, value)
         //alert(value + nisse ? nisse : 'nullsiu');
         alert(`${value}`);

package/actions/Date.d.ts

@@ -0,0 +1,3 @@
+import { IActionHandler } from "./IActionHandler";
+export declare const dateFormat: IActionHandler;
+export declare const dateCountDown: IActionHandler;

package/actions/Date.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dateCountDown = exports.dateFormat = void 0;
+const tslib_1 = require("tslib");
+const dayjs_1 = tslib_1.__importDefault(require("dayjs"));
+const duration_1 = tslib_1.__importDefault(require("dayjs/plugin/duration"));
+dayjs_1.default.extend(duration_1.default);
+exports.dateFormat = {
+    name: "@date.format",
+    action: (action, value) => {
+        return Promise.resolve((0, dayjs_1.default)().format(value));
+    }
+};
+exports.dateCountDown = {
+    name: "@date.diff",
+    action: (action, date, past = false) => {
+        const now = (0, dayjs_1.default)();
+        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({
+            years: duration.years(),
+            months: duration.months(),
+            days: duration.days(),
+            hours: duration.hours(),
+            minutes: duration.minutes(),
+            seconds: duration.seconds(),
+            expired,
+        });
+    }
+};

package/actions/IActionHandler.d.ts

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

package/actions/Timer.d.ts

@@ -0,0 +1,4 @@
+import { IActionHandler } from "./IActionHandler";
+export declare const timerCreate: IActionHandler;
+export declare const timerStart: IActionHandler;
+export declare const timerStop: IActionHandler;

package/actions/Timer.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timerStop = exports.timerStart = exports.timerCreate = void 0;
+const parser_1 = require("../parser");
+const timerCreateName = "@timer.create";
+exports.timerCreate = {
+    name: "@timer.create",
+    action: (action, interval, autostart = true, immediate = false) => {
+        if (!action.path) {
+            parser_1.VelcronLogger.logActionError(`${timerCreateName} requires assignment to a state variable. Example: $state.timer1 = ${timerCreateName}(1000)`);
+        }
+        if (interval < 1000) {
+            parser_1.VelcronLogger.logActionError(`${timerCreateName} The timer interval must be at least 1000 milliseconds`);
+        }
+        const path = getPath(action.path);
+        if (action.rootContext[path] === typeof TimerInstance) {
+            //TODO: What do we do if the instance is already created?
+            console.dir("Timer already created");
+        }
+        else {
+            //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);
+    },
+    dispose: (action) => {
+        return () => {
+            const path = getPath(action.path);
+            action.rootContext[path].stop();
+            action.rootContext[path] = undefined;
+        };
+    }
+};
+const timerStartName = "@timer.start";
+exports.timerStart = {
+    name: timerStartName,
+    action: (action, timer) => {
+        if ((timer instanceof TimerInstance) === false) {
+            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);
+    }
+};
+const timerStopName = "@timer.stop";
+exports.timerStop = {
+    name: timerStopName,
+    action: (action, timer) => {
+        if ((timer instanceof TimerInstance) === false) {
+            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);
+    }
+};
+function getPath(path) {
+    return path.substring(0, path.indexOf("=")).trim();
+}
+class TimerInstance {
+    constructor(actions, renderCtx, interval, autostart, immediate) {
+        this.actions = actions;
+        this.renderCtx = renderCtx;
+        this.interval = interval;
+        this.autostart = autostart;
+        this.immediate = immediate;
+        if (autostart) {
+            this.start();
+        }
+    }
+    stop() {
+        clearInterval(this.intervalId);
+    }
+    start() {
+        //Run the action immediately
+        this.immediate && parser_1.VelcronActions.parseAndExecuteActions(this.actions, this.renderCtx);
+        this.intervalId = setInterval(() => {
+            parser_1.VelcronActions.parseAndExecuteActions(this.actions, this.renderCtx);
+        }, this.interval);
+    }
+}

package/actions/index.d.ts

@@ -9,3 +9,5 @@ export * from "./Log";
 export * from "./MsGraph";
 export * from "./MsSharePoint";
 export * from "./Emit";
+export * from "./Timer";
+export * from "./Date";

package/actions/index.js

@@ -12,3 +12,5 @@ tslib_1.__exportStar(require("./Log"), exports);
 tslib_1.__exportStar(require("./MsGraph"), exports);
 tslib_1.__exportStar(require("./MsSharePoint"), exports);
 tslib_1.__exportStar(require("./Emit"), exports);
+tslib_1.__exportStar(require("./Timer"), exports);
+tslib_1.__exportStar(require("./Date"), exports);

package/models/VelcronDefinitions.d.ts

@@ -44,19 +44,20 @@ export interface VelcronRenderContext {
     colors?: ReturnType<typeof useVelcronColorSchemaStore>;
     blueprints?: ReturnType<typeof useVelcronBlueprintStore>;
     actions?: {
-        [name: string]: [];
+        [name: string]: Array<string>;
     };
     components?: Array<VelcronCustomComponentDefinition>;
     properties?: {
         [name: string]: VelcronPrimitiveType | VelcroncomponentArrayType;
     };
     computed?: {
-        [name: string]: [];
+        [name: string]: Array<string>;
     };
     parent?: VelcronRenderContext;
     hooks?: VelcronRenderContextHooks;
     eventHandlers?: VelcronRenderContextEventHandlers;
     editMode?: boolean;
+    disposers: Array<() => void>;
 }
 export interface VelcronRenderContextEventHandlers {
     receiving?: {
@@ -172,13 +173,13 @@ export interface VelcronAppDefinition<TState extends DynamicState = DynamicState
     body?: Array<VelcronDefinition>;
     events?: VelcronOnLoadEvent & VelcronOnEditModeEvent;
     actions?: {
-        [name: string]: [];
+        [name: string]: Array<string>;
     };
     components?: Array<VelcronCustomComponentDefinition>;
     propEditors?: Array<VelcronPropertyEditor>;
     state?: TState;
     computed?: {
-        [name: string]: [];
+        [name: string]: Array<string>;
     };
 }
 export interface VelcronComponentDefinition extends VelcronDefinition {

package/package.json

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

package/parser/VelcronActions.d.ts

@@ -7,7 +7,7 @@ export declare class VelcronActions {
     static registerAction(name: string, handler: IActionHandler): void;
     static parseAndExecuteActions(templates: Array<string>, renderContext: VelcronRenderContext, customActionContext?: VelcronCustomActionExecutionContext): void;
     static parseFunction(target: {
-        [name: string]: [];
+        [name: string]: Array<string>;
     }, template: string, renderContext: VelcronRenderContext, params: Array<VelcronActionParameterValue>, foundCb: (name: string, params: {}) => void): void;
     static getActionFromTemplate(partialTemplate: string, eventId: string, renderContext: VelcronRenderContext, customActionContext?: VelcronCustomActionExecutionContext): VelcronAction;
     static valueIsAction(value: string): boolean;

package/parser/VelcronActions.js

@@ -271,6 +271,9 @@ class VelcronActions {
             if (VelcronActions._actionHandlers[actionName]) {
                 //Built in handler
                 promise = VelcronActions._actionHandlers[actionName].action(awAction, ...paramValues);
+                if (VelcronActions._actionHandlers[actionName].dispose) {
+                    awAction.disposers.push(VelcronActions._actionHandlers[actionName].dispose(awAction));
+                }
             }
             else {
                 //Custom handler

package/parser/VelcronData.js

@@ -285,7 +285,10 @@ class VelcronData {
                     }
                     else {
                         //try get value from render context
-                        value = VelcronData.getOrSetObjectByPathUsingRenderContext(renderContext, value);
+                        const localVal = VelcronData.getOrSetObjectByPathUsingRenderContext(renderContext, value);
+                        if (localVal !== undefined && localVal !== null) {
+                            value = localVal;
+                        }
                     }
                 }
             }

package/parser/VelcronRenderers.js

@@ -75,6 +75,7 @@ class VelcronRenderers {
             colors: currentRenderCtx.colors,
             editMode: currentRenderCtx.editMode,
             blueprints: currentRenderCtx.blueprints,
+            disposers: currentRenderCtx.disposers
         };
         if (VelcronRenderers.definitionContainsCustomColorSchema(definition)) {
             const colorSchemaStore = (0, __1.useVelcronColorSchemaStore)(definition.key.toString());