@magic-xpa/mscorelib 4.1200.0-dev4120.21 → 4.1200.0-dev4120.212

package/fesm2022/magic-xpa-mscorelib.mjs

@@ -10,6 +10,9 @@ function isUndefined(object) {
     return object == undefined;
 }
 
+/// <summary>
+/// The base class of all exceptions
+/// </summary>
 class Exception {
     name = "Exception";
     message = "";
@@ -27,15 +30,25 @@ class Exception {
             }
         }
     }
+    /// <summary>
+    /// get the message of exception
+    /// </summary>
     get Message() {
         return this.message;
     }
+    /// <summary>
+    /// get the stack trace of exception
+    /// </summary>
     get StackTrace() {
         let stackTrace = this.stack || '';
         let stackLines = stackTrace.split("\n").map(function (line) { return line.trim(); });
+        // On some browsers (e.g. Chrome), the statck includes a title as "Error", so remove it.
         stackTrace = stackLines.splice(stackLines[0] === 'Error' ? this.errorLevel + 1 : this.errorLevel).join("\n");
         return "\n" + stackTrace;
     }
+    /// <summary>
+    /// get the type of exception
+    /// </summary>
     GetType() {
         return this.name;
     }
@@ -68,17 +81,33 @@ class Array_Enumerator {
     }
 }
 
+/// <summary>
+///  Manages a compact array of bit values,
+//   which are represented as Booleans, where true indicates that the bit is on (1) and false indicates the bit is off (0).
+/// </summary>
 class BitArray {
-    array = null;
+    array = null; // array of boolean values
+    /// <summary>
+    ///  returns the length of array
+    /// </summary>
+    /// <returns></returns>
     get Length() {
         return this.array.length;
     }
     constructor(length) {
         this.array = new Array(length).fill(false);
     }
+    /// <summary>
+    /// get the value of flag at specified index
+    /// </summary>
+    /// <returns></returns>
     Get(index) {
         return this.array[index];
     }
+    /// <summary>
+    /// set the value of flag at specified index
+    /// </summary>
+    /// <returns></returns>
     Set(index, value) {
         this.array[index] = value;
     }
@@ -98,12 +127,17 @@ var DateTimeKind;
     DateTimeKind[DateTimeKind["Local"] = 0] = "Local";
     DateTimeKind[DateTimeKind["Utc"] = 1] = "Utc";
 })(DateTimeKind || (DateTimeKind = {}));
