@omnia/velcron 6.100.8-dev

package/README.md

@@ -0,0 +1,6 @@
+# Omnia Velcron
+
+Omnia Velcron is a product from Precio Fishbone. In order to use Omnia Fx you need a product license for one of the following products:
+
+### Documentation
+https://github.com/preciofishbone/OmniaDocs

package/actions/ActionResults.d.ts

@@ -0,0 +1,4 @@
+export declare class CancelProcedingActions {
+}
+export declare class SkipSetValue {
+}

package/actions/ActionResults.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkipSetValue = exports.CancelProcedingActions = void 0;
+//When this class is returned as the value of action promise 
+//we will stop executing actions after.
+class CancelProcedingActions {
+}
+exports.CancelProcedingActions = CancelProcedingActions;
+//Actions can set this as the promise response 
+//to indicate that they have controled the set operation
+//in the action. e.g @arrayAppend sets the values 
+class SkipSetValue {
+}
+exports.SkipSetValue = SkipSetValue;

package/actions/Alert.d.ts

@@ -0,0 +1,2 @@
+import { IActionHandler } from "./IActionHandler";
+export declare const alerter: IActionHandler;

package/actions/Alert.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.alerter = void 0;
+exports.alerter = {
+    name: "@alert",
+    action: (action, value, nisse) => {
+        //value = VelcronData.dataBind(action, value)
+        //alert(value + nisse ? nisse : 'nullsiu');
+        alert(`${value}`);
+        return Promise.resolve(null);
+    }
+};

package/actions/Array.d.ts

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

package/actions/Array.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayTake = exports.arrayAppend = void 0;
+const VelcronData_1 = require("../parser/VelcronData");
+const ActionResults_1 = require("./ActionResults");
+exports.arrayAppend = {
+    name: "@array.append",
+    action: (action, arrayToAppend) => {
+        const existingArray = VelcronData_1.VelcronData.getOrSetObjectByPathUsingRenderContext(action, action.path);
+        existingArray.push(...arrayToAppend);
+        return Promise.resolve(new ActionResults_1.SkipSetValue());
+    }
+};
+exports.arrayTake = {
+    name: "@array.take",
+    action: (action, arr, takeTemplate) => {
+        takeTemplate = VelcronData_1.VelcronData.dataBind(action, takeTemplate);
+        const take = parseInt(takeTemplate);
+        arr = arr.slice(0, take);
+        return Promise.resolve(arr);
+    }
+};

package/actions/Debounce.d.ts

@@ -0,0 +1,2 @@
+import { IActionHandler } from "./IActionHandler";
+export declare const debounce: IActionHandler;

package/actions/Debounce.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debounce = void 0;
+const VelcronData_1 = require("../parser/VelcronData");
+const ActionResults_1 = require("./ActionResults");
+const debounces = {};
+exports.debounce = {
+    name: "@debounce",
+    action: (action, value) => {
+        //TODO Try catch
+        value = VelcronData_1.VelcronData.dataBind(action, value);
+        const bounceDelayTime = parseInt(value);
+        if (!debounces[action.id]) {
+            debounces[action.id] = debounceInternal(() => { Promise.resolve(); }, bounceDelayTime);
+        }
+        return debounces[action.id]();
+    }
+};
+function debounceInternal(inner, ms = 0) {
+    let timer;
+    let resolves = [];
+    return function (...args) {
+        // Run the function after a certain amount of time
+        clearTimeout(timer);
+        timer = setTimeout(() => {
+            // Get the result of the inner function, then apply it to the resolve function of
+            // each promise that has been created since the last time the inner function was run
+            const result = inner(...args);
+            let count = 1;
+            resolves.forEach((resolvable) => {
+                if (count === resolves.length) {
+                    resolvable.resolve(null);
+                }
+                else {
+                    resolvable.resolve(new ActionResults_1.CancelProcedingActions());
+                }
+                count++;
+            });
+            resolves = [];
+        }, ms);
+        return new Promise((resolve, reject) => resolves.push({ resolve: resolve, reject: reject }));
+    };
+}

package/actions/Delay.d.ts

@@ -0,0 +1,2 @@
+import { IActionHandler } from "./IActionHandler";
+export declare const delay: IActionHandler;

package/actions/Delay.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delay = void 0;
+const VelcronData_1 = require("../parser/VelcronData");
+exports.delay = {
+    name: "@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);
+        });
+    }
+};

package/actions/Emit.d.ts

@@ -0,0 +1,2 @@
+import { IActionHandler } from "./IActionHandler";
+export declare const emit: IActionHandler;

