Add Assert Shortcodes (#5619)

Now that the automation is coming together this change will apply the first set of shortcodes

related to #5409 #5529 #5552

common/lib/common-utils/src/bufferBrowser.ts

@@ -93,8 +93,8 @@ export class IsoBuffer extends Uint8Array {
         // Capture any typed arrays, including Uint8Array (and thus - IsoBuffer!)
         } else if (value !== null && typeof value === "object" && isArrayBuffer(value.buffer)) {
             // Support currently for full array, no view ports! (though it can be added in future)
-            assert(value.byteOffset === 0, "nonzero isobuffer byte offset");
-            assert(value.byteLength === value.buffer.byteLength, "unexpected isobuffer byte length");
+            assert(value.byteOffset === 0, 0x000 /* "nonzero isobuffer byte offset" */);
+            assert(value.byteLength === value.buffer.byteLength, 0x001 /* "unexpected isobuffer byte length" */);
             return IsoBuffer.fromArrayBuffer(value.buffer, encodingOrOffset as number | undefined, length);
         } else if (isArrayBuffer(value)) {
             return IsoBuffer.fromArrayBuffer(value, encodingOrOffset as number | undefined, length);

common/lib/common-utils/src/hashFileBrowser.ts

@@ -31,7 +31,7 @@ export function setInsecureContextHashFn(hashFn: (f: IsoBuffer) => Promise<strin
 export async function hashFile(file: IsoBuffer): Promise<string> {
     // Use the function override if provided
     if (insecureContextHashFn !== undefined) {
-        assert(crypto.subtle === undefined, "Both crypto.subtle and insecureContextHashFn are defined!");
+        assert(crypto.subtle === undefined, 0x002 /* "Both crypto.subtle and insecureContextHashFn are defined!" */);
         return insecureContextHashFn(file);
     }
 

common/lib/common-utils/src/rangeTracker.ts

@@ -93,9 +93,9 @@ export class RangeTracker {
     public add(primary: number, secondary: number) {
         // Both values must continuously be increasing - we won't always track the last value we saw so we do so
         // below to check invariants
-        assert(primary >= this.lastPrimary, "Primary to add to range < last primary!");
+        assert(primary >= this.lastPrimary, 0x003 /* "Primary to add to range < last primary!" */);
         if (this.lastSecondary !== undefined) {
-            assert(secondary >= this.lastSecondary, "Secondary to add to range < last secondary!");
+            assert(secondary >= this.lastSecondary, 0x004 /* "Secondary to add to range < last secondary!" */);
         }
         this.lastPrimary = primary;
         this.lastSecondary = secondary;
@@ -140,7 +140,7 @@ export class RangeTracker {
      * @returns the closest range to the primary
      */
     public get(primary: number): number {
-        assert(primary >= this.ranges[0].primary, "Target primary to retrieve < first range's primary!");
+        assert(primary >= this.ranges[0].primary, 0x005 /* "Target primary to retrieve < first range's primary!" */);
 
         // Find the first range where the starting position is greater than the primary. Our target range is
         // the one before it.
@@ -150,7 +150,8 @@ export class RangeTracker {
                 break;
             }
         }
-        assert(primary >= this.ranges[index - 1].primary, "Target primary to retrieve < last range's primary!");
+        assert(primary >= this.ranges[index - 1].primary,
+            0x006 /* "Target primary to retrieve < last range's primary!" */);
 
         // If the difference is within the stored range use it - otherwise add in the length - 1 as the highest
         // stored secondary value to use.
@@ -164,7 +165,7 @@ export class RangeTracker {
      * @param primary - the primary value to update
      */
     public updateBase(primary: number) {
-        assert(primary >= this.ranges[0].primary, "Target primary to update < first range's primary!");
+        assert(primary >= this.ranges[0].primary, 0x007 /* "Target primary to update < first range's primary!" */);
 
         // Walk the ranges looking for the first one that is greater than the primary. Primary is then within the
         // previous index by definition (since it's less than the current index's primary but greather than the
@@ -175,7 +176,8 @@ export class RangeTracker {
                 break;
             }
         }
-        assert(primary >= this.ranges[index - 1].primary, "Target primary to update < last range's primary!");
+        assert(primary >= this.ranges[index - 1].primary,
+            0x008 /* "Target primary to update < last range's primary!" */);
 
         // Update the last range values
         const range = this.ranges[index - 1];
@@ -188,6 +190,7 @@ export class RangeTracker {
         this.ranges = index - 1 > 0 ? this.ranges.slice(index - 1) : this.ranges;
 
         // Assert that the lowest value is now the input to this method
-        assert(primary === this.ranges[0].primary, "After update, target primary is not first range's primary!");
+        assert(primary === this.ranges[0].primary,
+            0x009 /* "After update, target primary is not first range's primary!" */);
     }
 }

common/lib/common-utils/src/timer.ts

@@ -148,7 +148,7 @@ export class Timer implements ITimer {
     }
 
     private handler() {
-        assert(!!this.runningState, "Running timer missing handler");
+        assert(!!this.runningState, 0x00a /* "Running timer missing handler" */);
         const restart = this.runningState.restart;
         if (restart !== undefined) {
             // Restart with remaining time
@@ -222,7 +222,7 @@ export class PromiseTimer implements IPromiseTimer {
 
     protected wrapHandler(handler: () => void) {
         handler();
-        assert(!!this.deferred, "Handler executed without deferred");
+        assert(!!this.deferred, 0x00b /* "Handler executed without deferred" */);
         this.deferred.resolve({ timerResult: "timeout" });
         this.deferred = undefined;
     }