@magic-xpa/engine 4.1100.0-dev4110.20 → 4.1100.0-dev4110.202

package/esm2022/src/tasks/TaskBase.mjs

@@ -0,0 +1,83 @@
+import { GuiTaskBase } from '@magic-xpa/gui';
+export var Task_SubformExecModeEnum;
+(function (Task_SubformExecModeEnum) {
+    Task_SubformExecModeEnum[Task_SubformExecModeEnum["NO_SUBFORM"] = -1] = "NO_SUBFORM";
+    Task_SubformExecModeEnum[Task_SubformExecModeEnum["SET_FOCUS"] = 0] = "SET_FOCUS";
+    Task_SubformExecModeEnum[Task_SubformExecModeEnum["FIRST_TIME"] = 1] = "FIRST_TIME";
+    Task_SubformExecModeEnum[Task_SubformExecModeEnum["REFRESH"] = 2] = "REFRESH";
+})(Task_SubformExecModeEnum || (Task_SubformExecModeEnum = {}));
+export class TaskBase extends GuiTaskBase {
+    IsTryingToStop = false;
+    DoSubformPrefixSuffix = false;
+    IsAfterRetryBeforeBuildXML = false;
+    TaskSuffixExecuted = false;
+    DataviewManager = null;
+    IsOffline = false;
+    ResetRange = false;
+    UserRngs = null;
+    ResetLocate = false;
+    UserLocs = null;
+    ResetSort = false;
+    UserSorts = null;
+    PreviouslyActiveTaskId;
+    _transactionFailed = false;
+    InEndTask = false;
+    InCtrlPrefix = false;
+    RetainFocus = false;
+    SubformExecMode = 0;
+    TransactionErrorHandlingsRetry = null;
+    ClosingFormUI = false;
+    AfterFirstRecordPrefix = false;
+    static ShouldNonInteractiveBeModal() {
+        return true;
+    }
+    async isCached() {
+        return Promise.resolve(true);
+    }
+    async prepareCache(ignoreCurr) {
+        return Promise.resolve(true);
+    }
+    async testAndSet(ignoreCurr) {
+        return Promise.resolve(true);
+    }
+    async SubformRefresh(subformTask, explicitSubformRefresh) {
+        return Promise.resolve();
+    }
+    async stop() {
+        return Promise.resolve();
+    }
+    async fillData(mgd, openingTaskDetails) {
+        return Promise.resolve();
+    }
+    async buildXML(message) {
+        return Promise.resolve();
+    }
+}
+export class UserRange {
+    veeIdx = 0;
+    min = null;
+    max = null;
+    nullMax = false;
+    nullMin = false;
+    discardMax = false;
+    discardMin = false;
+}
+export class OpeningTaskDetails {
+    CallingTask = null;
+    PathParentTask = null;
+    constructor(callingTask, pathParentTask) {
+        if (arguments.length === 0) {
+            this.constructor_0();
+            return;
+        }
+        this.constructor_1(callingTask, pathParentTask);
+    }
+    constructor_0() {
+        this.CallingTask = (this.PathParentTask = null);
+    }
+    constructor_1(callingTask, pathParentTask) {
+        this.CallingTask = callingTask;
+        this.PathParentTask = pathParentTask;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TaskBase.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/tasks/TaskBase.ts"],"names":[],"mappings":"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","sourcesContent":["import { List, RefParam, StringBuilder } from '@magic-xpa/mscorelib';\r\nimport { XmlParser } from '@magic-xpa/utils';\r\nimport { GuiTaskBase } from '@magic-xpa/gui';\r\nimport { TaskServiceBase } from './TaskServiceBase';\r\nimport { Event } from '../event/Event';\r\nimport { Expression } from '../exp/Expression';\r\nimport { MGData } from './MGData';\r\nimport { DataviewManager } from '../data/DataviewManager';\r\nimport { Sort } from './sort/Sort';\r\nimport { DvCache } from '../data/DvCache';\r\nimport { MgControl } from '../gui/MgControl';\r\nimport { Field } from '../data/Field';\r\nimport { Transaction } from '../rt/Transaction';\r\n\r\nexport enum Task_SubformExecModeEnum {\r\n  NO_SUBFORM = -1,\r\n  SET_FOCUS,\r\n  FIRST_TIME,\r\n  REFRESH\r\n}\r\n\r\n// the following comment prevents the error created by the compiler issue with the static call\r\n// @dynamic\r\nexport abstract class TaskBase extends GuiTaskBase {\r\n  public IsTryingToStop: boolean = false;               // if true then the task is trying to stop but not necessarily stopped yet\r\n  public DoSubformPrefixSuffix: boolean = false;            // if true, do the subform record prefix & suffix\r\n  public IsAfterRetryBeforeBuildXML: boolean = false;   // indicates whether flag AfterRetry is set to TRUE before building the XML\r\n  public TaskSuffixExecuted: boolean = false;\r\n  public DataviewManager: DataviewManager = null;       // the data view manager of the task\r\n  public IsOffline: boolean = false;\r\n  public ResetRange: boolean = false;\r\n  public UserRngs: List<UserRange> = null;\r\n  public ResetLocate: boolean = false;\r\n  public UserLocs: List<UserRange> = null;\r\n  public ResetSort: boolean = false;\r\n  public UserSorts: List<Sort> = null;\r\n  public PreviouslyActiveTaskId: string;                // ID of the task that was the active context task, when this task was created\r\n  protected _transactionFailed: boolean = false;\r\n  public InEndTask: boolean = false;                    // am I checking whether the task should be closed?\r\n  public InCtrlPrefix: boolean = false;\r\n  public RetainFocus: boolean = false;                      // only for Call operation with destination\r\n  public SubformExecMode: Task_SubformExecModeEnum = 0;      // for SubformExecMode function\r\n  TransactionErrorHandlingsRetry: Transaction = null;\r\n  public ClosingFormUI:boolean = false; // flag identifying whether user has closed the browser window\r\n\r\n  /// <summary>\r\n  /// is set true after initial data from remote and local database is fetched\r\n  /// </summary>\r\n  public AfterFirstRecordPrefix: boolean = false;\r\n\r\n  /// <summary>\r\n  /// For a richclient tasks, Non-Interactive task will be always Modal.\r\n  /// </summary>\r\n  /// <returns>true</returns>\r\n  static ShouldNonInteractiveBeModal(): boolean {\r\n    return true;\r\n  }\r\n\r\n  abstract isDescendentOf(chkTask: TaskBase): boolean;\r\n\r\n  abstract get TaskService(): TaskServiceBase;\r\n\r\n  abstract getUserEvent(idx: number): Event;\r\n\r\n  abstract getExpById(id: number): Expression;\r\n\r\n  abstract setInRecordSuffix(bValue: boolean): boolean;\r\n\r\n  abstract getMGData(): MGData;\r\n\r\n  abstract ctl_itm_4_parent_vee(parent: number, vee: number): number;\r\n\r\n  abstract getAfterRetry(): boolean;\r\n  abstract getAfterRetry(recovery: string): boolean;\r\n\r\n  abstract setAfterRetry(val: string): void;\r\n\r\n  abstract setTransactionFailed(val: boolean): void;\r\n\r\n  abstract getOriginalTaskMode(): string;\r\n\r\n  abstract setOriginalTaskMode(originalTaskMode: string): void;\r\n\r\n  abstract setTryingToStop(val: boolean): void;\r\n\r\n  abstract resetExecEndTask(): void;\r\n\r\n  abstract getTriggeringTask(): TaskBase;\r\n\r\n  async isCached(): Promise<boolean> {\r\n    return Promise.resolve(true)\r\n  }\r\n\r\n  abstract getLoopCounter(): number;\r\n\r\n  abstract getCounter(): number;\r\n\r\n  abstract buildXMLForRngs(message: StringBuilder, UserRanges: List<UserRange>, locate: boolean): void ;\r\n\r\n  abstract buildXMLForSorts(message: StringBuilder): void;\r\n\r\n  abstract getTaskCache(): DvCache;\r\n\r\n  abstract isTableWithAbsolutesScrollbar(): boolean;\r\n\r\n  async prepareCache(ignoreCurr: boolean): Promise<boolean>{\r\n    return Promise.resolve(true)\r\n  }\r\n\r\n  async testAndSet(ignoreCurr: boolean): Promise<boolean>{\r\n    return Promise.resolve(true)\r\n  }\r\n\r\n  abstract setPreventRecordSuffix(val: boolean): void;\r\n\r\n  abstract transactionFailed(level: string): boolean;\r\n\r\n  abstract HasLoacte(): boolean;\r\n\r\n  abstract isTransactionOwner(): boolean;\r\n\r\n  abstract getParent(): TaskBase;\r\n\r\n  abstract getMgdID(): number;\r\n\r\n  async SubformRefresh(subformTask: TaskBase, explicitSubformRefresh: boolean): Promise<void>{\r\n    return Promise.resolve()\r\n  }\r\n\r\n  abstract setExecEndTask(): void;\r\n\r\n  async stop(): Promise<void> {\r\n    return Promise.resolve()\r\n  }\r\n\r\n  abstract abort(): void;\r\n\r\n  abstract enableCreateActs(val: boolean): void;\r\n\r\n  abstract cancelWasRaised(): boolean;\r\n\r\n  abstract setCancelWasRaised(val: boolean): void;\r\n\r\n  abstract pathContains(task: TaskBase): boolean;\r\n\r\n  abstract RecomputeFillData(parser: XmlParser): void\r\n\r\n  abstract get ParentTask(): TaskBase;\r\n\r\n  abstract ShouldNonInteractiveChildBeModal(): boolean;\r\n\r\n  abstract setTransOwnerTask(): void;\r\n\r\n  abstract setDestinationSubform(destinationSubform: boolean): void;\r\n\r\n  abstract setIsDestinationCall(isDestinationCall: boolean): void;\r\n\r\n  abstract GetRealMainDisplayIndexOnDepth(mainDspIdx: number): number;\r\n\r\n  abstract getTaskDepth(byParentOrder: boolean): number;\r\n\r\n  abstract setEvalOldValues(bFlag: boolean): boolean;\r\n\r\n  abstract GetControlIDFromVarItem(item: number): number;\r\n\r\n  abstract GetControlFromControlID(controlID: number, parent: RefParam<number>): MgControl;\r\n\r\n  abstract pathToRoot(path: TaskBase[], byParentOrder: boolean): void;\r\n\r\n  abstract isFirstRecordCycle(Value_?: boolean): any;\r\n\r\n  abstract ctl_itm_2_parent_vee(itm: number): Field;\r\n\r\n  abstract queryTaskPath(): StringBuilder;\r\n\r\n  abstract getFieldByName(fldName: string): Field;\r\n\r\n  abstract getIndexOfFieldByName(fldName: string): number;\r\n\r\n  abstract isProgram(): boolean;\r\n\r\n  abstract getPublicName(): string;\r\n\r\n  abstract getExternalTaskId(): string;\r\n\r\n  /// <summary>\r\n  /// the transaction need to be on the data view manager\r\n  /// </summary>\r\n  abstract set Transaction(value: Transaction);\r\n  abstract get Transaction(): Transaction;\r\n\r\n  async fillData(mgd: MGData, openingTaskDetails: OpeningTaskDetails): Promise<void>{\r\n    return Promise.resolve()\r\n  }\r\n\r\n  async buildXML(message: StringBuilder): Promise<void>{\r\n    return Promise.resolve()\r\n  }\r\n}\r\n\r\n/// <summary>\r\n///\r\n/// </summary>\r\nexport class UserRange {\r\n  public veeIdx: number = 0;\r\n  public min: string = null;\r\n  public max: string = null;\r\n  public nullMax: boolean = false;\r\n  public nullMin: boolean = false;\r\n  public discardMax: boolean = false;\r\n  public discardMin: boolean = false;\r\n}\r\n\r\n\r\n/// <summary>\r\n/// Class holding additional information regarding a task being opened.\r\n/// </summary>\r\nexport class OpeningTaskDetails {\r\n  CallingTask: TaskBase = null;\r\n  PathParentTask: TaskBase = null;\r\n\r\n  constructor();\r\n  constructor(callingTask: TaskBase, pathParentTask: TaskBase);\r\n  constructor(callingTask?: TaskBase, pathParentTask?: TaskBase) {\r\n    if (arguments.length === 0) {\r\n      this.constructor_0();\r\n      return;\r\n    }\r\n    this.constructor_1(callingTask, pathParentTask);\r\n  }\r\n\r\n  private constructor_0(): void {\r\n    this.CallingTask = (this.PathParentTask = null);\r\n  }\r\n\r\n  private constructor_1(callingTask: TaskBase, pathParentTask: TaskBase): void {\r\n    this.CallingTask = callingTask;\r\n    this.PathParentTask = pathParentTask;\r\n  }\r\n}\r\n"]}

package/esm2022/src/tasks/TaskServiceBase.mjs

@@ -0,0 +1,25 @@
+import { ReturnResult } from "../util/ReturnResult";
+import { PropInterface } from "@magic-xpa/gui";
+export class TaskServiceBase {
+    static CreateFirstRecord(task) {
+        task.AfterFirstRecordPrefix = true;
+    }
+    PrepareTask(task) {
+        return ReturnResult.SuccessfulResult;
+    }
+    static async PreparePropOpenTaskWindow(task) {
+        let propOpenTaskWindow = task.getProp(PropInterface.PROP_TYPE_TASK_PROPERTIES_OPEN_TASK_WINDOW);
+        let propOpenTaskWindowValue = false;
+        if (!task.isMainProg() || task.getCtlIdx() === 0) {
+            propOpenTaskWindowValue = await propOpenTaskWindow.getValueBoolean();
+        }
+        task.SetOpenWin(propOpenTaskWindowValue);
+    }
+    static async Exit(task, reversibleExit, subformDestination) {
+        await task.Exit(reversibleExit, subformDestination);
+    }
+    GetOwnerTransactionTask(task) {
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/tasks/TasksTable.mjs

@@ -0,0 +1,80 @@
+import { XMLConstants } from "@magic-xpa/utils";
+import { List } from "@magic-xpa/mscorelib";
+export class TasksTable {
+    _tasks = null;
+    static createNewtask = null;
+    constructor() {
+        this._tasks = new List();
+    }
+    async fillData(mgdata, openingTaskDetails, parser) {
+        while (await this.initInnerObjects(parser.getNextTag(), mgdata, openingTaskDetails)) {
+        }
+    }
+    async initInnerObjects(foundTagName, mgdata, openingTaskDetails) {
+        let result;
+        if (foundTagName === null) {
+            result = false;
+        }
+        else {
+            if (foundTagName === XMLConstants.MG_TAG_TASK) {
+                let task = TasksTable.createNewtask();
+                this._tasks.push(task);
+                await task.fillData(mgdata, openingTaskDetails);
+                result = true;
+            }
+            else {
+                result = false;
+            }
+        }
+        return result;
+    }
+    addTask(task) {
+        this._tasks.push(task);
+    }
+    removeTask(task) {
+        this._tasks.Remove(task);
+    }
+    getTask(tasktagOrIdx) {
+        if (arguments.length === 1 && (tasktagOrIdx === null || typeof tasktagOrIdx === "undefined" || tasktagOrIdx.constructor === String)) {
+            return this.getTask_0(tasktagOrIdx);
+        }
+        return this.getTask_1(tasktagOrIdx);
+    }
+    getTask_0(tasktag) {
+        let result;
+        for (let i = 0; i < this._tasks.length; i = i + 1) {
+            let task = this._tasks.get_Item(i);
+            if (tasktag === task.getTaskTag()) {
+                result = task;
+                return result;
+            }
+        }
+        result = null;
+        return result;
+    }
+    getTask_1(idx) {
+        let result;
+        if (idx >= 0 && idx < this._tasks.length) {
+            result = this._tasks.get_Item(idx);
+        }
+        else {
+            result = null;
+        }
+        return result;
+    }
+    getSize() {
+        return this._tasks.length;
+    }
+    async buildXML(message) {
+        for (let i = 0; i < this.getSize(); i = i + 1) {
+            await this.getTask(i).buildXML(message);
+        }
+    }
+    setTaskAt(task, index) {
+        if (this._tasks.length <= index) {
+            this._tasks.SetSize(index + 1);
+        }
+        this._tasks.set_Item(index, task);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TasksTable.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/tasks/TasksTable.ts"],"names":[],"mappings":"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","sourcesContent":["import {StringBuilder} from \"@magic-xpa/mscorelib\";\r\nimport { XMLConstants, XmlParser} from \"@magic-xpa/utils\";\r\nimport {List} from \"@magic-xpa/mscorelib\";\r\nimport {MGData} from \"./MGData\";\r\nimport {TaskBase} from \"./TaskBase\";\r\nimport {OpeningTaskDetails} from \"./TaskBase\";\r\n\r\nexport class TasksTable {\r\n  private readonly _tasks: List<TaskBase> = null;\r\n  static createNewtask = null;\r\n\r\n  constructor() {\r\n    this._tasks = new List();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   parse a set of tasks\r\n  /// </summary>\r\n  /// <param name = \"mgdata\">to parent -> MGData </param>\r\n  /// <param name=\"openingTaskDetails\">additional information of opening task</param>\r\n  async fillData(mgdata: MGData, openingTaskDetails: OpeningTaskDetails, parser: XmlParser): Promise<void> {\r\n    while (await this.initInnerObjects(parser.getNextTag(), mgdata, openingTaskDetails)) {\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Start task,parsing\r\n  /// </summary>\r\n  private async initInnerObjects(foundTagName: string, mgdata: MGData, openingTaskDetails: OpeningTaskDetails): Promise<boolean> {\r\n    let result: boolean;\r\n    if (foundTagName === null) {\r\n      result = false;\r\n    }\r\n    else {\r\n      if (foundTagName === XMLConstants.MG_TAG_TASK) {\r\n        let task: TaskBase = TasksTable.createNewtask();\r\n        this._tasks.push(task);\r\n        await task.fillData(mgdata, openingTaskDetails);\r\n        result = true;\r\n      }\r\n      else {\r\n        result = false;\r\n      }\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   add a new task to the table\r\n  /// </summary>\r\n  /// <param name = \"task\">the new task to add </param>\r\n  addTask(task: TaskBase): void {\r\n    this._tasks.push(task);\r\n  }\r\n\r\n  removeTask(task: TaskBase): void {\r\n    this._tasks.Remove(task);\r\n  }\r\n\r\n  getTask(tasktag: string): TaskBase;\r\n  getTask(idx: number): TaskBase;\r\n  getTask(tasktagOrIdx: any): TaskBase {\r\n    if (arguments.length === 1 && (tasktagOrIdx === null || typeof tasktagOrIdx === \"undefined\" || tasktagOrIdx.constructor === String)) {\r\n      return this.getTask_0(tasktagOrIdx);\r\n    }\r\n    return this.getTask_1(tasktagOrIdx);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get a task by its Id\r\n  /// </summary>\r\n  /// <param name = \"tasktag\">the requested task id (current id or original id)</param>\r\n  private getTask_0(tasktag: string): TaskBase {\r\n    let result: TaskBase;\r\n    for (let i: number = 0; i < this._tasks.length; i = i + 1) {\r\n      let task: TaskBase = this._tasks.get_Item(i);\r\n      if (tasktag === task.getTaskTag()) {\r\n        result = task;\r\n        return result;\r\n      }\r\n    }\r\n    result = null;\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get a task by its index\r\n  /// </summary>\r\n  /// <param name = \"idx\">task index in the table</param>\r\n  private getTask_1(idx: number): TaskBase {\r\n    let result: TaskBase;\r\n    if (idx >= 0 && idx < this._tasks.length) {\r\n      result = this._tasks.get_Item(idx);\r\n    }\r\n    else {\r\n      result = null;\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the number of tasks in the table\r\n  /// </summary>\r\n  getSize(): number {\r\n    return this._tasks.length;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   build the XML string for the tasks in the table\r\n  /// </summary>\r\n  /// <param name = \"message\">the xml message to append to </param>\r\n  async buildXML(message: StringBuilder): Promise<void> {\r\n    for (let i: number = 0; i < this.getSize(); i = i + 1) {\r\n      await this.getTask(i).buildXML(message);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set task of event\r\n  /// </summary>\r\n  /// <param name = \"task\"></param>\r\n  /// <param name = \"index\"> </param>\r\n\r\n  setTaskAt(task: TaskBase, index: number): void {\r\n    if (this._tasks.length <= index) {\r\n      this._tasks.SetSize(index + 1);\r\n    }\r\n    this._tasks.set_Item(index, task);\r\n  }\r\n}\r\n"]}

package/esm2022/src/tasks/sort/Sort.mjs

@@ -0,0 +1,5 @@
+export class Sort {
+    fldIdx = 0;
+    dir = false;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU29ydC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2VuZ2luZS9zcmMvdGFza3Mvc29ydC9Tb3J0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxJQUFJO0lBQ2YsTUFBTSxHQUFXLENBQUMsQ0FBQztJQUVuQixHQUFHLEdBQVksS0FBSyxDQUFDO0NBQ3RCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIFNvcnQge1xyXG4gIGZsZElkeDogbnVtYmVyID0gMDsgLy8gc2VnbWVudCBmaWVsZFxyXG5cclxuICBkaXI6IGJvb2xlYW4gPSBmYWxzZTsgLy8gZGlyXHJcbn1cclxuIl19

package/esm2022/src/tasks/sort/SortCollection.mjs

@@ -0,0 +1,67 @@
+import { List, NString } from '@magic-xpa/mscorelib';
+import { Sort } from './Sort';
+import { Logger, XMLConstants, XmlParser } from '@magic-xpa/utils';
+import { ConstInterface } from '../../ConstInterface';
+export class SortCollection {
+    _sortTab = null;
+    constructor() {
+        this._sortTab = new List();
+    }
+    fillData(parser) {
+        while (this.initInnerObjects(parser, parser.getNextTag())) {
+        }
+    }
+    initInnerObjects(parser, foundTagName) {
+        if (foundTagName === null)
+            return false;
+        switch (foundTagName) {
+            case ConstInterface.MG_TAG_SORTS:
+                parser.setCurrIndex(parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()) + 1);
+                break;
+            case ConstInterface.MG_TAG_SORT:
+                {
+                    let sort = new Sort();
+                    this._sortTab.push(sort);
+                    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_SORT) + ConstInterface.MG_TAG_SORT.length);
+                        let tokensVector = new List(XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM).GetEnumerator());
+                        this.InitElements(tokensVector, sort);
+                        parser.setCurrIndex(endContext + XMLConstants.TAG_TERM.length);
+                    }
+                }
+                break;
+            case ConstInterface.MG_TAG_SORTS_END:
+                parser.setCurrIndex2EndOfTag();
+                return false;
+        }
+        return true;
+    }
+    InitElements(tokensVector, sort) {
+        for (let j = 0; j < tokensVector.length; j += 2) {
+            let attribute = (tokensVector.get_Item(j));
+            let valueStr = (tokensVector.get_Item(j + 1));
+            switch (attribute) {
+                case XMLConstants.MG_ATTR_ID:
+                    sort.fldIdx = XmlParser.getInt(valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_DIR:
+                    sort.dir = valueStr === "A";
+                    break;
+                default:
+                    Logger.Instance.WriteExceptionToLogWithMsg(NString.Format("Unrecognized attribute: '{0}'", attribute));
+                    break;
+            }
+        }
+    }
+    getSize() {
+        if (this._sortTab === null)
+            return 0;
+        return this._sortTab.length;
+    }
+    add(sort) {
+        this._sortTab.push(sort);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SortCollection.js","sourceRoot":"","sources":["../../../../../../../projects/engine/src/tasks/sort/SortCollection.ts"],"names":[],"mappings":"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","sourcesContent":["import {List, NString} from '@magic-xpa/mscorelib';\r\nimport {Sort} from './Sort';\r\nimport {Logger, XMLConstants, XmlParser} from '@magic-xpa/utils';\r\nimport {ConstInterface} from '../../ConstInterface';\r\n\r\n// This will hold runtime sorts added on task.\r\nexport class SortCollection {\r\n  private _sortTab: List<Sort> = null;\r\n\r\n  /// <summary>\r\n  ///   CTOR\r\n  /// </summary>\r\n  constructor() {\r\n    this._sortTab = new List<Sort>();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   parse input string and fill inner data : Vector RTSortTab\r\n  /// </summary>\r\n  fillData(parser: XmlParser): void {\r\n    while (this.initInnerObjects(parser, parser.getNextTag())) {\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   allocate and fill inner objects of the class\r\n  /// </summary>\r\n  /// <param name = \"foundTagName\">possible  tag name, name of object, which need be allocated </param>\r\n  initInnerObjects(parser: XmlParser, foundTagName: string): boolean {\r\n    if (foundTagName === null)\r\n      return false;\r\n\r\n    switch (foundTagName) {\r\n      case ConstInterface.MG_TAG_SORTS:\r\n        parser.setCurrIndex(parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()) + 1);\r\n        // end of outer tag and its \">\"\r\n        break;\r\n      case ConstInterface.MG_TAG_SORT: {\r\n        let sort: Sort = new Sort();\r\n        this._sortTab.push(sort);\r\n        let endContext: number = parser.getXMLdata().indexOf(XMLConstants.TAG_TERM, parser.getCurrIndex());\r\n\r\n        if (endContext !== -1 && endContext < parser.getXMLdata().length) {\r\n          // last position of its tag\r\n          let tag: String = parser.getXMLsubstring(endContext);\r\n          parser.add2CurrIndex(tag.indexOf(ConstInterface.MG_TAG_SORT) + ConstInterface.MG_TAG_SORT.length);\r\n\r\n          let tokensVector: List<string> = new List<string>(XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM).GetEnumerator());\r\n          // parse each column\r\n          this.InitElements(tokensVector, sort);\r\n          parser.setCurrIndex(endContext + XMLConstants.TAG_TERM.length); // to delete \"/>\" too\r\n        }\r\n      }\r\n        break;\r\n\r\n      case ConstInterface.MG_TAG_SORTS_END:\r\n        parser.setCurrIndex2EndOfTag();\r\n        return false;\r\n    }\r\n    return true;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   used to parse each column xml tag attributes the column represents a segment in the key\r\n  /// </summary>\r\n  private InitElements(tokensVector: List<string>, sort: Sort): void {\r\n    for (let j: number = 0; j < tokensVector.length; j += 2) {\r\n\r\n      let attribute: string = (tokensVector.get_Item(j));\r\n      let valueStr: string = (tokensVector.get_Item(j + 1));\r\n\r\n      switch (attribute) {\r\n        case XMLConstants.MG_ATTR_ID: // sort segment i.e. fldIdx\r\n          sort.fldIdx = XmlParser.getInt(valueStr);\r\n          break;\r\n        case ConstInterface.MG_ATTR_DIR: // direction of sort segment\r\n          sort.dir = valueStr === \"A\";\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\r\n\r\n  /// <summary>\r\n  ///   get size of the sort table\r\n  /// </summary>\r\n  getSize(): number {\r\n    if (this._sortTab === null)\r\n      return 0;\r\n    return this._sortTab.length;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   add Sort to  Sort collection.\r\n  /// </summary>\r\n  /// <param name = \"sort\">Sort to be added </param>\r\n  add(sort: Sort): void {\r\n    this._sortTab.push(sort);\r\n  }\r\n}\r\n"]}

package/esm2022/src/util/ConstUtils.mjs

@@ -0,0 +1,14 @@
+export class ConstUtils {
+    static getStringOfOption(strOptions, options, selectedOption) {
+        let strOption = "";
+        let indexOpt = options.indexOf(selectedOption);
+        if (indexOpt > -1) {
+            let tokens = strOptions.split(',');
+            if (indexOpt < tokens.length) {
+                strOption = tokens[indexOpt];
+            }
+        }
+        return strOption;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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