package/actions/Emit.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emit = void 0;
+const parser_1 = require("../parser");
+exports.emit = {
+    name: "@emit",
+    action: (action, value, ...args) => {
+        if (action.eventHandlers?.receiving) {
+            let found = false;
+            Object.keys(action.eventHandlers?.receiving).forEach((key) => {
+                if (value.toLowerCase() == key.toLowerCase()) {
+                    action.eventHandlers?.receiving[key](...args);
+                    found = true;
+                }
+            });
+            if (!found) {
+                parser_1.VelcronLogger.logActionError(`Could not find incoming event handler for ${value}`);
+            }
+        }
+        else {
+            parser_1.VelcronLogger.logActionError("There is no incoming event handlers registered");
+        }
+        return Promise.resolve(null);
+    }
+};

package/actions/Http.d.ts

@@ -0,0 +1,2 @@
+import { IActionHandler } from "./IActionHandler";
+export declare const httpGet: IActionHandler;

package/actions/Http.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpGet = void 0;
+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;
+            });
+        });
+    }
+};

package/actions/IActionHandler.d.ts

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

package/actions/IActionHandler.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/actions/Log.d.ts

@@ -0,0 +1,2 @@
+import { IActionHandler } from "./IActionHandler";
+export declare const logInfo: IActionHandler;

package/actions/Log.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logInfo = void 0;
+exports.logInfo = {
+    name: "@log.info",
+    action: (action, value) => {
+        console.dir(value);
+        return Promise.resolve(null);
+    }
+};

package/actions/MsGraph.d.ts

@@ -0,0 +1,2 @@
+import { IActionHandler } from "./IActionHandler";
+export declare const msGraphGet: IActionHandler;

package/actions/MsGraph.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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);
+        });
+    }
+};

package/actions/MsSharePoint.d.ts

@@ -0,0 +1,2 @@
+import { IActionHandler } from "./IActionHandler";
+export declare const msSp: IActionHandler;

package/actions/MsSharePoint.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.msSp = void 0;
+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);
+        });
+    }
+};

package/actions/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./IActionHandler";
+export * from "./Delay";
+export * from "./Http";
+export * from "./Debounce";
+export * from "./ActionResults";
+export * from "./Array";
+export * from "./Alert";
+export * from "./Log";
+export * from "./MsGraph";
+export * from "./MsSharePoint";
+export * from "./Emit";

package/actions/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./IActionHandler"), exports);
+tslib_1.__exportStar(require("./Delay"), exports);
+tslib_1.__exportStar(require("./Http"), exports);
+tslib_1.__exportStar(require("./Debounce"), exports);
+tslib_1.__exportStar(require("./ActionResults"), exports);
+tslib_1.__exportStar(require("./Array"), exports);
+tslib_1.__exportStar(require("./Alert"), exports);
+tslib_1.__exportStar(require("./Log"), exports);
+tslib_1.__exportStar(require("./MsGraph"), exports);
+tslib_1.__exportStar(require("./MsSharePoint"), exports);
+tslib_1.__exportStar(require("./Emit"), exports);

package/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./models";
+export * from "./parser";
+export * from "./actions";
+export * from "./stores";
+export * from "@omnia/velcron/internal-do-not-import-from-here/shared/models";
+export * from "./utilities";

package/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./models"), exports);
+tslib_1.__exportStar(require("./parser"), exports);
+tslib_1.__exportStar(require("./actions"), exports);
+tslib_1.__exportStar(require("./stores"), exports);
+tslib_1.__exportStar(require("@omnia/velcron/internal-do-not-import-from-here/shared/models"), exports);
+tslib_1.__exportStar(require("./utilities"), exports);

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

@@ -0,0 +1,23 @@
+export type BringMethods = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
+export type BringCacheOptions = "no-cache" | "reload" | "force-cache" | "only-if-cached";
+export type BringCredentials = "include" | "omit" | "same-origin";
+export interface BringInterceptOptions {
+    beforeRequest?: (request: BringConfig) => BringConfig;
+    afterRequest?: <T>(response: BringResponse<T>, request: BringConfig) => BringResponse<T>;
+}
+export interface BringConfig {
+    baseUrl?: string;
+    headers?: {
+        [key: string]: string;
+    };
+    cache?: BringCacheOptions;
+    interceptors?: BringInterceptOptions;
+    abortable?: boolean;
+    credentials?: BringCredentials;
+}
+export interface BringResponse<TData> {
+    data?: TData;
+    status: Number;
+    statusText: String;
+    ok: Boolean;
+}

