@magic-xpa/engine 4.1100.0-dev4110.106 → 4.1100.0-dev4110.107

package/esm2020/src/rt/CompMainPrgTable.mjs

@@ -0,0 +1,65 @@
+import { Logger, StrUtil, XMLConstants, XmlParser } from "@magic-xpa/utils";
+import { NString, NNumber } from "@magic-xpa/mscorelib";
+import { ConstInterface } from "../ConstInterface";
+export class CompMainPrgTable {
+    constructor() {
+        this._ctlIdxTab = null;
+    }
+    fillData(parser) {
+        let endContext = parser.getXMLdata().indexOf(XMLConstants.TAG_TERM, parser.getCurrIndex());
+        if (endContext !== -1 && endContext < parser.getXMLdata().length) {
+            let tag = parser.getXMLsubstring(endContext);
+            parser.add2CurrIndex(tag.indexOf(ConstInterface.MG_TAG_COMPMAINPRG) + ConstInterface.MG_TAG_COMPMAINPRG.length);
+            let tokensVector = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);
+            Logger.Instance.WriteDevToLog("in CompMainPrg.FillData: " + tokensVector.toString());
+            this.initElements(tokensVector);
+            parser.setCurrIndex(endContext + XMLConstants.TAG_TERM.length);
+            return;
+        }
+        Logger.Instance.WriteExceptionToLogWithMsg("in CompMainPrg.FillData() out of string bounds");
+    }
+    initElements(tokensVector) {
+        for (let j = 0; j < tokensVector.length; j += 2) {
+            let attribute = (tokensVector.get_Item(j));
+            let valueStr = (tokensVector.get_Item(j + 1));
+            if (attribute === XMLConstants.MG_ATTR_VALUE) {
+                valueStr = StrUtil.DeleteStringsFromEnds(valueStr, "\"");
+                this.initCtlIdxTab(valueStr);
+            }
+            else
+                Logger.Instance.WriteExceptionToLogWithMsg(NString.Format("There is no such index in CompMainPrg. Add case to CompMainPrg.initElements for {0}", attribute));
+        }
+        Logger.Instance.WriteDevToLog("End CompMainPrg ");
+    }
+    initCtlIdxTab(val) {
+        if (NString.IsNullOrEmpty(val))
+            return;
+        if (val.indexOf(",") !== -1)
+            this._ctlIdxTab = StrUtil.tokenize(val, ",");
+        else {
+            this._ctlIdxTab = new Array(1);
+            this._ctlIdxTab[0] = val;
+        }
+    }
+    getCtlIdx(idx) {
+        if (idx >= 0 && idx < this.getSize()) {
+            let s = this._ctlIdxTab[idx];
+            return NNumber.Parse(s);
+        }
+        return -1;
+    }
+    getIndexOf(ctlIdx) {
+        let i;
+        for (i = 0; i < this.getSize(); i++) {
+            if (ctlIdx === this.getCtlIdx(i))
+                return i;
+        }
+        return -1;
+    }
+    getSize() {
+        if (this._ctlIdxTab === null)
+            return 0;
+        return this._ctlIdxTab.length;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/rt/DataviewHeaderBase.mjs

@@ -0,0 +1,96 @@
+import { YesNoExp } from '../exp/YesNoExp';
+import { NString, RefParam } from '@magic-xpa/mscorelib';
+import { Logger, XMLConstants, XmlParser } from '@magic-xpa/utils';
+import { ConstInterface } from '../ConstInterface';
+export class DataviewHeaderBase {
+    get ReturnField() {
+        if (this.returnfield === null && this._retVal !== null)
+            this.returnfield = this.Task.getFieldByValueStr(this._retVal);
+        return this.returnfield;
+    }
+    get IsMainSource() {
+        return this._id === -1;
+    }
+    get Task() {
+        return this._task;
+    }
+    get Fields() {
+        return this._task.DataView.GetFieldsTab().getLinkFields(this._id);
+    }
+    get Id() {
+        return this._id;
+    }
+    get LinkEvaluateCondition() {
+        return this._linkEvalCondition;
+    }
+    constructor(task) {
+        this._cond = null;
+        this._task = null;
+        this.Loc = null;
+        this._dir = '\0';
+        this._id = 0;
+        this._keyIdx = 0;
+        this._retVal = null;
+        this.returnfield = null;
+        this.LinkStartAfterField = 0;
+        this.KeyExpression = 0;
+        this._task = task;
+        this._keyIdx = -1;
+        this._cond = new YesNoExp(true);
+    }
+    SetAttributes(attributes) {
+        let keys = attributes.Keys;
+        keys.forEach((text) => {
+            this.setAttribute(text, attributes.get_Item(text));
+        });
+    }
+    setAttribute(attribute, valueStr) {
+        switch (attribute) {
+            case XMLConstants.MG_ATTR_ID:
+                this._id = XmlParser.getInt(valueStr);
+                break;
+            case ConstInterface.MG_ATTR_KEY:
+                this._keyIdx = XmlParser.getInt(valueStr);
+                break;
+            case ConstInterface.MG_ATTR_KEY_EXP:
+                this.KeyExpression = XmlParser.getInt(valueStr);
+                break;
+            case ConstInterface.MG_ATTR_DIR:
+                this._dir = valueStr[0];
+                break;
+            case ConstInterface.MG_ATTR_COND:
+            case ConstInterface.MG_ATTR_COND_RES:
+                this._cond.setVal(this._task, valueStr);
+                break;
+            case ConstInterface.MG_ATTR_RET_VAL:
+                this._retVal = valueStr;
+                break;
+            case ConstInterface.MG_ATTR_LINK_EVAL_CONDITION:
+                this._linkEvalCondition = valueStr[0];
+                break;
+            case ConstInterface.MG_ATTR_LINK_MODE:
+                this.Mode = valueStr[0];
+                break;
+            case ConstInterface.MG_ATTR_LINK_START:
+                this.LinkStartAfterField = XmlParser.getInt(valueStr);
+                break;
+            default:
+                Logger.Instance.WriteExceptionToLogWithMsg(NString.Format("Unrecognized attribute: '{0}'", attribute));
+                break;
+        }
+    }
+    async getLinkedRecord(curRec) {
+        return Promise.resolve(true);
+    }
+    async InitLinkFields(currRec) {
+        for (let i = 0; i < this.Fields.length; i++) {
+            let field = this.Fields.get_Item(i);
+            let isNull = new RefParam(field.isNull());
+            let result = new RefParam(field.getValue(false));
+            await field.getInitExpVal(result, isNull);
+            currRec.SetFieldValue(field.getId(), isNull.value, result.value);
+            field.invalidate(true, false);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DataviewHeaderBase.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/rt/DataviewHeaderBase.ts"],"names":[],"mappings":"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","sourcesContent":["import {YesNoExp} from '../exp/YesNoExp';\r\nimport {Task} from '../tasks/Task';\r\nimport {Dictionary, List, NString, RefParam} from '@magic-xpa/mscorelib';\r\nimport {Boundary} from './Boundary';\r\nimport {Field} from '../data/Field';\r\nimport {LnkEval_Cond, LnkMode, Logger, XMLConstants, XmlParser} from '@magic-xpa/utils';\r\nimport {FieldsTableExt as FieldsTable} from '../data/FieldsTable';\r\nimport {IRecord} from '@magic-xpa/gui';\r\nimport {Record} from '../data/Record';\r\nimport {ConstInterface} from '../ConstInterface';\r\n\r\n/// <summary>\r\n///   Summary description for Link.\r\n/// </summary>\r\nexport abstract class DataviewHeaderBase {\r\n  _cond: YesNoExp = null;  // will be generated or from the link condition or from the link condition value tag\r\n  _task: Task = null;\r\n  Loc: List<Boundary> = null;\r\n  _dir: string = '\\0';\r\n  _id: number = 0; // the id of the link in the task\r\n  _keyIdx: number = 0; // the key (from the tableCache) that this\r\n\r\n  private _retVal: string = null;\r\n\r\n  /// <summary>\r\n  /// do not use directly\r\n  /// </summary>\r\n  private returnfield: Field = null;\r\n  _linkEvalCondition: LnkEval_Cond;\r\n\r\n  get ReturnField(): Field {\r\n    if (this.returnfield === null && this._retVal !== null)\r\n      this.returnfield = <Field>this.Task.getFieldByValueStr(this._retVal);\r\n    return this.returnfield;\r\n  }\r\n\r\n  /// <summary>\r\n  /// link Mode\r\n  /// </summary>\r\n  Mode: LnkMode;\r\n  LinkStartAfterField: number = 0;\r\n  KeyExpression: number = 0;\r\n\r\n  /// <summary>\r\n  /// true if this link represents Main source\r\n  /// </summary>\r\n  get IsMainSource(): boolean {\r\n    return this._id === -1;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Task\r\n  /// </summary>\r\n  get Task(): Task {\r\n    return this._task;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Fields\r\n  /// </summary>\r\n  get Fields(): List<Field> {\r\n    return (<FieldsTable>this._task.DataView.GetFieldsTab()).getLinkFields(this._id);\r\n  }\r\n\r\n  get Id(): number {\r\n    return this._id;\r\n  }\r\n\r\n  get LinkEvaluateCondition(): LnkEval_Cond {\r\n    return this._linkEvalCondition;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   initialize the link for a given task\r\n  /// </summary>\r\n  constructor(task: Task) {\r\n    this._task = task;\r\n    this._keyIdx = -1;\r\n    this._cond = new YesNoExp(true);\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"attributes\"></param>\r\n  SetAttributes(attributes: Dictionary<string>): void {\r\n    let keys: string[] = attributes.Keys;\r\n    keys.forEach((text: string) => {\r\n      this.setAttribute(text, attributes.get_Item(text));\r\n    });\r\n  }\r\n\r\n  /// <summary>\r\n  ///   parse the link XML tag\r\n  /// </summary>\r\n  /// <param name = \"tokensVector\">the vector of attributes and their values</param>\r\n  protected setAttribute(attribute: string, valueStr: string): void {\r\n    switch (attribute) {\r\n      case XMLConstants.MG_ATTR_ID:\r\n        this._id = XmlParser.getInt(valueStr);\r\n        break;\r\n      case ConstInterface.MG_ATTR_KEY:\r\n        this._keyIdx = XmlParser.getInt(valueStr);\r\n        break;\r\n      case ConstInterface.MG_ATTR_KEY_EXP:\r\n        this.KeyExpression = XmlParser.getInt(valueStr);\r\n        break;\r\n      case ConstInterface.MG_ATTR_DIR:\r\n        this._dir = valueStr[0];\r\n        break;\r\n      case ConstInterface.MG_ATTR_COND:\r\n      case ConstInterface.MG_ATTR_COND_RES:\r\n        this._cond.setVal(this._task, valueStr);\r\n        break;\r\n      case ConstInterface.MG_ATTR_RET_VAL:\r\n        this._retVal = valueStr;\r\n        break;\r\n      case ConstInterface.MG_ATTR_LINK_EVAL_CONDITION:\r\n        this._linkEvalCondition = <LnkEval_Cond>valueStr[0];\r\n        break;\r\n      case ConstInterface.MG_ATTR_LINK_MODE:\r\n        this.Mode = <LnkMode>valueStr[0];\r\n        break;\r\n      case ConstInterface.MG_ATTR_LINK_START:\r\n        this.LinkStartAfterField = XmlParser.getInt(valueStr);\r\n        break;\r\n      default:\r\n        Logger.Instance.WriteExceptionToLogWithMsg(NString.Format(\"Unrecognized attribute: '{0}'\", attribute));\r\n        break;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// update link result\r\n  /// </summary>\r\n  /// <param name=\"curRec\">current record</param>\r\n  /// <param name=\"ret\">link success</param>\r\n  abstract SetReturnValue( ret: boolean, recompute: boolean): void;\r\n\r\n  async getLinkedRecord(curRec: Record): Promise<boolean>{\r\n    return Promise.resolve(true);\r\n  }\r\n\r\n  /// <summary>\r\n  /// initialize link fields\r\n  /// </summary>\r\n  /// <param name=\"currRec\"></param>\r\n  public async InitLinkFields(currRec: IRecord): Promise<void> {\r\n\r\n    // nit the cureent rec fields that belong to the link\r\n\r\n    for (let i: number = 0; i < this.Fields.length; i++) {\r\n      let field: Field = this.Fields.get_Item(i);\r\n\r\n      let isNull: RefParam<boolean> = new RefParam(field.isNull());\r\n      let result: RefParam<string> = new RefParam(field.getValue(false));\r\n      await field.getInitExpVal(result, isNull);\r\n      // this function knows to take either the null value or the defualt value\r\n      (<Record>currRec).SetFieldValue(field.getId(), isNull.value, result.value);\r\n      field.invalidate(true, false);\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2020/src/rt/DataviewHeaderFactory.mjs

@@ -0,0 +1,7 @@
+import { RemoteDataviewHeader } from "./RemoteDataviewHeader";
+export class DataviewHeaderFactory {
+    CreateDataviewHeaders(task) {
+        return new RemoteDataviewHeader(task);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRGF0YXZpZXdIZWFkZXJGYWN0b3J5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZW5naW5lL3NyYy9ydC9EYXRhdmlld0hlYWRlckZhY3RvcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFDLG9CQUFvQixFQUFDLE1BQU0sd0JBQXdCLENBQUM7QUFNNUQsTUFBTSxPQUFPLHFCQUFxQjtJQUNoQyxxQkFBcUIsQ0FBQyxJQUFVO1FBQzlCLE9BQU8sSUFBSSxvQkFBb0IsQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUN4QyxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0RhdGF2aWV3SGVhZGVyQmFzZX0gZnJvbSBcIi4vRGF0YXZpZXdIZWFkZXJCYXNlXCI7XHJcbmltcG9ydCB7UmVtb3RlRGF0YXZpZXdIZWFkZXJ9IGZyb20gXCIuL1JlbW90ZURhdGF2aWV3SGVhZGVyXCI7XHJcbmltcG9ydCB7VGFza30gZnJvbSBcIi4uL3Rhc2tzL1Rhc2tcIjtcclxuXHJcbi8vLyA8c3VtbWFyeT5cclxuLy8vIGxpbmsgZmFjdG9yeVxyXG4vLy8gPC9zdW1tYXJ5PlxyXG5leHBvcnQgY2xhc3MgRGF0YXZpZXdIZWFkZXJGYWN0b3J5IHtcclxuICBDcmVhdGVEYXRhdmlld0hlYWRlcnModGFzazogVGFzayk6IERhdGF2aWV3SGVhZGVyQmFzZSB7XHJcbiAgICByZXR1cm4gbmV3IFJlbW90ZURhdGF2aWV3SGVhZGVyKHRhc2spO1xyXG4gIH1cclxufVxyXG4iXX0=

package/esm2020/src/rt/DataviewHeaders.mjs

@@ -0,0 +1,53 @@
+import { Hashtable, StringBuilder } from "@magic-xpa/mscorelib";
+import { Logger, XMLConstants, XmlParser } from "@magic-xpa/utils";
+import { DataviewHeadersSaxHandler } from "./DataviewHeadersSaxHandler";
+import { RemoteDataviewHeader } from "./RemoteDataviewHeader";
+import { ConstInterface } from "../ConstInterface";
+export class DataviewHeaders {
+    constructor(task) {
+        this._dataviewHeaders = null;
+        this._task = null;
+        this._task = task;
+        this._dataviewHeaders = new Hashtable();
+    }
+    fillData(parser) {
+        while (this.initInnerObjects(parser, parser.getNextTag())) {
+        }
+    }
+    initInnerObjects(parser, foundTagName) {
+        if (foundTagName === null)
+            return false;
+        if (foundTagName === ConstInterface.MG_TAG_LINKS) {
+            let endContext = parser.getXMLdata().indexOf(ConstInterface.MG_TAG_LINKS_END, parser.getCurrIndex()) + ConstInterface.MG_TAG_LINKS_END.length + 1;
+            let xml = parser.getXMLsubstring(endContext);
+            xml = XmlParser.escapeUrl(xml);
+            new DataviewHeadersSaxHandler(this._task, this._dataviewHeaders, xml);
+            parser.setCurrIndex(endContext + XMLConstants.TAG_CLOSE.length);
+        }
+        else
+            Logger.Instance.WriteExceptionToLogWithMsg("There is no such tag in LinksTable.initInnerObjects(): " + foundTagName);
+    }
+    getDataviewHeaderById(linkId) {
+        return this._dataviewHeaders.get_Item(linkId);
+    }
+    buildDbPosString() {
+        if (this._dataviewHeaders.Count === 0) {
+            return null;
+        }
+        let buf = new StringBuilder();
+        let dataviewHeaders = this._dataviewHeaders.Values;
+        while (dataviewHeaders.MoveNext()) {
+            let curr = ((dataviewHeaders.Current instanceof RemoteDataviewHeader) ? dataviewHeaders.Current : null);
+            if (curr !== null) {
+                let currDbPosVal = curr.getLastFetchedDbPos();
+                buf.Append("@");
+                if (currDbPosVal !== null) {
+                    buf.Append(currDbPosVal);
+                }
+            }
+        }
+        buf.Append("@");
+        return buf.ToString();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/rt/DataviewHeadersSaxHandler.mjs

@@ -0,0 +1,38 @@
+import { Dictionary, isNullOrUndefined } from "@magic-xpa/mscorelib";
+import { JSON_Utils } from "@magic-xpa/utils";
+import { DataviewHeaderFactory } from "./DataviewHeaderFactory";
+import { ConstInterface } from "../ConstInterface";
+export class DataviewHeadersSaxHandler {
+    constructor(task, dataviewHeaders, xmlData) {
+        this._dataviewHeaders = null;
+        this._task = null;
+        this._dataviewHeadersFactory = null;
+        this._dataviewHeaders = dataviewHeaders;
+        this._task = task;
+        this._dataviewHeadersFactory = new DataviewHeaderFactory();
+        JSON_Utils.JSONFromXML(xmlData, this.FillFromJSON.bind(this));
+    }
+    FillFromJSON(error, result) {
+        if (error != null) {
+            throw error;
+        }
+        let links = result[ConstInterface.MG_TAG_LINKS][ConstInterface.MG_TAG_LINK];
+        if (!isNullOrUndefined(links) && links.constructor === Array) {
+            for (let i = 0; i < links.length; i++) {
+                let link = links[i]['$'];
+                if (!isNullOrUndefined(link[ConstInterface.MG_ATTR_TABLE_INDEX])) {
+                    let dataviewHeader = this._dataviewHeadersFactory.CreateDataviewHeaders(this._task);
+                    let attributes = new Dictionary();
+                    for (let key in link) {
+                        if (key !== ConstInterface.MG_ATTR_TABLE_INDEX) {
+                            attributes.Add(key, link[key]);
+                        }
+                    }
+                    dataviewHeader.SetAttributes(attributes);
+                    this._dataviewHeaders.set_Item(dataviewHeader.Id, dataviewHeader);
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/rt/ExecutionStack.mjs

@@ -0,0 +1,94 @@
+import { NNumber, Stack, StringBuilder } from "@magic-xpa/mscorelib";
+import { ExecutionStackEntry } from "./ExecutionStackEntry";
+import { ConstInterface } from "../ConstInterface";
+import { XMLConstants } from "@magic-xpa/utils";
+export class ExecutionStack {
+    constructor(inExecStack) {
+        this._execStack = null;
+        if (arguments.length === 0) {
+            this.constructor_0();
+            return;
+        }
+        this.constructor_1(inExecStack);
+    }
+    constructor_0() {
+        this._execStack = new Stack();
+    }
+    constructor_1(inExecStack) {
+        this._execStack = inExecStack.getStack().Clone();
+    }
+    getStack() {
+        return this._execStack;
+    }
+    push(execEntryOrTaskId, handlerId, operIdx) {
+        if (arguments.length === 1)
+            this.push_0(execEntryOrTaskId);
+        else
+            this.push_1(execEntryOrTaskId, handlerId, operIdx);
+    }
+    push_0(execEntry) {
+        this._execStack.push(execEntry);
+    }
+    push_1(taskId, handlerId, operIdx) {
+        let execEntry = new ExecutionStackEntry(taskId, handlerId, operIdx);
+        this._execStack.push(execEntry);
+    }
+    pop() {
+        return this._execStack.pop();
+    }
+    empty() {
+        return this._execStack.count() === 0;
+    }
+    clear() {
+        this._execStack.Clear();
+    }
+    size() {
+        return this._execStack.count();
+    }
+    Equals(execStackCmp) {
+        let tmpExecStack = new ExecutionStack(this);
+        let tmpExecStackCmp = new ExecutionStack(execStackCmp);
+        let equalStacks = false;
+        if (tmpExecStack.size() === tmpExecStackCmp.size()) {
+            equalStacks = true;
+            while (!tmpExecStack.empty() && equalStacks) {
+                if (!tmpExecStack.pop().Equals(tmpExecStackCmp.pop()))
+                    equalStacks = false;
+            }
+        }
+        return equalStacks;
+    }
+    pushUpSideDown(inExecStack) {
+        let tmpStack = new ExecutionStack(inExecStack);
+        while (!tmpStack.empty()) {
+            let tmpStackEntry = tmpStack.pop();
+            this._execStack.push(tmpStackEntry);
+        }
+    }
+    reverse() {
+        let tmpExecStack = new ExecutionStack(this);
+        this.clear();
+        while (!tmpExecStack.empty()) {
+            let tmpExecStackEntry = tmpExecStack.pop();
+            this.push(tmpExecStackEntry);
+        }
+    }
+    buildXML(message) {
+        let forMessage = new StringBuilder();
+        while (this._execStack.count() !== 0) {
+            let ExecEntry = this._execStack.pop();
+            let taskTag = NNumber.Parse(ExecEntry.TaskId);
+            if (taskTag > ConstInterface.INITIAL_OFFLINE_TASK_TAG) {
+                forMessage.Remove(0, forMessage.Length);
+                continue;
+            }
+            forMessage.Append("\n " + XMLConstants.TAG_OPEN + ConstInterface.MG_TAG_EXEC_STACK_ENTRY);
+            forMessage.Append(" " + XMLConstants.MG_ATTR_TASKID + "=\"" + ExecEntry.TaskId + "\"");
+            forMessage.Append(" " + ConstInterface.MG_ATTR_HANDLERID + "=\"" + ExecEntry.HandlerId + "\"");
+            forMessage.Append(" " + ConstInterface.MG_ATTR_OPER_IDX + "=\"" + ExecEntry.OperIdx + "\"");
+            forMessage.Append(" " + XMLConstants.TAG_TERM);
+        }
+        message.Append(forMessage.ToString());
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ExecutionStack.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/rt/ExecutionStack.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAAE,KAAK,EAAE,aAAa,EAAC,MAAM,sBAAsB,CAAC;AACnE,OAAO,EAAC,mBAAmB,EAAC,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAC,YAAY,EAAC,MAAM,kBAAkB,CAAC;AAK9C,MAAM,OAAO,cAAc;IAKzB,YAAY,WAA4B;QAJhC,eAAU,GAA+B,IAAI,CAAC;QAKpD,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE;YAC1B,IAAI,CAAC,aAAa,EAAE,CAAC;YACrB,OAAO;SACR;QACD,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC;IAClC,CAAC;IAGO,aAAa;QACnB,IAAI,CAAC,UAAU,GAAG,IAAI,KAAK,EAAE,CAAC;IAChC,CAAC;IAIO,aAAa,CAAC,WAA2B;QAC/C,IAAI,CAAC,UAAU,GAAG,WAAW,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC;IACnD,CAAC;IAID,QAAQ;QACN,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAID,IAAI,CAAC,iBAAsB,EAAE,SAAkB,EAAE,OAAgB;QAC/D,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC;YACxB,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC;;YAE/B,IAAI,CAAC,MAAM,CAAC,iBAAiB,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;IACvD,CAAC;IAIO,MAAM,CAAC,SAA8B;QAC3C,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAClC,CAAC;IAMO,MAAM,CAAC,MAAc,EAAE,SAAiB,EAAE,OAAe;QAC/D,IAAI,SAAS,GAAwB,IAAI,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;QACzF,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAClC,CAAC;IAKD,GAAG;QACD,OAA4B,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC;IACpD,CAAC;IAKD,KAAK;QACH,OAAO,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACvC,CAAC;IAGD,KAAK;QACH,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;IAC1B,CAAC;IAID,IAAI;QACF,OAAO,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;IACjC,CAAC;IAKD,MAAM,CAAC,YAAiB;QACtB,IAAI,YAAY,GAAmB,IAAI,cAAc,CAAC,IAAI,CAAC,CAAC;QAC5D,IAAI,eAAe,GAAmB,IAAI,cAAc,CAAiB,YAAY,CAAC,CAAC;QACvF,IAAI,WAAW,GAAY,KAAK,CAAC;QAEjC,IAAI,YAAY,CAAC,IAAI,EAAE,KAAK,eAAe,CAAC,IAAI,EAAE,EAAE;YAClD,WAAW,GAAG,IAAI,CAAC;YACnB,OAAO,CAAC,YAAY,CAAC,KAAK,EAAE,IAAI,WAAW,EAAE;gBAC3C,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE,CAAC;oBACnD,WAAW,GAAG,KAAK,CAAC;aACvB;SACF;QACD,OAAO,WAAW,CAAC;IACrB,CAAC;IAID,cAAc,CAAC,WAA2B;QACxC,IAAI,QAAQ,GAAmB,IAAI,cAAc,CAAC,WAAW,CAAC,CAAC;QAE/D,OAAO,CAAC,QAAQ,CAAC,KAAK,EAAE,EAAE;YACxB,IAAI,aAAa,GAAwB,QAAQ,CAAC,GAAG,EAAE,CAAC;YACxD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;SACrC;IACH,CAAC;IAGD,OAAO;QACL,IAAI,YAAY,GAAmB,IAAI,cAAc,CAAC,IAAI,CAAC,CAAC;QAE5D,IAAI,CAAC,KAAK,EAAE,CAAC;QAEb,OAAO,CAAC,YAAY,CAAC,KAAK,EAAE,EAAE;YAC5B,IAAI,iBAAiB,GAAwB,YAAY,CAAC,GAAG,EAAE,CAAC;YAChE,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;SAC9B;IACH,CAAC;IAKM,QAAQ,CAAC,OAAsB;QACpC,IAAI,UAAU,GAAkB,IAAI,aAAa,EAAE,CAAC;QACpD,OAAO,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE;YACpC,IAAI,SAAS,GAAwB,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC;YAE3D,IAAI,OAAO,GAAW,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;YACtD,IAAI,OAAO,GAAG,cAAc,CAAC,wBAAwB,EAAE;gBAErD,UAAU,CAAC,MAAM,CAAC,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,CAAC;gBACxC,SAAS;aACV;YACD,UAAU,CAAC,MAAM,CAAC,KAAK,GAAG,YAAY,CAAC,QAAQ,GAAG,cAAc,CAAC,uBAAuB,CAAC,CAAC;YAC1F,UAAU,CAAC,MAAM,CAAC,GAAG,GAAG,YAAY,CAAC,cAAc,GAAG,KAAK,GAAG,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;YACvF,UAAU,CAAC,MAAM,CAAC,GAAG,GAAG,cAAc,CAAC,iBAAiB,GAAG,KAAK,GAAG,SAAS,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC;YAC/F,UAAU,CAAC,MAAM,CAAC,GAAG,GAAG,cAAc,CAAC,gBAAgB,GAAG,KAAK,GAAG,SAAS,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC;YAC5F,UAAU,CAAC,MAAM,CAAC,GAAG,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAC;SAChD;QACD,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC,CAAC;IACxC,CAAC;CACF","sourcesContent":["import {NNumber, Stack, StringBuilder} from \"@magic-xpa/mscorelib\";\r\nimport {ExecutionStackEntry} from \"./ExecutionStackEntry\";\r\nimport {ConstInterface} from \"../ConstInterface\";\r\nimport {XMLConstants} from \"@magic-xpa/utils\";\r\n\r\n/// <summary> this class represents an execution stack of all operations that can be interupted by going to the server\r\n/// to continue execution (raise event or any call to user defined function)\r\n/// </summary>\r\nexport class ExecutionStack {\r\n  private _execStack: Stack<ExecutionStackEntry> = null;\r\n\r\n  constructor();\r\n  constructor(inExecStack: ExecutionStack);\r\n  constructor(inExecStack?: ExecutionStack) {\r\n    if (arguments.length === 0) {\r\n      this.constructor_0();\r\n      return;\r\n    }\r\n    this.constructor_1(inExecStack);\r\n  }\r\n\r\n  /// <summary> default constructor</summary>\r\n  private constructor_0(): void {\r\n    this._execStack = new Stack();\r\n  }\r\n\r\n  /// <summary> constructor which copies the parameter execution stack</summary>\r\n  /// <param name=\"inExecStack\">- the execution stack to copy </param>\r\n  private constructor_1(inExecStack: ExecutionStack): void {\r\n    this._execStack = inExecStack.getStack().Clone();\r\n  }\r\n\r\n  /// <summary> getter for the execution stack itself</summary>\r\n  /// <returns> the stack </returns>\r\n  getStack(): Stack<ExecutionStackEntry> {\r\n    return this._execStack;\r\n  }\r\n\r\n  push(execEntry: ExecutionStackEntry): void;\r\n  push(taskId: string, handlerId: string, operIdx: number): void;\r\n  push(execEntryOrTaskId: any, handlerId?: string, operIdx?: number): void {\r\n    if (arguments.length === 1)\r\n      this.push_0(execEntryOrTaskId);\r\n    else\r\n      this.push_1(execEntryOrTaskId, handlerId, operIdx);\r\n  }\r\n\r\n  /// <summary> pushes one entry into the stack</summary>\r\n  /// <param name=\"execEntry\">- to be pushed </param>\r\n  private push_0(execEntry: ExecutionStackEntry): void {\r\n    this._execStack.push(execEntry);\r\n  }\r\n\r\n  /// <summary> pushes an entry to the execution stack constructed by its 3 elements which are recieved as parameters</summary>\r\n  /// <param name=\"taskId\"> </param>\r\n  /// <param name=\"handlerId\"> </param>\r\n  /// <param name=\"operIdx\"> </param>\r\n  private push_1(taskId: string, handlerId: string, operIdx: number): void {\r\n    let execEntry: ExecutionStackEntry = new ExecutionStackEntry(taskId, handlerId, operIdx);\r\n    this._execStack.push(execEntry);\r\n  }\r\n\r\n  /// <summary> pops an entry from the execution stack</summary>\r\n  /// <returns> the popped entry\r\n  /// </returns>\r\n  pop(): ExecutionStackEntry {\r\n    return <ExecutionStackEntry>this._execStack.pop();\r\n  }\r\n\r\n  /// <summary> check if the execution stack is empty </summary>\r\n  /// <returns> an indication if it's empty or not\r\n  /// </returns>\r\n  empty(): boolean {\r\n    return this._execStack.count() === 0;\r\n  }\r\n\r\n  /// <summary> clears the execution stack</summary>\r\n  clear(): void {\r\n    this._execStack.Clear();\r\n  }\r\n\r\n  /// <returns> the size of the execution stack\r\n  /// </returns>\r\n  size(): number {\r\n    return this._execStack.count();\r\n  }\r\n\r\n  /// <summary> checks if two execution stacks are equal</summary>\r\n  /// <param name=\"execStackCmp\">- execution stack to compare to the current </param>\r\n  /// <returns>s an indication whether the two are equal or not </returns>\r\n  Equals(execStackCmp: any): boolean {\r\n    let tmpExecStack: ExecutionStack = new ExecutionStack(this);\r\n    let tmpExecStackCmp: ExecutionStack = new ExecutionStack(<ExecutionStack>execStackCmp);\r\n    let equalStacks: boolean = false;\r\n\r\n    if (tmpExecStack.size() === tmpExecStackCmp.size()) {\r\n      equalStacks = true;\r\n      while (!tmpExecStack.empty() && equalStacks) {\r\n        if (!tmpExecStack.pop().Equals(tmpExecStackCmp.pop()))\r\n          equalStacks = false;\r\n      }\r\n    }\r\n    return equalStacks;\r\n  }\r\n\r\n  /// <summary> push into the current execution stack the execution stack that we get as parameter, but in reverse order</summary>\r\n  /// <param name=\"inExecStack\">- the execution stack to be pushed </param>\r\n  pushUpSideDown(inExecStack: ExecutionStack): void {\r\n    let tmpStack: ExecutionStack = new ExecutionStack(inExecStack);\r\n\r\n    while (!tmpStack.empty()) {\r\n      let tmpStackEntry: ExecutionStackEntry = tmpStack.pop();\r\n      this._execStack.push(tmpStackEntry);\r\n    }\r\n  }\r\n\r\n  /// <summary> reverse the order of the entries in the current execution stack</summary>\r\n  reverse(): void {\r\n    let tmpExecStack: ExecutionStack = new ExecutionStack(this);\r\n\r\n    this.clear();\r\n\r\n    while (!tmpExecStack.empty()) {\r\n      let tmpExecStackEntry: ExecutionStackEntry = tmpExecStack.pop();\r\n      this.push(tmpExecStackEntry);\r\n    }\r\n  }\r\n\r\n  /// <summary> builds the xml of the current execution stack to be sent to the server</summary>\r\n  /// <param name=\"Message\">- the message which the xml needs to be appended to\r\n  /// </param>\r\n  public buildXML(message: StringBuilder): void {\r\n    let forMessage: StringBuilder = new StringBuilder();\r\n    while (this._execStack.count() !== 0) {\r\n      let ExecEntry = <ExecutionStackEntry>this._execStack.pop();\r\n      // offline tasks, and all tasks before them, should not be passed to the server\r\n      let taskTag: number = NNumber.Parse(ExecEntry.TaskId);\r\n      if (taskTag > ConstInterface.INITIAL_OFFLINE_TASK_TAG) {\r\n        // clean the buffer and continue with the next task\r\n        forMessage.Remove(0, forMessage.Length);\r\n        continue;\r\n      }\r\n      forMessage.Append(\"\\n \" + XMLConstants.TAG_OPEN + ConstInterface.MG_TAG_EXEC_STACK_ENTRY);\r\n      forMessage.Append(\" \" + XMLConstants.MG_ATTR_TASKID + \"=\\\"\" + ExecEntry.TaskId + \"\\\"\");\r\n      forMessage.Append(\" \" + ConstInterface.MG_ATTR_HANDLERID + \"=\\\"\" + ExecEntry.HandlerId + \"\\\"\");\r\n      forMessage.Append(\" \" + ConstInterface.MG_ATTR_OPER_IDX + \"=\\\"\" + ExecEntry.OperIdx + \"\\\"\");\r\n      forMessage.Append(\" \" + XMLConstants.TAG_TERM);\r\n    }\r\n    message.Append(forMessage.ToString());\r\n  }\r\n}\r\n"]}

package/esm2020/src/rt/ExecutionStackEntry.mjs

@@ -0,0 +1,17 @@
+export class ExecutionStackEntry {
+    constructor(intaskId, inhandlerId, inoperIdx) {
+        this.TaskId = null;
+        this.HandlerId = null;
+        this.OperIdx = 0;
+        this.TaskId = intaskId;
+        this.HandlerId = inhandlerId;
+        this.OperIdx = inoperIdx;
+    }
+    Equals(obj) {
+        let executionStackEntry = ((obj instanceof ExecutionStackEntry) ? obj : null);
+        return executionStackEntry !== null &&
+            executionStackEntry.HandlerId === this.HandlerId && executionStackEntry.TaskId === this.TaskId &&
+            executionStackEntry.OperIdx === this.OperIdx;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/rt/HandlersTable.mjs

@@ -0,0 +1,96 @@
+import { List } from "@magic-xpa/mscorelib";
+import { Logger, XMLConstants } from "@magic-xpa/utils";
+import { EventHandler } from "../event/EventHandler";
+import { GUIManager } from "../GUIManager";
+import { ConstInterface } from "../ConstInterface";
+export class HandlersTable {
+    constructor() {
+        this._handlers = null;
+        this._handlers = new List();
+    }
+    fillData(taskRef, parser) {
+        while (this.initInnerObjects(parser, parser.getNextTag(), taskRef)) {
+        }
+    }
+    initInnerObjects(parser, foundTagName, taskRef) {
+        if (foundTagName === null)
+            return false;
+        if (foundTagName === ConstInterface.MG_TAG_EVENTHANDLERS) {
+            parser.setCurrIndex(parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()) + 1);
+        }
+        else {
+            if (foundTagName === ConstInterface.MG_TAG_HANDLER) {
+                let eventHandler = new EventHandler();
+                eventHandler.fillData(taskRef, parser);
+                this._handlers.push(eventHandler);
+            }
+            else {
+                if (foundTagName === '/' + ConstInterface.MG_TAG_EVENTHANDLERS) {
+                    parser.setCurrIndex2EndOfTag();
+                    return false;
+                }
+                Logger.Instance.WriteExceptionToLogWithMsg("There is no such tag in HandlersTable. Insert else if to HandlersTable.initInnerObjects for " + foundTagName);
+                return false;
+            }
+        }
+        return true;
+    }
+    add(handler) {
+        this._handlers.push(handler);
+    }
+    remove(idx) {
+        this._handlers.RemoveAt(idx);
+    }
+    insertAfter(handler, idx) {
+        this._handlers.Insert(idx, handler);
+    }
+    getSize() {
+        return this._handlers.length;
+    }
+    getHandler(idx) {
+        if (idx < 0 || idx >= this._handlers.length)
+            return null;
+        return this._handlers.get_Item(idx);
+    }
+    hasExpressionHandler() {
+        let found = false;
+        for (let i = 0; i < this._handlers.length; i++) {
+            let evt = this.getHandler(i).getEvent();
+            if (evt.getType() === ConstInterface.EVENT_TYPE_EXPRESSION ||
+                (evt.getType() === ConstInterface.EVENT_TYPE_USER && evt.getUserEventType() === ConstInterface.EVENT_TYPE_EXPRESSION))
+                return true;
+        }
+        return found;
+    }
+    startTimers(mgd) {
+        let guiManager = GUIManager.Instance;
+        if (this._handlers !== null) {
+            let timersVector = this.getTimersVector();
+            for (let i = 0; i < timersVector.length; i++)
+                guiManager.startTimer(mgd, timersVector.get_Item(i), false);
+        }
+    }
+    getTimersVector() {
+        let timers = new List();
+        for (let i = 0; i < this._handlers.length; i++) {
+            let timerEvt = this.getHandler(i).getEvent();
+            let sec;
+            if (timerEvt.getType() === ConstInterface.EVENT_TYPE_TIMER)
+                sec = timerEvt.getSeconds();
+            else
+                sec = timerEvt.getSecondsOfUserEvent();
+            let timerExists = false;
+            for (let j = 0; j < timers.length; j++) {
+                if (sec === timers.get_Item(j)) {
+                    timerExists = true;
+                    break;
+                }
+            }
+            if (!timerExists) {
+                timers.push(sec);
+            }
+        }
+        return timers;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"HandlersTable.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/rt/HandlersTable.ts"],"names":[],"mappings":"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","sourcesContent":["import {List} from \"@magic-xpa/mscorelib\";\r\nimport {Logger, XMLConstants, XmlParser} from \"@magic-xpa/utils\";\r\nimport {Event} from \"../event/Event\";\r\nimport {EventHandler} from \"../event/EventHandler\";\r\nimport {Task} from \"../tasks/Task\";\r\nimport {MGData} from \"../tasks/MGData\";\r\nimport {GUIManager} from \"../GUIManager\";\r\nimport {ConstInterface} from \"../ConstInterface\";\r\n\r\n///   the handlers table\r\nexport class HandlersTable {\r\n  private _handlers: List<EventHandler> = null;\r\n\r\n  constructor() {\r\n    this._handlers = new List<EventHandler>();\r\n  }\r\n\r\n  ///   parse the handlers of a task\r\n  fillData(taskRef: Task, parser: XmlParser): void {\r\n    while (this.initInnerObjects(parser, parser.getNextTag(), taskRef)) {\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   To allocate and fill inner objects of the class\r\n  /// </summary>\r\n  /// <param name = \"foundTagName\">name of tag, of oject, which need be allocated </param>\r\n  private initInnerObjects(parser: XmlParser, foundTagName: string, taskRef: Task): boolean {\r\n    if (foundTagName === null)\r\n      return false;\r\n\r\n    if (foundTagName === ConstInterface.MG_TAG_EVENTHANDLERS) {\r\n      parser.setCurrIndex(parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()) + 1);\r\n    }\r\n    else {\r\n      if (foundTagName === ConstInterface.MG_TAG_HANDLER) {\r\n        let eventHandler: EventHandler = new EventHandler();\r\n        eventHandler.fillData(taskRef, parser);\r\n        this._handlers.push(eventHandler);\r\n      }\r\n      else {\r\n        if (foundTagName === '/' + ConstInterface.MG_TAG_EVENTHANDLERS) {\r\n          parser.setCurrIndex2EndOfTag();\r\n          return false;\r\n        }\r\n\r\n        Logger.Instance.WriteExceptionToLogWithMsg(\"There is no such tag in HandlersTable. Insert else if to HandlersTable.initInnerObjects for \" + foundTagName);\r\n        return false;\r\n      }\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   add a new event handler to the table\r\n  /// </summary>\r\n  /// <param name = \"handler\">the new event handler </param>\r\n  add(handler: EventHandler): void {\r\n    this._handlers.push(handler);\r\n  }\r\n\r\n\r\n\r\n  /// <summary>\r\n  ///   removes the handler at idx place\r\n  /// </summary>\r\n  /// <param name = \"idx\"> </param>\r\n  remove(idx: number): void {\r\n    this._handlers.RemoveAt(idx);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   insert a new event handler to the table after the idx's element\r\n  /// </summary>\r\n  /// <param name = \"handler\">the new event handler </param>\r\n  /// <param name = \"idx\">index of the element to add the new element after </param>\r\n  insertAfter(handler: EventHandler, idx: number): void {\r\n    this._handlers.Insert(idx, handler);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the number of handlers in the table\r\n  /// </summary>\r\n  getSize(): number {\r\n    return this._handlers.length;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get a handler by its index\r\n  /// </summary>\r\n  /// <param name = \"idx\">the index of the handler in the table </param>\r\n  getHandler(idx: number): EventHandler {\r\n    if (idx < 0 || idx >= this._handlers.length)\r\n      return null;\r\n\r\n    return this._handlers.get_Item(idx);\r\n  }\r\n\r\n  hasExpressionHandler(): boolean  {\r\n    let found: boolean = false;\r\n    for (let i: number = 0; i < this._handlers.length; i++) {\r\n      let evt: Event = this.getHandler(i).getEvent();\r\n      if (evt.getType() === ConstInterface.EVENT_TYPE_EXPRESSION ||\r\n        (evt.getType() === ConstInterface.EVENT_TYPE_USER && evt.getUserEventType() === ConstInterface.EVENT_TYPE_EXPRESSION))\r\n        return true;\r\n    }\r\n    return found;\r\n  }\r\n  \r\n  /// <summary>\r\n  ///   start timers for timer events\r\n  /// </summary>\r\n  startTimers(mgd: MGData): void {\r\n    let guiManager: GUIManager = GUIManager.Instance;\r\n    if (this._handlers !== null) {\r\n      let timersVector: List<number> = this.getTimersVector();\r\n      for (let i: number = 0; i < timersVector.length; i++)\r\n        guiManager.startTimer(mgd, timersVector.get_Item(i), false);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Returns a list of the number of seconds for each timer\r\n  ///   If there is more than one timer handler with the same number of seconds\r\n  ///   this number will appear in the list only once.\r\n  /// </summary>\r\n  getTimersVector(): List<number> {\r\n    let timers: List<number> = new List<number>();\r\n\r\n    // scan the timers\r\n    for (let i: number = 0; i < this._handlers.length; i++) {\r\n      let timerEvt: Event = this.getHandler(i).getEvent();\r\n      let sec: number;\r\n      if (timerEvt.getType() === ConstInterface.EVENT_TYPE_TIMER)\r\n        sec = timerEvt.getSeconds();\r\n      else // EVENT_TYPE_USER\r\n        sec = timerEvt.getSecondsOfUserEvent();\r\n      let timerExists: boolean = false;\r\n      for (let j: number = 0; j < timers.length; j++) {\r\n        if (sec === timers.get_Item(j)) {\r\n          timerExists = true;\r\n          break;\r\n        }\r\n      }\r\n      if (!timerExists) {\r\n        timers.push(sec);\r\n      }\r\n    }\r\n    return timers;\r\n  }\r\n}\r\n"]}

package/esm2020/src/rt/IDataSourceViewDefinition.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSURhdGFTb3VyY2VWaWV3RGVmaW5pdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2VuZ2luZS9zcmMvcnQvSURhdGFTb3VyY2VWaWV3RGVmaW5pdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtPcmRlcn0gZnJvbSBcIkBtYWdpYy14cGEvdXRpbHNcIjtcclxuXHJcbi8vLyA8c3VtbWFyeT5cclxuLy8vIERlZmluaXRpb24gb2YgYSB2aWV3IG9uIGEgZGF0YSBzb3VyY2UuIFRoaXMgaW5mb3JtYXRpb24gaXMgdXNlZFxyXG4vLy8gd2hlbiBjcmVhdGluZyB0aGUgYWN0dWFsIHZpZXcuXHJcbi8vLyA8L3N1bW1hcnk+XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIElEYXRhU291cmNlVmlld0RlZmluaXRpb24ge1xyXG4gIC8vLyA8c3VtbWFyeT5cclxuICAvLy8gR2V0cyB0aGUgb3JkZXIgb2YgcmV0cmlldmluZyByZWNvcmRzIGZyb20gdGhlIGRhdGFiYXNlLlxyXG4gIC8vLyA8L3N1bW1hcnk+XHJcbiAgUmVjb3Jkc09yZGVyOiBPcmRlcjtcclxuXHJcbiAgLy8vIDxzdW1tYXJ5PlxyXG4gIC8vLyBHZXRzIGEgdmFsdWUgZGVub3Rpbmcgd2hldGhlciB0aGUgdmlldyB3aWxsIGJlIGFibGUgdG8gaW5zZXJ0IG5ld1xyXG4gIC8vLyByZWNvcmRzIHRvIHRoZSBkYXRhYmFzZS5cclxuICAvLy8gPC9zdW1tYXJ5PlxyXG4gIENhbkluc2VydDogYm9vbGVhbjtcclxuXHJcbiAgLy8vIDxzdW1tYXJ5PlxyXG4gIC8vLyBHZXRzIGEgdmFsdWUgZGVub3Rpbmcgd2hldGhlciB0aGUgdmlldyB3aWxsIGJlIGFibGUgdG8gZGVsZXRlIHJlY29yZHNcclxuICAvLy8gZnJvbSB0aGUgZGF0YWJhc2UuXHJcbiAgLy8vIDwvc3VtbWFyeT5cclxuICBDYW5EZWxldGU6IGJvb2xlYW47XHJcblxyXG59XHJcbiJdfQ==

package/esm2020/src/rt/IDataviewHeader.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/rt/IResultValue.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSVJlc3VsdFZhbHVlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZW5naW5lL3NyYy9ydC9JUmVzdWx0VmFsdWUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7U3RvcmFnZUF0dHJpYnV0ZX0gZnJvbSBcIkBtYWdpYy14cGEvdXRpbHNcIjtcclxuXHJcbi8vLyA8c3VtbWFyeT5cclxuLy8vIEludGVyZmFjZSBmb3Igc2V0dGluZyBSZXN1bHQgVmFsdWUuXHJcbi8vLyA8L3N1bW1hcnk+XHJcbmV4cG9ydCBpbnRlcmZhY2UgSVJlc3VsdFZhbHVlIHtcclxuICAvLy8gPHN1bW1hcnk+XHJcbiAgLy8vIHNldCB0aGUgcmVzdWx0IHZhbHVlIGFuZCBpdCdzIHR5cGUuXHJcbiAgLy8vIDwvc3VtbWFyeT5cclxuICAvLy8gPHBhcmFtIG5hbWU9XCJleHBcIj48L3BhcmFtPlxyXG4gIFNldFJlc3VsdFZhbHVlKHJlc3VsdDogc3RyaW5nLCB0eXBlOiBTdG9yYWdlQXR0cmlidXRlKTogdm9pZDtcclxufVxyXG4iXX0=