@magic-xpa/engine 4.801.0-dev481.243 → 4.801.0-dev481.249

package/esm2020/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 {
+    constructor(tableId) {
+        this._keys = null;
+        this._records = null;
+        this._currSortDir = '\0';
+        this._currSortKey = 0;
+        this.FldsTab = null;
+        this._isLoaded = false;
+        this._tableIdent = null;
+        this._tableUId = null;
+        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/esm2020/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 {
+    constructor() {
+        this._tables = null;
+        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));
+            }
+        }
+    }
+}
+TableCacheManager.Instance = new TableCacheManager();
+//# 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/{esm2015/src/tasks/IMGDataCollection.js → esm2020/src/tasks/IMGDataCollection.mjs}

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