package/internal-do-not-import-from-here/shared/models/Bring.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,25 @@
+import { Topic } from "./Topic";
+export declare enum BroadcastTopicScopes {
+    localUi = "localUi",
+    localWorker = "localWorker",
+    localAll = "localAll",
+    globalUi = "globalUi",
+    globalWorker = "globalWorker",
+    globalAll = "globalAll"
+}
+export interface BroadcastTopic<TMessage> extends Topic<TMessage> {
+    scope: BroadcastTopicScopes;
+}
+export interface BroadcastInvokeTopic<TMessage, TReturnValue> extends Topic<TMessage> {
+    scope: BroadcastTopicScopes;
+}
+export interface BroadcastMessage<TMessage> extends BroadcastTopic<TMessage> {
+    message: TMessage;
+}
+export interface BroadcastInvokeMessage<TMessage, TReturnValue> extends BroadcastInvokeTopic<TMessage, TReturnValue> {
+    messageId: string;
+    message: TMessage;
+    type: "request" | "response";
+    error?: string;
+    response?: TReturnValue;
+}

package/internal-do-not-import-from-here/shared/models/Broadcasting.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BroadcastTopicScopes = void 0;
+var BroadcastTopicScopes;
+(function (BroadcastTopicScopes) {
+    BroadcastTopicScopes["localUi"] = "localUi";
+    BroadcastTopicScopes["localWorker"] = "localWorker";
+    BroadcastTopicScopes["localAll"] = "localAll";
+    BroadcastTopicScopes["globalUi"] = "globalUi";
+    BroadcastTopicScopes["globalWorker"] = "globalWorker";
+    BroadcastTopicScopes["globalAll"] = "globalAll";
+})(BroadcastTopicScopes = exports.BroadcastTopicScopes || (exports.BroadcastTopicScopes = {}));

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

@@ -0,0 +1,44 @@
+export declare class Future<T> extends Promise<T> {
+    resolve: (value: T) => void;
+    reject: (reason: any) => void;
+    resolving: boolean;
+    private _resolved;
+    private _rejected;
+    private onAborted;
+    constructor(executor: (resolve: (value: T) => void, reject: (reason?: any) => void, onAborted: (cb: (reason?: any) => void) => void) => void);
+    /**
+     * Handles success / rejection from Promise and returns the result as an object.
+     * If the promise is rejected, the error will be in the error property.
+     * No need to try/catch the promise when using this method.
+     *
+     * @return {*}  {Future<{ success?: T, error?: Error; }>}
+     * @memberof Future
+     */
+    tryCatch(): Future<[success: T, error: Error]>;
+    /**
+     * Aborts the request
+     *
+     * @param {*} [reason]
+     * @memberof Future
+     */
+    abort(reason?: any): void;
+    /**
+     * Creates a Promise that is resolved with an array of results when all of the provided Promises
+     * resolve, or rejected when any Promise is rejected.
+     * @param values An array of Promises.
+     * @returns A new Promise.
+     */
+    static all<T extends readonly unknown[] | []>(values: T): Promise<{
+        -readonly [P in keyof T]: Awaited<T[P]>;
+    }>;
+    get resolved(): boolean;
+    get rejected(): boolean;
+    static get [Symbol.species](): PromiseConstructor;
+    get [Symbol.toStringTag](): string;
+    static new<TReturnValue>(): Future<TReturnValue>;
+}
+export declare class ResponsePromise<T> extends Promise<T> {
+    cancelCb: (() => void);
+    constructor(executor: any);
+    cancel(): void;
+}

