@magic-xpa/engine 4.1100.0-dev4110.99 → 4.1101.0-dev4111.271

package/esm2022/src/rt/TableCache.mjs

@@ -0,0 +1,177 @@
+import { List, NString } from "@magic-xpa/mscorelib";
+import { Key } from "../data/Key";
+import { FieldsTableExt as FieldsTable } from "../data/FieldsTable";
+import { Logger, XMLConstants, XmlParser } from "@magic-xpa/utils";
+import { RuntimeContextBase } from "@magic-xpa/gui";
+import { Record } from "../data/Record";
+import { HeapSort } from "../util/HeapSort";
+import { ConstInterface } from "../ConstInterface";
+import { TableCacheManager } from "./TableCacheManager";
+export class TableCache {
+    _keys = null;
+    _records = null;
+    _currSortDir = '\0';
+    _currSortKey = 0;
+    FldsTab = null;
+    _isLoaded = false;
+    _tableIdent = null;
+    _tableUId = null;
+    constructor(tableId) {
+        this._tableUId = tableId;
+        this._keys = new List();
+        this._records = new List();
+        this._isLoaded = false;
+    }
+    SetTableIdent(ident) {
+        if (this._tableIdent === null)
+            this._tableIdent = ident;
+        else if (this._tableIdent !== ident) {
+            Logger.Instance.WriteExceptionToLogWithMsg("in TableCache.setTableIdent() already set and table identifier  does not match");
+        }
+    }
+    FillData() {
+        let parser = RuntimeContextBase.Instance.Parser;
+        this.FillAttributes(parser);
+        while (this.InitInnerObjects(parser, parser.getNextTag())) {
+        }
+    }
+    FillAttributes(parser) {
+        let endContext = parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex());
+        if (endContext !== -1 && endContext < parser.getXMLdata().length) {
+            let tag = parser.getXMLsubstring(endContext);
+            parser.add2CurrIndex(tag.indexOf(ConstInterface.MG_TAG_CACHED_TABLE) + ConstInterface.MG_TAG_CACHED_TABLE.length);
+            let tokensVector = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);
+            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:
+                        if (this._tableUId.indexOf(valueStr) === -1) {
+                            this._tableUId = valueStr;
+                            Logger.Instance.WriteExceptionToLogWithMsg("in TableCache.fillAttributes() table unique id does not match");
+                        }
+                        break;
+                    case XMLConstants.MG_ATTR_NAME:
+                        break;
+                    case ConstInterface.MG_ATTR_IDENT:
+                        if (this._tableIdent !== valueStr) {
+                            this._tableIdent = valueStr;
+                            Logger.Instance.WriteExceptionToLogWithMsg("in TableCache.fillAttributes() table identifier id does not match");
+                        }
+                        break;
+                    default:
+                        Logger.Instance.WriteExceptionToLogWithMsg(NString.Format("Unrecognized attribute: '{0}'", attribute));
+                        break;
+                }
+            }
+            parser.setCurrIndex(++endContext);
+            return;
+        }
+        Logger.Instance.WriteExceptionToLogWithMsg("in TableCache.fillAttributes() out of string bounds");
+    }
+    InitInnerObjects(parser, foundTagName) {
+        if (foundTagName == null)
+            return false;
+        switch (foundTagName) {
+            case XMLConstants.MG_TAG_FLDH:
+                this.FldsTab = new FieldsTable();
+                this.FldsTab.fillData(parser);
+                break;
+            case ConstInterface.MG_ATTR_KEY: {
+                let current = new Key(this);
+                current.FillData(parser);
+                this._keys.push(current);
+                break;
+            }
+            case ConstInterface.MG_TAG_RECORDS:
+                parser.setCurrIndex(parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()) + 1);
+                break;
+            case ConstInterface.MG_TAG_RECORDS_END:
+                parser.setCurrIndex2EndOfTag();
+                break;
+            case ConstInterface.MG_TAG_CACHED_TABLE_END:
+                parser.setCurrIndex2EndOfTag();
+                return false;
+            case ConstInterface.MG_TAG_REC: {
+                let current = new Record(this);
+                current.Initialize();
+                current.fillData(parser);
+                this._records.push(current);
+                break;
+            }
+        }
+        return true;
+    }
+    GetTableUniqueId() {
+        return this._tableUId;
+    }
+    GetTableCommonIdentifier() {
+        return this._tableIdent;
+    }
+    GetCurrSortKey() {
+        return this._currSortKey;
+    }
+    GetKeyById(keyId) {
+        for (let i = 0; i < this._keys.length; i = i + 1) {
+            if (this._keys.get_Item(i).GetKeyId() === keyId)
+                return this._keys.get_Item(i);
+        }
+        return null;
+    }
+    async Load() {
+        if (!this._isLoaded) {
+            await TableCacheManager.Instance.LoadTable(this._tableUId);
+            this._isLoaded = true;
+        }
+    }
+    async SortTable(sortKeyId, sortDir) {
+        if (!this._isLoaded)
+            await this.Load();
+        if (sortKeyId !== this._currSortKey || sortDir !== this._currSortDir) {
+            this._currSortDir = sortDir;
+            this._currSortKey = sortKeyId;
+            let recordsArr = this._records.ToArray();
+            HeapSort.sort(recordsArr);
+            if (this._currSortDir === 'D')
+                this.ReverseVector(recordsArr);
+            for (let i = 0; i < this._records.length; i = i + 1) {
+                this._records.set_Item(i, recordsArr[i]);
+            }
+        }
+    }
+    Fetch(loc) {
+        let checkLoc = loc.length > 0;
+        if (this._isLoaded) {
+            if (!checkLoc) {
+                return ((this._records.length !== 0) ? this._records.get_Item(0) : null);
+            }
+            for (let i = 0; i < this._records.length; i = i + 1) {
+                let currRec = this._records.get_Item(i);
+                if (TableCache.validateRec(currRec, loc)) {
+                    return currRec;
+                }
+            }
+        }
+        return null;
+    }
+    static validateRec(currRec, rangeCond) {
+        let result = true;
+        for (let i = 0; i < rangeCond.length; i = i + 1) {
+            let currCnd = rangeCond.get_Item(i);
+            if (!currCnd.checkRange(currRec.GetFieldValue(currCnd.getCacheTableFldId()), currRec.IsNull(currCnd.getCacheTableFldId()))) {
+                result = false;
+                break;
+            }
+        }
+        return result;
+    }
+    ReverseVector(array) {
+        let right = array.length - 1;
+        for (let left = 0; left < Math.floor((array.length - 1) / 2); left++, right--) {
+            let tmp = array[left];
+            array[left] = array[right];
+            array[right] = tmp;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TableCache.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/rt/TableCache.ts"],"names":[],"mappings":"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","sourcesContent":["import {List, NString} from \"@magic-xpa/mscorelib\";\r\nimport {Key} from \"../data/Key\";\r\nimport {FieldsTableExt as FieldsTable } from \"../data/FieldsTable\";\r\nimport {Logger, XMLConstants, XmlParser} from \"@magic-xpa/utils\";\r\nimport {RuntimeContextBase} from \"@magic-xpa/gui\";\r\nimport {Record} from \"../data/Record\";\r\nimport {HeapSort} from \"../util/HeapSort\";\r\nimport {Boundary} from \"./Boundary\";\r\nimport {ConstInterface} from \"../ConstInterface\";\r\nimport { TableCacheManager } from \"./TableCacheManager\";\r\n\r\n/// <summary>\r\n///   resident table on client\r\n/// </summary>\r\nexport class TableCache {\r\n  private _keys: List<Key> = null;\r\n  private _records: List<Record> = null;\r\n  private _currSortDir: string = '\\0';\r\n  private _currSortKey: number = 0;\r\n\r\n  FldsTab: FieldsTable = null;\r\n\r\n  private _isLoaded: boolean = false;\r\n  private _tableIdent: string = null; // a table identifier this id if share between all instances of a resident table used to delete old instnces of a reloaded table;\r\n  private _tableUId: string = null; // the table unique id used to load the table - it is also the id of the data-island containing the table xml\r\n\r\n\r\n  /// <summary>\r\n  ///   constructs an empty table cache without loading the table\r\n  /// </summary>\r\n  constructor(tableId: string) {\r\n    this._tableUId = tableId;\r\n    this._keys = new List<Key>();\r\n    this._records = new List<Record>();\r\n    this._isLoaded = false;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the table shared identifier will be called directly before the constructor and before parsing\r\n  /// </summary>\r\n  SetTableIdent(ident: string): void {\r\n    if (this._tableIdent === null)\r\n      this._tableIdent = ident;\r\n    else if (this._tableIdent !== ident) {\r\n      Logger.Instance.WriteExceptionToLogWithMsg(\"in TableCache.setTableIdent() already set and table identifier  does not match\");\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   parses the xml data of the table cache as part of the load process\r\n  /// </summary>\r\n  FillData(): void {\r\n    let parser: XmlParser = RuntimeContextBase.Instance.Parser;\r\n    this.FillAttributes(parser);\r\n    while (this.InitInnerObjects(parser, parser.getNextTag())) {\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   parses the attributes of the cachedTable tag\r\n  /// </summary>\r\n  private FillAttributes(parser: XmlParser): void {\r\n    let endContext: number = parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, 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_CACHED_TABLE) + ConstInterface.MG_TAG_CACHED_TABLE.length);\r\n\r\n      let tokensVector: List<string> = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);\r\n\r\n      // parse the cachedTable attributes\r\n      for (let j: number = 0; j < tokensVector.length; j += 2) {\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:\r\n\r\n            // the id of the table is recived at the constructor and does not need to be parsed\r\n            // however issue a warnning if the parsed value is different than the current value\r\n            if (this._tableUId.indexOf(valueStr) === -1) {\r\n              this._tableUId = valueStr;\r\n              Logger.Instance.WriteExceptionToLogWithMsg(\"in TableCache.fillAttributes() table unique id does not match\");\r\n            }\r\n            break;\r\n\r\n          case XMLConstants.MG_ATTR_NAME:\r\n            break;\r\n\r\n          case ConstInterface.MG_ATTR_IDENT:\r\n            if (this._tableIdent !== valueStr) {\r\n              this._tableIdent = valueStr;\r\n              Logger.Instance.WriteExceptionToLogWithMsg(\"in TableCache.fillAttributes() table identifier id does not match\");\r\n            }\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      parser.setCurrIndex(++endContext);  // to delete \">\" too\r\n      return;\r\n    }\r\n    Logger.Instance.WriteExceptionToLogWithMsg(\"in TableCache.fillAttributes() out of string bounds\");\r\n  }\r\n\r\n  /// <summary>\r\n  ///   allocates and initialize inner object according to the found xml data\r\n  /// </summary>\r\n  private InitInnerObjects(parser: XmlParser, foundTagName: String): boolean {\r\n    if (foundTagName == null)\r\n      return false;\r\n\r\n    switch (foundTagName) {\r\n      case XMLConstants.MG_TAG_FLDH:\r\n        this.FldsTab = new FieldsTable();\r\n        this.FldsTab.fillData(parser);\r\n        break;\r\n\r\n      case ConstInterface.MG_ATTR_KEY: {\r\n        let current = new Key(this);\r\n        current.FillData(parser);\r\n        this._keys.push(current);\r\n        break;\r\n      }\r\n\r\n      case ConstInterface.MG_TAG_RECORDS:\r\n        parser.setCurrIndex(parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()) + 1);\r\n        // end of outer tad and its \">\"\r\n        break;\r\n      case ConstInterface.MG_TAG_RECORDS_END:\r\n        parser.setCurrIndex2EndOfTag();\r\n        break;\r\n      case ConstInterface.MG_TAG_CACHED_TABLE_END:\r\n        parser.setCurrIndex2EndOfTag();\r\n        return false;\r\n      case ConstInterface.MG_TAG_REC: {\r\n        let current = new Record(this);\r\n        current.Initialize();\r\n        current.fillData(parser);\r\n        this._records.push(current);\r\n        break;\r\n      }\r\n    }\r\n    return true;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the unique id of the current cached table\r\n  /// </summary>\r\n  GetTableUniqueId(): string {\r\n    return this._tableUId;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return the table common identifier\r\n  /// </summary>\r\n  GetTableCommonIdentifier(): string {\r\n    return this._tableIdent;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the key by whic we are currently sorting (or currently sorted) the table\r\n  /// </summary>\r\n  GetCurrSortKey(): number {\r\n    return this._currSortKey;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the key by id\r\n  /// </summary>\r\n  GetKeyById(keyId: number): Key {\r\n    for (let i: number = 0; i < this._keys.length; i = i + 1) {\r\n      if (this._keys.get_Item(i).GetKeyId() === keyId)\r\n        return this._keys.get_Item(i);\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   loads a table from the dataIsland according to is unique id\r\n  /// </summary>\r\n  private async Load(): Promise<void> {\r\n    if (!this._isLoaded) {\r\n      await TableCacheManager.Instance.LoadTable(this._tableUId);\r\n      this._isLoaded = true;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   sort the current table\r\n  /// </summary>\r\n  /// <param name=\"sortKeyId\">the id of the key to sort by </param>\r\n  /// <param name=\"sortDir\"></param>\r\n  async SortTable(sortKeyId: number, sortDir: string): Promise<void> {\r\n    if (!this._isLoaded)\r\n      await this.Load();\r\n\r\n    // if the table is already sorted the way we want it\r\n    if (sortKeyId !== this._currSortKey || sortDir !== this._currSortDir) {\r\n      this._currSortDir = sortDir;\r\n      this._currSortKey = sortKeyId;\r\n\r\n      let recordsArr: Record[] = this._records.ToArray();\r\n      HeapSort.sort(recordsArr);\r\n\r\n      if (this._currSortDir === 'D')\r\n        this.ReverseVector(recordsArr);\r\n\r\n      for (let i: number = 0; i < this._records.length; i = i + 1) {\r\n        this._records.set_Item(i, recordsArr[i]);\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   executes the the link operation we assume the table is already sorted by the correct key and direction\r\n  ///   the method returns the requested record according the locates\r\n  /// </summary>\r\n  Fetch(loc: List<Boundary>): Record {\r\n\r\n    // if there are not any locate expression then either we return the ffirst record that accepts\r\n    // al the range condition or we return the first record in the table according to the current sort\r\n    let checkLoc: boolean = loc.length > 0;\r\n\r\n    if (this._isLoaded) {\r\n      // should be loaded at sort time the time must be already sorted at this stage\r\n      if (!checkLoc) {\r\n        // if there are no locates return the first record\r\n        return ((this._records.length !== 0) ? this._records.get_Item(0) : null);\r\n      }\r\n\r\n      // find the first record that agrees with the locates ant return it\r\n      for (let i: number = 0; i < this._records.length; i = i + 1) {\r\n        let currRec: Record = this._records.get_Item(i);\r\n\r\n        // check if this record agrees with all the locate conditions\r\n        if (TableCache.validateRec(currRec, loc)) {\r\n          return currRec;\r\n        }\r\n      }\r\n    }\r\n    // if we got here then either the table was not loaded and sorted or we did not find any record\r\n    // that agrees with the locate expressions - in either case return null\r\n    return null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   validate a record data against a series of locate expressions\r\n  /// </summary>\r\n  private static validateRec(currRec: Record, rangeCond: List<Boundary>): boolean {\r\n    let result: boolean = true;\r\n\r\n    // go over all the conditions\r\n    for (let i: number = 0; i < rangeCond.length; i = i + 1) {\r\n      let currCnd: Boundary = rangeCond.get_Item(i);\r\n      // if there is at least one filed that does not agree all the record dies not agree\r\n      if (!currCnd.checkRange(currRec.GetFieldValue(currCnd.getCacheTableFldId()), currRec.IsNull(currCnd.getCacheTableFldId()))) {\r\n        result = false;\r\n        break;\r\n      }\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"array\"></param>\r\n  protected ReverseVector(array: Object[]): void {\r\n    let right: number = array.length - 1;\r\n    for (let left: number = 0; left < Math.floor((array.length - 1) / 2); left++ , right--) {\r\n      let tmp: Object = array[left];\r\n      array[left] = array[right];\r\n      array[right] = tmp;\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2022/src/rt/TableCacheManager.mjs

@@ -0,0 +1,67 @@
+import { Misc } from '@magic-xpa/utils';
+import { ApplicationException, Exception, Hashtable, List } from '@magic-xpa/mscorelib';
+import { RuntimeContextBase } from '@magic-xpa/gui';
+import { RemoteCommandsProcessor } from '../remote/RemoteCommandsProcessor';
+export class TableCacheManager {
+    _tables = null;
+    static Instance = new TableCacheManager();
+    constructor() {
+        this._tables = new Hashtable();
+    }
+    GetTableById(tableUId) {
+        return this._tables.get_Item(tableUId);
+    }
+    TableExists(tableUId) {
+        let result = true;
+        if (this.GetTableById(tableUId) === null)
+            result = false;
+        return result;
+    }
+    InsertTable(table) {
+        let result = false;
+        if (!this.TableExists(table.GetTableUniqueId())) {
+            this._tables.set_Item(table.GetTableUniqueId(), table);
+            result = true;
+        }
+        return result;
+    }
+    async LoadTable(tableUId) {
+        let server = RemoteCommandsProcessor.GetInstance();
+        if (this.TableExists(tableUId)) {
+            let current = this._tables.get_Item(tableUId);
+            try {
+                let residentTableContentStr = await server.GetContent(tableUId, true);
+                try {
+                    RuntimeContextBase.Instance.Parser.loadTableCacheData(residentTableContentStr);
+                }
+                catch (innerException) {
+                    if (innerException instanceof Exception) {
+                        throw new ApplicationException("Unable to parse resident table " + tableUId + ", due to unsupported encoding.", innerException);
+                    }
+                    else
+                        throw innerException;
+                }
+            }
+            catch (throwable) {
+                if (throwable instanceof Exception) {
+                    Misc.WriteStackTrace(throwable);
+                }
+                else
+                    throw throwable;
+            }
+            current.FillData();
+            let deletedUids = new List();
+            let enumerator = this._tables.Values;
+            while (enumerator.MoveNext()) {
+                let tbl = enumerator.Current;
+                let currIdent = tbl.GetTableCommonIdentifier();
+                if (currIdent === current.GetTableCommonIdentifier() && tbl.GetTableUniqueId() !== tableUId)
+                    deletedUids.push(tbl.GetTableUniqueId());
+            }
+            for (let i = 0; i < deletedUids.length; i = i + 1) {
+                this._tables.Remove(deletedUids.get_Item(i));
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TableCacheManager.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/rt/TableCacheManager.ts"],"names":[],"mappings":"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","sourcesContent":["import { Misc } from '@magic-xpa/utils';\r\nimport { ApplicationException, Array_Enumerator, Exception, Hashtable, List } from '@magic-xpa/mscorelib';\r\nimport { RuntimeContextBase } from '@magic-xpa/gui';\r\nimport { TableCache } from './TableCache';\r\nimport { CommandsProcessorBase } from '../CommandsProcessorBase';\r\nimport { RemoteCommandsProcessor } from '../remote/RemoteCommandsProcessor';\r\n\r\n/// <summary>\r\n///   handles the loading and managing of all cache tables in the context\r\n/// </summary>\r\nexport class TableCacheManager {\r\n  private _tables: Hashtable<string, TableCache> = null;\r\n\r\n  static Instance: TableCacheManager = new TableCacheManager();\r\n\r\n  private constructor() {\r\n    this._tables = new Hashtable<string, TableCache>();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return the tableCache object  according to its unique id or null if does not exist in the manager\r\n  /// </summary>\r\n  GetTableById(tableUId: string): TableCache {\r\n    return <TableCache>this._tables.get_Item(tableUId);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   checks if a given table exists in the manager\r\n  /// </summary>\r\n  TableExists(tableUId: string): boolean {\r\n    let result: boolean = true;\r\n\r\n    if (this.GetTableById(tableUId) === null)\r\n      result = false;\r\n\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   inserts a table into the manager is not already exists\r\n  ///   returns true is insert succeeded false otherwise\r\n  /// </summary>\r\n  InsertTable(table: TableCache): boolean {\r\n    let result: boolean = false;\r\n\r\n    if (!this.TableExists(table.GetTableUniqueId())) {\r\n      this._tables.set_Item(table.GetTableUniqueId(), table);\r\n      result = true;\r\n    }\r\n\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   loads a new table start the table parsing process\r\n  ///   delete any old instances of the same table (even if they other unique ids\r\n  /// </summary>\r\n  async LoadTable(tableUId: string): Promise<void> {\r\n    let server: CommandsProcessorBase = RemoteCommandsProcessor.GetInstance();\r\n\r\n    // the table must exist in the hashTable at this stage else it is an error\r\n    if (this.TableExists(tableUId)) {\r\n      // get the table\r\n      let current: TableCache = <TableCache>this._tables.get_Item(tableUId);\r\n      try {\r\n        let residentTableContentStr: string = await server.GetContent(tableUId, true);\r\n        try {\r\n          RuntimeContextBase.Instance.Parser.loadTableCacheData(residentTableContentStr);\r\n        }\r\n        catch (innerException) {\r\n          if (innerException instanceof Exception) {\r\n            throw new ApplicationException(\"Unable to parse resident table \" + tableUId + \", due to unsupported encoding.\", innerException);\r\n          }\r\n          else\r\n            throw innerException;\r\n        }\r\n      }\r\n      catch (throwable) {\r\n        if (throwable instanceof Exception) {\r\n          Misc.WriteStackTrace(throwable);\r\n        }\r\n        else\r\n          throw throwable;\r\n      }\r\n\r\n      // start parsing\r\n      current.FillData();\r\n\r\n      // delete old tables\r\n      let deletedUids: List<string> = new List<string>();\r\n      let enumerator: Array_Enumerator<TableCache> = this._tables.Values;\r\n      while (enumerator.MoveNext()) {\r\n        let tbl: TableCache = <TableCache>enumerator.Current;\r\n        let currIdent: string = tbl.GetTableCommonIdentifier();\r\n        if (currIdent === current.GetTableCommonIdentifier() && tbl.GetTableUniqueId() !== tableUId)\r\n          deletedUids.push(tbl.GetTableUniqueId());\r\n      }\r\n      // delete\r\n      for (let i: number = 0; i < deletedUids.length; i = i + 1) {\r\n        this._tables.Remove(deletedUids.get_Item(i));\r\n      }\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2022/src/rt/Transaction.mjs

@@ -0,0 +1,53 @@
+import { ConstInterface } from "../ConstInterface";
+export class Transaction {
+    _transId = null;
+    _afterTransRetry = ConstInterface.RECOVERY_NONE;
+    _transBegin = '\0';
+    Opened = false;
+    OwnerTask = null;
+    constructor(task, setTransId) {
+        this.OwnerTask = task;
+        this._transId = setTransId;
+        this._transBegin = ConstInterface.TRANS_TASK_PREFIX;
+    }
+    isOwner(task) {
+        return task === this.OwnerTask;
+    }
+    close() {
+        this.Opened = false;
+    }
+    open() {
+        this.Opened = true;
+    }
+    isOpened() {
+        return this.Opened;
+    }
+    setAfterRetry(val) {
+        this._afterTransRetry = val;
+    }
+    getAfterRetry(recovery) {
+        if (arguments.length === 0) {
+            return this.getAfterRetry_0();
+        }
+        return this.getAfterRetry_1(recovery);
+    }
+    getAfterRetry_0() {
+        return this._afterTransRetry !== ConstInterface.RECOVERY_NONE;
+    }
+    getAfterRetry_1(recovery) {
+        return this._afterTransRetry === recovery;
+    }
+    getLevel() {
+        return this._transBegin;
+    }
+    setTransBegin(val) {
+        this._transBegin = val;
+    }
+    getTransId() {
+        return this._transId;
+    }
+    setOwnerTask(task) {
+        this.OwnerTask = task;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVHJhbnNhY3Rpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9lbmdpbmUvc3JjL3J0L1RyYW5zYWN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBQyxjQUFjLEVBQUMsTUFBTSxtQkFBbUIsQ0FBQztBQUdqRCxNQUFNLE9BQU8sV0FBVztJQUNkLFFBQVEsR0FBVyxJQUFJLENBQUM7SUFHeEIsZ0JBQWdCLEdBQVcsY0FBYyxDQUFDLGFBQWEsQ0FBQztJQUV4RCxXQUFXLEdBQVcsSUFBSSxDQUFDO0lBQ25DLE1BQU0sR0FBWSxLQUFLLENBQUM7SUFDeEIsU0FBUyxHQUFTLElBQUksQ0FBQztJQVF2QixZQUFZLElBQWMsRUFBRSxVQUFrQjtRQUM1QyxJQUFJLENBQUMsU0FBUyxHQUFTLElBQUksQ0FBQztRQUM1QixJQUFJLENBQUMsUUFBUSxHQUFHLFVBQVUsQ0FBQztRQUMzQixJQUFJLENBQUMsV0FBVyxHQUFHLGNBQWMsQ0FBQyxpQkFBaUIsQ0FBUztJQUM5RCxDQUFDO0lBTUQsT0FBTyxDQUFDLElBQVU7UUFDaEIsT0FBTyxJQUFJLEtBQUssSUFBSSxDQUFDLFNBQVMsQ0FBQztJQUNqQyxDQUFDO0lBS0QsS0FBSztRQUNILElBQUksQ0FBQyxNQUFNLEdBQUcsS0FBSyxDQUFDO0lBQ3RCLENBQUM7SUFLRCxJQUFJO1FBQ0YsSUFBSSxDQUFDLE1BQU0sR0FBRyxJQUFJLENBQUM7SUFDckIsQ0FBQztJQUtELFFBQVE7UUFDTixPQUFPLElBQUksQ0FBQyxNQUFNLENBQUM7SUFDckIsQ0FBQztJQUtELGFBQWEsQ0FBQyxHQUFXO1FBQ3ZCLElBQUksQ0FBQyxnQkFBZ0IsR0FBRyxHQUFHLENBQUM7SUFDOUIsQ0FBQztJQUlELGFBQWEsQ0FBQyxRQUFpQjtRQUM3QixJQUFJLFNBQVMsQ0FBQyxNQUFNLEtBQUssQ0FBQyxFQUFFO1lBQzFCLE9BQU8sSUFBSSxDQUFDLGVBQWUsRUFBRSxDQUFDO1NBQy9CO1FBQ0QsT0FBTyxJQUFJLENBQUMsZUFBZSxDQUFDLFFBQVEsQ0FBQyxDQUFDO0lBQ3hDLENBQUM7SUFLTyxlQUFlO1FBQ3JCLE9BQU8sSUFBSSxDQUFDLGdCQUFnQixLQUFLLGNBQWMsQ0FBQyxhQUFhLENBQVM7SUFDeEUsQ0FBQztJQUtPLGVBQWUsQ0FBQyxRQUFnQjtRQUN0QyxPQUFPLElBQUksQ0FBQyxnQkFBZ0IsS0FBSyxRQUFRLENBQUM7SUFDNUMsQ0FBQztJQUtELFFBQVE7UUFDTixPQUFPLElBQUksQ0FBQyxXQUFXLENBQUM7SUFDMUIsQ0FBQztJQUtELGFBQWEsQ0FBQyxHQUFXO1FBQ3ZCLElBQUksQ0FBQyxXQUFXLEdBQUcsR0FBRyxDQUFDO0lBQ3pCLENBQUM7SUFLRCxVQUFVO1FBQ1IsT0FBTyxJQUFJLENBQUMsUUFBUSxDQUFDO0lBQ3ZCLENBQUM7SUFLRCxZQUFZLENBQUMsSUFBVTtRQUNyQixJQUFJLENBQUMsU0FBUyxHQUFHLElBQUksQ0FBQztJQUN4QixDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1Rhc2t9IGZyb20gXCIuLi90YXNrcy9UYXNrXCI7XHJcbmltcG9ydCB7Q29uc3RJbnRlcmZhY2V9IGZyb20gXCIuLi9Db25zdEludGVyZmFjZVwiO1xyXG5pbXBvcnQge1Rhc2tCYXNlfSBmcm9tIFwiLi4vdGFza3MvVGFza0Jhc2VcIjtcclxuXHJcbmV4cG9ydCBjbGFzcyBUcmFuc2FjdGlvbiB7XHJcbiAgcHJpdmF0ZSBfdHJhbnNJZDogc3RyaW5nID0gbnVsbDtcclxuXHJcbiAgLy8gaG9sZHMgdGhlIHJlY292ZXJ5IHR5cGUgb2YgYSBmYWlsZWQgdHJhbnNhY3Rpb24gc28gd2UgY2FuIGFzayBpZiB3ZSBhcmUgYWZ0ZXIgcmV0cnkuXHJcbiAgcHJpdmF0ZSBfYWZ0ZXJUcmFuc1JldHJ5OiBzdHJpbmcgPSBDb25zdEludGVyZmFjZS5SRUNPVkVSWV9OT05FO1xyXG5cclxuICBwcml2YXRlIF90cmFuc0JlZ2luOiBzdHJpbmcgPSAnXFwwJztcclxuICBPcGVuZWQ6IGJvb2xlYW4gPSBmYWxzZTtcclxuICBPd25lclRhc2s6IFRhc2sgPSBudWxsO1xyXG5cclxuXHJcbiAgLy8vIDxzdW1tYXJ5PlxyXG4gIC8vLyAgIENUT1JcclxuICAvLy8gPC9zdW1tYXJ5PlxyXG4gIC8vLyA8cGFyYW0gbmFtZSA9IFwidGFza1wiPnRoZSB0YXNrIHdobyBvd25zIHRoaXMgdHJhbnNhY3Rpb24gPC9wYXJhbT5cclxuICAvLy8gPHBhcmFtIG5hbWU9XCJzZXRUcmFuc0lkXCI+PC9wYXJhbT5cclxuICBjb25zdHJ1Y3Rvcih0YXNrOiBUYXNrQmFzZSwgc2V0VHJhbnNJZDogc3RyaW5nKSB7XHJcbiAgICB0aGlzLk93bmVyVGFzayA9IDxUYXNrPnRhc2s7XHJcbiAgICB0aGlzLl90cmFuc0lkID0gc2V0VHJhbnNJZDtcclxuICAgIHRoaXMuX3RyYW5zQmVnaW4gPSBDb25zdEludGVyZmFjZS5UUkFOU19UQVNLX1BSRUZJWCAvKidUJyovO1xyXG4gIH1cclxuXHJcbiAgLy8vIDxzdW1tYXJ5PlxyXG4gIC8vLyAgIHJldHVybnMgdHJ1ZSBpZiB0aGUgZ2l2ZW4gdGFzayBpcyB0aGUgb3duZXIgb2YgdGhpcyB0cmFuc2FjdGlvblxyXG4gIC8vLyA8L3N1bW1hcnk+XHJcbiAgLy8vIDxwYXJhbSBuYW1lID0gXCJ0YXNrXCI+dGhlIHRhc2sgdG8gY2hlY2sgPC9wYXJhbT5cclxuICBpc093bmVyKHRhc2s6IFRhc2spOiBib29sZWFuIHtcclxuICAgIHJldHVybiB0YXNrID09PSB0aGlzLk93bmVyVGFzaztcclxuICB9XHJcblxyXG4gIC8vLyA8c3VtbWFyeT5cclxuICAvLy8gICBjbG9zZSB0aGUgdHJhbnNhY3Rpb25cclxuICAvLy8gPC9zdW1tYXJ5PlxyXG4gIGNsb3NlKCk6IHZvaWQge1xyXG4gICAgdGhpcy5PcGVuZWQgPSBmYWxzZTtcclxuICB9XHJcblxyXG4gIC8vLyA8c3VtbWFyeT5cclxuICAvLy8gICBvcGVucyB0aGUgdHJhbnNhY3Rpb24gLSBzaG91bGQgYmUgY2FsbGVkIHdoZW4gYW4gdXBkYXRlIG9jY3VyZWRcclxuICAvLy8gPC9zdW1tYXJ5PlxyXG4gIG9wZW4oKTogdm9pZCB7XHJcbiAgICB0aGlzLk9wZW5lZCA9IHRydWU7XHJcbiAgfVxyXG5cclxuICAvLy8gPHN1bW1hcnk+XHJcbiAgLy8vICAgcmV0dXJucyB0cnVlIGlmIHRoZSB0cmFuc2FjdGlvbiB3YXMgb3BlbmVkXHJcbiAgLy8vIDwvc3VtbWFyeT5cclxuICBpc09wZW5lZCgpOiBib29sZWFuIHtcclxuICAgIHJldHVybiB0aGlzLk9wZW5lZDtcclxuICB9XHJcblxyXG4gIC8vLyA8c3VtbWFyeT5cclxuICAvLy8gICBzaWduYWxscyB3aGVhdGhlciB3ZSBhcmUgbm93IGluIHRoZSBwcm9jZXNzIG9mIHJldHJ5aW5nIGEgZmFpbGVkIHRyYW5zYWN0aW9uXHJcbiAgLy8vIDwvc3VtbWFyeT5cclxuICBzZXRBZnRlclJldHJ5KHZhbDogc3RyaW5nKTogdm9pZCB7XHJcbiAgICB0aGlzLl9hZnRlclRyYW5zUmV0cnkgPSB2YWw7XHJcbiAgfVxyXG5cclxuICBnZXRBZnRlclJldHJ5KCk6IGJvb2xlYW47XHJcbiAgZ2V0QWZ0ZXJSZXRyeShyZWNvdmVyeTogc3RyaW5nKTogYm9vbGVhbjtcclxuICBnZXRBZnRlclJldHJ5KHJlY292ZXJ5Pzogc3RyaW5nKTogYm9vbGVhbiB7XHJcbiAgICBpZiAoYXJndW1lbnRzLmxlbmd0aCA9PT0gMCkge1xyXG4gICAgICByZXR1cm4gdGhpcy5nZXRBZnRlclJldHJ5XzAoKTtcclxuICAgIH1cclxuICAgIHJldHVybiB0aGlzLmdldEFmdGVyUmV0cnlfMShyZWNvdmVyeSk7XHJcbiAgfVxyXG5cclxuICAvLy8gPHN1bW1hcnk+XHJcbiAgLy8vICAgcmV0dXJuIHRydWUgaWYgd2UgYXJlIGFmdGVyIGEgdHJhbnNhY3Rpb24gcmV0cnlcclxuICAvLy8gPC9zdW1tYXJ5PlxyXG4gIHByaXZhdGUgZ2V0QWZ0ZXJSZXRyeV8wKCk6IGJvb2xlYW4ge1xyXG4gICAgcmV0dXJuIHRoaXMuX2FmdGVyVHJhbnNSZXRyeSAhPT0gQ29uc3RJbnRlcmZhY2UuUkVDT1ZFUllfTk9ORSAvKidcdTAwMDAnKi87XHJcbiAgfVxyXG5cclxuICAvLy8gPHN1bW1hcnk+XHJcbiAgLy8vICAgcmV0dXJuIHRydWUgaWYgd2UgYXJlIGFmdGVyIGEgdHJhbnNhY3Rpb24gd2l0aCByZWNvdmVyeSBSRUNPVkVSWV9SRVRSWVxyXG4gIC8vLyA8L3N1bW1hcnk+XHJcbiAgcHJpdmF0ZSBnZXRBZnRlclJldHJ5XzEocmVjb3Zlcnk6IHN0cmluZyk6IGJvb2xlYW4ge1xyXG4gICAgcmV0dXJuIHRoaXMuX2FmdGVyVHJhbnNSZXRyeSA9PT0gcmVjb3Zlcnk7XHJcbiAgfVxyXG5cclxuICAvLy8gPHN1bW1hcnk+XHJcbiAgLy8vICAgcmV0dXJucyB0aGUgdHJhbnNhY3Rpb24gbGV2ZWwgKFRhc2svUmVjb3JkKVxyXG4gIC8vLyA8L3N1bW1hcnk+XHJcbiAgZ2V0TGV2ZWwoKTogc3RyaW5nIHtcclxuICAgIHJldHVybiB0aGlzLl90cmFuc0JlZ2luO1xyXG4gIH1cclxuXHJcbiAgLy8vIDxzdW1tYXJ5PlxyXG4gIC8vLyAgIHNldHMgdGhlIGxldmVsIG9mIHRoZSBUcmFuc2FjdGlvblxyXG4gIC8vLyA8L3N1bW1hcnk+XHJcbiAgc2V0VHJhbnNCZWdpbih2YWw6IHN0cmluZyk6IHZvaWQge1xyXG4gICAgdGhpcy5fdHJhbnNCZWdpbiA9IHZhbDtcclxuICB9XHJcblxyXG4gIC8vLyA8c3VtbWFyeT5cclxuICAvLy8gICBnZXRzIHRyYW5zSWRcclxuICAvLy8gPC9zdW1tYXJ5PlxyXG4gIGdldFRyYW5zSWQoKTogc3RyaW5nIHtcclxuICAgIHJldHVybiB0aGlzLl90cmFuc0lkO1xyXG4gIH1cclxuXHJcbiAgLy8vIDxzdW1tYXJ5PlxyXG4gIC8vLyAgIHNldHMgT3duZXIgdGFza1xyXG4gIC8vLyA8L3N1bW1hcnk+XHJcbiAgc2V0T3duZXJUYXNrKHRhc2s6IFRhc2spOiB2b2lkIHtcclxuICAgIHRoaXMuT3duZXJUYXNrID0gdGFzaztcclxuICB9XHJcbn1cclxuIl19

package/esm2022/src/security/UserDetails.mjs

@@ -0,0 +1,71 @@
+import { NString } from '@magic-xpa/mscorelib';
+import { Logger, XMLConstants, XmlParser } from '@magic-xpa/utils';
+import { ConstInterface } from '../ConstInterface';
+import { Commands } from '@magic-xpa/gui';
+export class UserDetails {
+    static _instance = null;
+    UserName = null;
+    UserID = null;
+    UserInfo = null;
+    Password = null;
+    IsLoggedIn = false;
+    setIsLoggedIn(value) {
+        this.IsLoggedIn = value;
+    }
+    getIsLoggedIn() {
+        return this.IsLoggedIn;
+    }
+    setUserID(userId) {
+        this.UserID = userId;
+        if (this.UserID.length == 0 || this.UserID === NString.Empty) {
+            this.setIsLoggedIn(false);
+        }
+        else
+            this.setIsLoggedIn(true);
+    }
+    static get Instance() {
+        if (UserDetails._instance === null)
+            UserDetails._instance = new UserDetails();
+        return UserDetails._instance;
+    }
+    constructor() {
+        this.UserName = NString.Empty;
+        this.UserInfo = NString.Empty;
+        this.IsLoggedIn = false;
+        this.setUserID(NString.Empty);
+    }
+    fillData(parser) {
+        let tokensVector;
+        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_USER_DETAILS) + ConstInterface.MG_TAG_USER_DETAILS.length);
+            tokensVector = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);
+            this.initElements(tokensVector);
+            parser.setCurrIndex(endContext + XMLConstants.TAG_TERM.length);
+        }
+        else
+            Logger.Instance.WriteExceptionToLogWithMsg("in UserDetails.fillData(): out of bounds");
+    }
+    initElements(tokensVector) {
+        let attribute, valueStr;
+        let isSuccess = true;
+        let j;
+        for (j = 0; j < tokensVector.length; j += 2) {
+            attribute = tokensVector.get_Item(j);
+            valueStr = tokensVector.get_Item(j + 1);
+            switch (attribute) {
+                case ConstInterface.MG_TAG_IS_LOGGED_IN:
+                    this.setIsLoggedIn(valueStr[0] === '1');
+                    Commands.addIsLoggedIn(this.getIsLoggedIn());
+                    break;
+                default:
+                    Logger.Instance.WriteExceptionToLogWithMsg("in UserDetails.initElements(): unknown attribute: " + attribute);
+                    isSuccess = false;
+                    break;
+            }
+        }
+        return isSuccess;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"UserDetails.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/security/UserDetails.ts"],"names":[],"mappings":"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","sourcesContent":["import { List, NString } from '@magic-xpa/mscorelib';\r\nimport { Logger, XMLConstants, XmlParser } from '@magic-xpa/utils';\r\nimport { ConstInterface } from '../ConstInterface';\r\nimport { Commands } from '@magic-xpa/gui';\r\n\r\n// This class is used to manage the user details on the client side.\r\n// The user details are sent from the server.\r\n// @dynamic\r\nexport class UserDetails {\r\n  private static _instance: UserDetails  = null;\r\n  UserName: string = null;  // user name obtained from the server.\r\n  UserID: string = null; // userID obtained from the server\r\n  UserInfo: string = null; // user info obtained from the server\r\n  Password: string = null; // Password obtained from server.\r\n  IsLoggedIn: boolean= false;\r\n\r\n  private setIsLoggedIn(value: boolean) {\r\n    this.IsLoggedIn = value;\r\n  }\r\n\r\n  getIsLoggedIn() {\r\n    return this.IsLoggedIn;\r\n  }\r\n\r\n  private setUserID(userId : string)\r\n  {\r\n    this.UserID = userId;\r\n    if ( this.UserID.length == 0 || this.UserID === NString.Empty){\r\n      this.setIsLoggedIn(false);\r\n    }\r\n    else\r\n      this.setIsLoggedIn(true);\r\n  }\r\n  static get Instance(): UserDetails {\r\n    if (UserDetails._instance === null)\r\n      UserDetails._instance = new UserDetails();\r\n    return UserDetails._instance;\r\n  }\r\n\r\n  /// <summary>Private CTOR as part of making this class a singleton/// </summary>\r\n  constructor() {\r\n    this.UserName = NString.Empty;\r\n    this.UserInfo = NString.Empty;\r\n    this.IsLoggedIn = false;\r\n    this.setUserID(NString.Empty);\r\n  }\r\n\r\n  /// <summary>\r\n  /// This function gets the xml tag containing user info.\r\n  /// </summary>\r\n  public fillData(parser: XmlParser): void {\r\n    //let parser: XmlParser = ClientManager.Instance.RuntimeCtx.Parser;\r\n    let tokensVector: List<string>;\r\n\r\n    let endContext: number = parser.getXMLdata().indexOf(XMLConstants.TAG_TERM, parser.getCurrIndex());\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_USER_DETAILS) + ConstInterface.MG_TAG_USER_DETAILS.length);\r\n      tokensVector = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);\r\n      this.initElements(tokensVector);\r\n      parser.setCurrIndex(endContext + XMLConstants.TAG_TERM.length); // to delete \">\" too\r\n    }\r\n    else\r\n      Logger.Instance.WriteExceptionToLogWithMsg(\"in UserDetails.fillData(): out of bounds\");\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"tokensVector\"></param>\r\n  /// <returns></returns>\r\n  private initElements(tokensVector: List<String>): boolean {\r\n    let attribute: String, valueStr;\r\n    let isSuccess: boolean = true;\r\n    let j: number;\r\n\r\n    for (j = 0; j < tokensVector.length; j += 2) {\r\n      attribute = (<String>tokensVector.get_Item(j));\r\n      valueStr = (<String>tokensVector.get_Item(j + 1));\r\n\r\n      switch (attribute) {\r\n        case ConstInterface.MG_TAG_IS_LOGGED_IN:\r\n          this.setIsLoggedIn(valueStr[0] === '1');\r\n          Commands.addIsLoggedIn(this.getIsLoggedIn());\r\n          //this.setIsLoggedIn(XmlParser.getBoolean(valueStr));\r\n          break;\r\n        // case ConstInterface.MG_TAG_USERNAME:\r\n        //   this.UserName = valueStr;\r\n        //   break;\r\n        // case ConstInterface.MG_ATTR_USERID:\r\n        //   valueStr = StrUtil.rtrim(valueStr);\r\n        //   this.setUserID(valueStr);\r\n        //   //ClientManager.Instance.setUsername(this.UserID);\r\n        //   break;\r\n        // case ConstInterface.MG_ATTR_USERINFO:\r\n        //   this.UserInfo = valueStr;\r\n        //   break;\r\n        // case ConstInterface.MG_TAG_PASSWORD:\r\n        //   this.Password = valueStr;\r\n        //   let passwordDecoded: Uint8Array = Base64.decodeToByte(this.Password);\r\n        //   let encryptedPassword: string = Encoding.UTF8.GetString(passwordDecoded, 0, passwordDecoded.length);\r\n        //   let decryptedPassword: string = Scrambler.UnScramble(encryptedPassword, 0, encryptedPassword.length - 1);\r\n        //   // At server side spaces are added at the end if the length of password is less than 4 characters.\r\n        //   // Remove these extra spaces before setting the password.\r\n        //   decryptedPassword = StrUtil.rtrim(decryptedPassword);\r\n        //   // if the password is empty set a password containing one \" \", as for userId, where if no userId\r\n        //   // then a \" \" set to userId.\r\n        //   if (NString.IsNullOrEmpty(decryptedPassword))\r\n        //     decryptedPassword = \" \";\r\n        //   //ClientManager.Instance.setPassword(decryptedPassword);\r\n        //   break;\r\n        default:\r\n          Logger.Instance.WriteExceptionToLogWithMsg(\"in UserDetails.initElements(): unknown attribute: \" + attribute);\r\n          isSuccess = false;\r\n          break;\r\n      }\r\n    }\r\n    return isSuccess;\r\n  }\r\n}\r\n"]}

package/{esm2020 → esm2022}/src/tasks/IMGDataCollection.mjs

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