+// @dynamic
 class DateTime {
     dt = null;
     kind = null;
+    // the number of .net ticks at the unix epoch
     epochTicks = 621355968000000000;
+    // there are 10000 .net ticks per millisecond
     ticksPerMillisecond = 10000;
     get Ticks() {
+        // https://stackoverflow.com/questions/7966559/how-to-convert-javascript-date-object-to-ticks
+        // TODO - check if we need this or to use Misc.getSystemMilliseconds()
         return ((this.dt.getTime() * this.ticksPerMillisecond) + this.epochTicks) - (this.dt.getTimezoneOffset() * 600000000);
     }
     get Year() {
@@ -236,6 +270,11 @@ class Encoding {
             bytes = this.textEncoder.encode(str);
         }
         catch (ex) {
+            // In C#, if any character is not within the range of specified charset, it is replaced by '?'.
+            // TextEncoder.encode() throws an error in such a case.
+            // We can modify the implementation of TextEncoder.encode() to put '?' instead of throwing error.
+            // But, it can be problematic if we change the library version.
+            // So, we will catch this error and handle the encoding ourselves.
             bytes = new Uint8Array(str.length * 3);
             let bytesCount = 0;
             let tmpBytes;
@@ -254,6 +293,7 @@ class Encoding {
         return bytes;
     }
     GetByteCount(str) {
+        // TODO: this is not the best way.
         return this.GetBytes(str).length;
     }
     GetString(bytes, index, count) {
@@ -278,57 +318,62 @@ class Encoding {
     }
     static PopulateCodePageToEncodingMap() {
         let hashTable = new Object;
-        hashTable[20106] = "DIN_66003";
-        hashTable[20107] = "SEN_850200_B";
-        hashTable[50932] = "_autodetect";
-        hashTable[20108] = "NS_4551-1";
-        hashTable[50949] = "_autodetect_kr";
-        hashTable[950] = "big5";
-        hashTable[50221] = "csISO2022JP";
-        hashTable[51949] = "euc-kr";
-        hashTable[936] = "gb2312";
-        hashTable[52936] = "hz-gb-2312";
-        hashTable[852] = "ibm852";
-        hashTable[866] = "ibm866";
-        hashTable[20105] = "irv";
-        hashTable[50220] = "iso-2022-jp";
-        hashTable[50222] = "iso-2022-jp";
-        hashTable[50225] = "iso-2022-kr";
-        hashTable[28591] = "iso-8859-1";
-        hashTable[28592] = "iso-8859-2";
-        hashTable[28593] = "iso-8859-3";
-        hashTable[28594] = "iso-8859-4";
-        hashTable[28595] = "iso-8859-5";
-        hashTable[28596] = "iso-8859-6";
-        hashTable[28597] = "iso-8859-7";
-        hashTable[28598] = "iso-8859-8";
-        hashTable[20866] = "koi8-r";
-        hashTable[949] = "ks_c_5601";
-        hashTable[932] = "shift-jis";
-        hashTable[1200] = "unicode";
-        hashTable[1201] = "unicodeFEFF";
-        hashTable[65000] = "utf-7";
-        hashTable[65001] = "utf-8";
-        hashTable[1250] = "windows-1250";
-        hashTable[1251] = "windows-1251";
-        hashTable[1252] = "windows-1252";
-        hashTable[1253] = "windows-1253";
-        hashTable[1254] = "windows-1254";
-        hashTable[1255] = "windows-1255";
-        hashTable[1256] = "windows-1256";
-        hashTable[1257] = "windows-1257";
-        hashTable[1258] = "windows-1258";
-        hashTable[874] = "windows-874";
-        hashTable[20127] = "US-ASCII";
-        hashTable[51932] = "x-euc";
+        // These map is similar to enc_map_table of exp_xml.cpp
+        hashTable[20106] = "DIN_66003"; // IA5 (German)
+        hashTable[20107] = "SEN_850200_B"; // IA5 (Swedish)
+        hashTable[50932] = "_autodetect"; // Japanese (Auto Select)
+        hashTable[20108] = "NS_4551-1"; // IA5 (Norwegian)
+        hashTable[50949] = "_autodetect_kr"; // Korean (Auto Select)
+        hashTable[950] = "big5"; // Chinese Traditional (Big5)
+        hashTable[50221] = "csISO2022JP"; // Japanese (JIS-Allow 1 byte Kana)
+        hashTable[51949] = "euc-kr"; // Korean (EUC)
+        hashTable[936] = "gb2312"; // Chinese Simplified (GB2312)
+        hashTable[52936] = "hz-gb-2312"; // Chinese Simplified (HZ)
+        hashTable[852] = "ibm852"; // Central European (DOS)
+        hashTable[866] = "ibm866"; // Cyrillic Alphabet (DOS)
+        hashTable[20105] = "irv"; // IA5 (IRV)
+        hashTable[50220] = "iso-2022-jp"; // Japanese (JIS)
+        hashTable[50222] = "iso-2022-jp"; // Japanese (JIS-Allow 1 byte Kana)
+        hashTable[50225] = "iso-2022-kr"; // Korean (ISO)
+        hashTable[28591] = "iso-8859-1"; // Western Alphabet (ISO)
+        hashTable[28592] = "iso-8859-2"; // Central European Alphabet (ISO)
+        hashTable[28593] = "iso-8859-3"; // Latin 3 Alphabet (ISO)
+        hashTable[28594] = "iso-8859-4"; // Baltic Alphabet (ISO)
+        hashTable[28595] = "iso-8859-5"; // Cyrillic Alphabet (ISO)
+        hashTable[28596] = "iso-8859-6"; // Arabic Alphabet (ISO)
+        hashTable[28597] = "iso-8859-7"; // Greek Alphabet (ISO)
+        hashTable[28598] = "iso-8859-8"; // Hebrew Alphabet (ISO)
+        hashTable[20866] = "koi8-r"; // Cyrillic Alphabet (KOI8-R)
+        hashTable[949] = "ks_c_5601"; // Korean
+        hashTable[932] = "shift-jis"; // Japanese (Shift-JIS)
+        hashTable[1200] = "unicode"; // Universal Alphabet
+        hashTable[1201] = "unicodeFEFF"; // Universal Alphabet (Big-Endian)
+        hashTable[65000] = "utf-7"; // Universal Alphabet (UTF-7)
+        hashTable[65001] = "utf-8"; // Universal Alphabet (UTF-8)
+        hashTable[1250] = "windows-1250"; // Central European Alphabet (Windows)
+        hashTable[1251] = "windows-1251"; // Cyrillic Alphabet (Windows)
+        hashTable[1252] = "windows-1252"; // Western Alphabet (Windows)
+        hashTable[1253] = "windows-1253"; // Greek Alphabet (Windows)
+        hashTable[1254] = "windows-1254"; // Turkish Alphabet
+        hashTable[1255] = "windows-1255"; // Hebrew Alphabet (Windows)
+        hashTable[1256] = "windows-1256"; // Arabic Alphabet (Windows)
+        hashTable[1257] = "windows-1257"; // Baltic Alphabet (Windows)
+        hashTable[1258] = "windows-1258"; // Vietnamese Alphabet (Windows)
+        hashTable[874] = "windows-874"; // Thai (Windows)
+        hashTable[20127] = "US-ASCII"; // us-ascii
+        hashTable[51932] = "x-euc"; // Japanese (EUC)
         return hashTable;
     }
+    // return the name of encoding used 
     toString() {
         return this.label;
     }
 }
 
+// Reference: https://github.com/rkostrzewski/hashtable-ts/blob/master/src/hashtable.ts
 class HashUtils {
+    // Pay attention that in server there is the same function and it must
+    // return the same hash value.
     static GetHashCode(str) {
         let bytes = null;
         bytes = Encoding.UTF8.GetBytes(str);
@@ -355,9 +400,10 @@ class HashUtils {
     }
 }
 const HashTableLoadFactor = 0.75;
+// Hashtable implementation for key TKey and Value TValue
 class Hashtable {
-    _buckets = [];
-    _elementsCount = 0;
+    _buckets = []; // total no. of buckets
+    _elementsCount = 0; // total elements
     _bucketCount = 0;
     _loadFactor = 0;
     constructor(bucketCount = 8, loadFactor = HashTableLoadFactor) {
@@ -367,6 +413,7 @@ class Hashtable {
             throw new Exception('Bucket count must be a positive number and be multiple of 2.');
         }
     }
+    // Generic Hash funtion
     HashFunction(key) {
         if (typeof key.GetHashCode === 'function') {
             return key.GetHashCode();
@@ -379,9 +426,11 @@ class Hashtable {
         }
         return 0;
     }
+    // returns elementCount
     get Count() {
         return this._elementsCount;
     }
+    // returns ValueCollection (Array Enumerator)
     get Values() {
         let array = [];
         this._buckets.forEach(b => b.forEach(item => {
@@ -389,6 +438,7 @@ class Hashtable {
         }));
         return new Array_Enumerator(array);
     }
+    // returns KeyCollection (Array Enumerator)
     get Keys() {
         let array = [];
         this._buckets.forEach(b => b.forEach(item => {
@@ -396,12 +446,15 @@ class Hashtable {
         }));
         return new Array_Enumerator(array);
     }
+    // adds item to Hashtable
     Add(key, value) {
         this.Insert(key, value, true);
     }
+    // sets item in Hashtable
     set_Item(key, value) {
         this.Insert(key, value, false);
     }
+    // Insert element in Hashtable
     Insert(key, value, add) {
         let bucketIndex = this.GetBucketIndex(key);
         if (typeof this._buckets[bucketIndex] === "undefined") {
@@ -422,6 +475,7 @@ class Hashtable {
             this.Resize(this._bucketCount * 2);
         }
     }
+    // Gets value for key TKey
     get_Item(key) {
         let bucketIndex = this.GetBucketIndex(key);
         let bucket = this._buckets[bucketIndex];
@@ -434,6 +488,7 @@ class Hashtable {
         }
         return null;
     }
+    // Returns if key TKey is present in Hashtable
     ContainsKey(key) {
         let bucketIndex = this.GetBucketIndex(key);
         let bucket = this._buckets[bucketIndex];
@@ -443,6 +498,7 @@ class Hashtable {
         let itemIndex = bucket.findIndex(x => x.key === key);
         return (itemIndex > -1);
     }
+    // Removes item with key TKey from Hashtable
     Remove(key) {
         let bucketIndex = this.GetBucketIndex(key);
         let bucket = this._buckets[bucketIndex];
@@ -458,6 +514,7 @@ class Hashtable {
             }
         }
     }
+    // Resize bucket (Hashtable)
     Resize(newBucketCount) {
         let _oldBuckets = this._buckets;
         this._elementsCount = 0;
@@ -465,6 +522,7 @@ class Hashtable {
         this._bucketCount = newBucketCount;
         _oldBuckets.forEach(b => b.forEach(item => this.Add(item.key, item.value)));
     }
+    // returns bucketIndex for key
     GetBucketIndex(key) {
         let hash = this.HashFunction(key);
         if (hash % 1 !== 0) {
@@ -476,6 +534,7 @@ class Hashtable {
         }
         return index;
     }
+    // Clears Hashtable
     Clear() {
         this._elementsCount = 0;
         this._buckets = [];
@@ -577,7 +636,7 @@ class List extends Array {
     Insert(index, item) {
         if (index >= 0 && index < this.length)
             this.splice(index, 0, item);
-        else if (index === this.length)
+        else if (index === this.length) // inserting at end means append
             this.push(item);
         else
             throw new Error("index out of bounds");
@@ -604,6 +663,10 @@ class List extends Array {
             foundItem = null;
         return foundItem;
     }
+    /// <summary>
+    /// add null cells up to 'size' cells.
+    /// </summary>
+    /// <param name="size"></param>
     SetSize(size) {
         if (this.length > size) {
             this.RemoveRange(size, this.length - size);
@@ -725,6 +788,11 @@ var NumberStyles;
     NumberStyles[NumberStyles["HexNumber"] = 0] = "HexNumber";
 })(NumberStyles || (NumberStyles = {}));
 class NNumber {
+    /// <summary>
+    ///  convert a string to number
+    /// for blank string , it will return 0
+    ///  for incorrect format it will return NaN
+    /// <summary>
     static Parse(text, style) {
         if (arguments.length === 2) {
             if (style === NumberStyles.HexNumber)
@@ -732,12 +800,20 @@ class NNumber {
             else
                 throw new NotImplementedException();
         }
-        return +text;
+        return +text; // use unary + operator to convert string  to number.
     }
+    /// <summary>
+    ///  convert a string to number
+    ///  return true if string is correctly parsed i.e pvalue.value is number
+    ///  for incorrect format it will return false
+    /// <summary>
     static TryParse(str, pvalue) {
         pvalue.value = +str;
         return !isNaN(pvalue.value);
     }
+    /// <summary>
+    ///  convert a number to string with specified format
+    /// <summary>
     static ToString(num, format) {
         if (format === 'X2') {
             let res = num.toString(16);
@@ -747,6 +823,7 @@ class NNumber {
     }
 }
 
+// @dynamic
 class NString {
     static Empty = "";
     static IndexOf(str, searchStr, startIndex, count) {
@@ -796,7 +873,7 @@ class NString {
         for (i = 0, l = str.length; i < l; i++) {
             ch = str.charCodeAt(i);
             hash = ((hash << 5) - hash) + ch;
-            hash |= 0;
+            hash |= 0; // Convert to 32bit integer
         }
         return hash;
     }
@@ -851,14 +928,17 @@ class NString {
         let lenA = strA.length;
         let lenB = strB.length;
         let len = Math.min(lenA, lenB);
+        // compare character by character
         for (let i = 0; i < len; i++) {
             if (strA[i].charCodeAt(0) !== strB[i].charCodeAt(0)) {
                 return strA[i].charCodeAt(0) - strB[i].charCodeAt(0);
             }
         }
+        // if all characters are same , but length is different return the difference of length
         if (lenA !== lenB) {
             return lenA - lenB;
         }
+        // all chars are same , so strings are equal
         return 0;
     }
     static PadRight(source, maxLength, fillString) {
@@ -874,6 +954,8 @@ class NString {
     }
     static Replace(str, orgSubStr, newSubStr) {
         let resultStr = '';
+        // fixed defect 151810:  replace "*" with "\*" before we update the string so * will be as char and not reg exp
+        // also for special chars $ ^ . ? + , [
         orgSubStr = orgSubStr.replace(new RegExp("\\\\", 'g'), "\\\\");
         orgSubStr = orgSubStr.replace(new RegExp("\\*", 'g'), "\\\*");
         orgSubStr = orgSubStr.replace(new RegExp("\\$", 'g'), "\\\$");
@@ -898,7 +980,7 @@ class NumberFormatInfo {
     static NegativeSign = '-';
     static NumberDecimalSeparator = NumberFormatInfo.GetLocaleDecimalSeperator();
     static GetLocaleDecimalSeperator() {
-        return (1.1).toLocaleString()[1];
+        return (1.1).toLocaleString()[1]; // get the decimal seperator of current locale
     }
 }
 
@@ -944,6 +1026,8 @@ class Stack {
     }
 }
 
+// StackFrame uses StackTrace utility using stacktrace-js utility from npm
+// https://www.npmjs.com/package/stacktrace-js
 class StackFrame {
     stackFrame = null;
     constructor(skipFrames) {
@@ -957,20 +1041,35 @@ class StackFrame {
     }
 }
 
+// This uses StackTrace utility using stacktrace-js utility from npm. Use this in package.json
+// https://www.npmjs.com/package/stacktrace-js
 class StackTrace {
     GetFrames() {
+        // Using getSync() method, it returns references of callstack ethod from the javascript files bindled and not typeScript file from sources.
+        // However, if aSync method would have used, it overcomes above problems but the call to log would have been async and we would not have
+        // received synchronous logs which would be confusing.
         return StackTrace$1.getSync();
     }
 }
 
+// StringBuilder class. Its Implementation currently uses string object. It could have been string[], but it has issues when inserting string.
+// It would not have served purpose while inserting a string. Other  could be to use string[] with one chraracter per string. Even its utility
+// is doubtful as while manipulation, it would be creting new objects instead pointers. So for now we have used only string and see if we have
+// any performance issues.
 class StringBuilder {
     part = "";
     constructor(valueOrLength, length) {
         if (arguments.length > 0) {
             if (valueOrLength != null && valueOrLength.constructor === Number) {
+                // TODO: Very low priority performance improvement - Implement this.
+                // Debug.Assert(false, "StringBuilder: NotImplemented constructor with initial length/capacity");
+                // throw  new Error("NotImplemented constructor with initial length/capacity");
             }
             else if (valueOrLength != null && valueOrLength.constructor === String) {
                 this.part = valueOrLength.toString();
+                // TODO: Very low priority performance improvement - Implement this.
+                // if (arguments.length === 2)
+                //   Debug.Assert(false, "NotImplemented constructor with initial length/capacity");
             }
         }
     }
@@ -991,14 +1090,17 @@ class StringBuilder {
             this.AppendNumber(textOrNum, startIndexOrNumberOfCharacters);
         return this;
     }
+    // Append string
     AppendString(text, startIndex = 0, charCount = text.length) {
         this.part = this.part + text.substr(startIndex, charCount);
     }
+    // Append Number
     AppendNumber(num, numberOfCharacters = 1) {
         if (numberOfCharacters <= 0)
             throw new Error("numberOfCharacters cannot be less than or equal to zero");
         this.part = this.part + num.toString().repeat(numberOfCharacters);
     }
+    // Append Line
     AppendLine(text = null) {
         if (text !== null)
             this.part = this.part + text;
@@ -1068,6 +1170,7 @@ class StringBuilder {
         }
         return this;
     }
+    // return the string
     toString() {
         return this.ToString();
     }
@@ -1080,6 +1183,10 @@ class Thread {
     constructor() {
         this.ManagedThreadId = Thread.nextId++;
     }
+    /// <summary>
+    ///   Free the thread so it will be able to do other work, like gui events
+    /// </summary>
+    /// <param name = "millisecondsTimeout"> timeout in milliseconds</param>
     static async Sleep(millisecondsTimeout) {
         await new Promise((resolve) => {
             let timer = interval(millisecondsTimeout);
@@ -1098,10 +1205,19 @@ class WebException extends Exception {
 }
 
 class XmlConvert {
+    // TODO : Implement
     static EncodeName(name) {
         throw new NotImplementedException();
     }
 }
 
+/**
+ * @file Automatically generated by barrelsby.
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
 export { $$, $0, $9, $A, $AMPERSAND, $AT, $BACKSLASH, $BANG, $BAR, $BT, $CARET, $COLON, $COMMA, $CR, $DQ, $E, $EOF, $EQ, $F, $FF, $GT, $HASH, $LBRACE, $LBRACKET, $LF, $LPAREN, $LT, $MINUS, $NBSP, $PERCENT, $PERIOD, $PIPE, $PLUS, $QUESTION, $RBRACE, $RBRACKET, $RPAREN, $SEMICOLON, $SLASH, $SPACE, $SQ, $STAR, $TAB, $TILDA, $VTAB, $X, $Z, $_, $a, $e, $f, $n, $r, $t, $u, $v, $x, $z, ApplicationException, Array_Enumerator, BitArray, Char, CultureInfo, DateTime, DateTimeKind, Debug, Dictionary, Encoding, Exception, HashUtils, Hashtable, ISO_8859_1_Encoding, Int32, Int64, List, NChar, NNumber, NString, NotImplementedException, NumberFormatInfo, NumberStyles, RefParam, Stack, StackFrame, StackTrace, StringBuilder, Thread, WebException, XmlConvert, isAsciiHexDigit, isAsciiLetter, isDigit, isLowerCase, isNullOrUndefined, isUndefined, isUpperCase, isWhitespace };
 //# sourceMappingURL=magic-xpa-mscorelib.mjs.map