package/internal-do-not-import-from-here/shared/models/Future.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponsePromise = exports.Future = void 0;
+class Future extends Promise {
+    constructor(executor) {
+        let resolveLocal;
+        let rejectLocal;
+        const onAborted = (cb) => {
+            setTimeout(() => {
+                this.onAborted = cb;
+            });
+        };
+        const exec = (resolve, reject) => {
+            // assign to local to prevent error assignbefore call super;
+            resolveLocal = resolve;
+            rejectLocal = reject;
+        };
+        super(exec);
+        this.resolving = false;
+        this._resolved = false;
+        this._rejected = false;
+        this.resolve = (value) => {
+            this.resolving = false;
+            this._resolved = true;
+            resolveLocal(value);
+        };
+        this.reject = (reason) => {
+            this.resolving = false;
+            this._rejected = true;
+            rejectLocal(reason);
+        };
+        if (executor) {
+            executor(this.resolve, this.reject, onAborted);
+        }
+    }
+    /**
+     * Handles success / rejection from Promise and returns the result as an object.
+     * If the promise is rejected, the error will be in the error property.
+     * No need to try/catch the promise when using this method.
+     *
+     * @return {*}  {Future<{ success?: T, error?: Error; }>}
+     * @memberof Future
+     */
+    //tryCatch(): Future<{ success?: T, error?: Error; }> {
+    tryCatch() {
+        return new Future(async (resolve) => {
+            try {
+                const data = await this;
+                resolve([data, undefined]);
+            }
+            catch (err) {
+                resolve([undefined, err]);
+            }
+        });
+    }
+    /**
+     * Aborts the request
+     *
+     * @param {*} [reason]
+     * @memberof Future
+     */
+    abort(reason) {
+        if (this.onAborted) {
+            this.onAborted(reason);
+        }
+        else {
+            throw "Failed calling abort() => The future has no onAborted callback or you tried to call abort immediately after the future was created.";
+        }
+    }
+    /**
+     * Creates a Promise that is resolved with an array of results when all of the provided Promises
+     * resolve, or rejected when any Promise is rejected.
+     * @param values An array of Promises.
+     * @returns A new Promise.
+     */
+    static all(values) {
+        // have issue with Promise.all not working when promises is mixin Future and promise
+        // so implement Future.all to make a wrapper promise to Future to resolve that issue.
+        const promises = values.map(p => p instanceof Future ? new Promise((resolve, reject) => p.then(resolve, reject)) : p);
+        return Promise.all(promises);
+    }
+    get resolved() {
+        return this._resolved;
+    }
+    get rejected() {
+        return this._rejected;
+    }
+    static get [Symbol.species]() {
+        return Promise;
+    }
+    get [Symbol.toStringTag]() {
+        // return Object value to make vue can build get/set reactive.
+        return "Object";
+    }
+    static new() {
+        return new Future(() => { });
+    }
+}
+exports.Future = Future;
+class ResponsePromise extends Promise {
+    constructor(executor) {
+        const onCancel = (cb) => {
+            //using nextTick because we cant use "this" before super()
+            setTimeout(() => {
+                this.cancelCb = cb;
+            });
+        };
+        const oExecutor = (resolve, reject) => {
+            executor(resolve, reject, onCancel);
+        };
+        super(oExecutor);
+    }
+    cancel() {
+        if (this.cancelCb) {
+            this.cancelCb();
+        }
+        else {
+            console.warn("onCancel not provided");
+        }
+    }
+}
+exports.ResponsePromise = ResponsePromise;

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

@@ -0,0 +1,17 @@
+export interface GuidValue {
+    toString: () => string;
+}
+/**
+ * Class to create a guid
+ */
+export declare class Guid implements GuidValue {
+    private static _empty;
+    static newGuid(): GuidValue;
+    static get empty(): GuidValue;
+    static isValid(guid: string | GuidValue): boolean;
+    private value;
+    constructor(guid: string);
+    toString(): string;
+    toJSON: () => string;
+    valueOf(): string;
+}

package/internal-do-not-import-from-here/shared/models/Guid.js

@@ -0,0 +1,51 @@
+"use strict";
+//export interface GuidValue {
+//    :string;
+//}
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Guid = void 0;
+/**
+ * Class to create a guid
+ */
+class Guid {
+    static newGuid() {
+        return new Guid("xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, c => {
+            const r = Math.random() * 16 | 0;
+            const v = (c == "x") ? r : (r & 0x3 | 0x8);
+            return v.toString(16);
+        }));
+    }
+    static get empty() {
+        return this._empty;
+    }
+    static isValid(guid) {
+        if (guid === undefined || guid === null) {
+            return false;
+        }
+        const validRegex = /^[{]?[0-9a-fA-F]{8}[-]?([0-9a-fA-F]{4}[-]?){3}[0-9a-fA-F]{12}[}]?$/;
+        return validRegex.test(guid.toString());
+    }
+    constructor(guid) {
+        this.value = Guid._empty;
+        //We serialize as string value
+        this.toJSON = () => {
+            return this.value.toLowerCase();
+        };
+        if (guid) {
+            if (Guid.isValid(guid)) {
+                this.value = guid;
+            }
+            else {
+                throw `The string '${guid}' is not a valid Guid`;
+            }
+        }
+    }
+    toString() {
+        return this.value.toLowerCase();
+    }
+    valueOf() {
+        return this.value.toLowerCase();
+    }
+}
+exports.Guid = Guid;
+Guid._empty = "00000000-0000-0000-0000-000000000000";