@ni/nimble-components 21.9.1 → 21.10.1

package/dist/all-components-bundle.js

@@ -16301,7 +16301,7 @@
 
   /**
    * Do not edit directly
-   * Generated on Wed, 06 Mar 2024 17:40:30 GMT
+   * Generated on Tue, 12 Mar 2024 20:45:49 GMT
    */
 
   const Information100DarkUi = "#a46eff";
@@ -44081,7 +44081,7 @@ img.ProseMirror-separator {
       .map((c) => c.charCodeAt(0)));
 
   // Adapted from https://github.com/mathiasbynens/he/blob/36afe179392226cf1b6ccdb16ebbb7a5a844d93a/src/he.js#L106-L134
-  var _a$1;
+  var _a$2;
   const decodeMap = new Map([
       [0, 65533],
       // C1 Unicode control character reference replacements
@@ -44118,7 +44118,7 @@ img.ProseMirror-separator {
    */
   const fromCodePoint$1 = 
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, node/no-unsupported-features/es-builtins
-  (_a$1 = String.fromCodePoint) !== null && _a$1 !== void 0 ? _a$1 : function (codePoint) {
+  (_a$2 = String.fromCodePoint) !== null && _a$2 !== void 0 ? _a$2 : function (codePoint) {
       let output = "";
       if (codePoint > 0xffff) {
           codePoint -= 0x10000;
@@ -52696,7 +52696,7 @@ img.ProseMirror-separator {
       }
   }
 
-  var _a;
+  var _a$1;
   /**
    * Provides markdown parser for rich text components
    */
@@ -52820,11 +52820,11 @@ img.ProseMirror-separator {
           RichTextMarkdownParser.mentionedHrefs.clear();
       }
   }
-  _a = RichTextMarkdownParser;
+  _a$1 = RichTextMarkdownParser;
   RichTextMarkdownParser.mentionedHrefs = new Set();
-  RichTextMarkdownParser.updatedSchema = _a.getCustomSchemaConfiguration();
-  RichTextMarkdownParser.markdownParser = _a.initializeMarkdownParser();
-  RichTextMarkdownParser.domSerializer = DOMSerializer.fromSchema(_a.updatedSchema);
+  RichTextMarkdownParser.updatedSchema = _a$1.getCustomSchemaConfiguration();
+  RichTextMarkdownParser.markdownParser = _a$1.initializeMarkdownParser();
+  RichTextMarkdownParser.domSerializer = DOMSerializer.fromSchema(_a$1.updatedSchema);
 
   /**
    * Provides markdown serializer for rich text components
@@ -66059,6 +66059,16 @@ img.ProseMirror-separator {
    * A nimble-styled table.
    */
   class Table extends FoundationElement {
+      get validity() {
+          return this.tableValidator.getValidity();
+      }
+      /**
+       * @internal
+       */
+      get showRowOperationColumn() {
+          return (this.selectionMode === TableRowSelectionMode.multiple
+              || this.showCollapseAll);
+      }
       constructor() {
           super();
           this.selectionMode = TableRowSelectionMode.none;
@@ -66191,16 +66201,6 @@ img.ProseMirror-separator {
           this.selectionManager = new InteractiveSelectionManager(this.table, this.selectionMode);
           this.expansionManager = new ExpansionManager(this.table);
       }
-      get validity() {
-          return this.tableValidator.getValidity();
-      }
-      /**
-       * @internal
-       */
-      get showRowOperationColumn() {
-          return (this.selectionMode === TableRowSelectionMode.multiple
-              || this.showCollapseAll);
-      }
       async setData(newData) {
           await this.processPendingUpdates();
           const tanstackUpdates = this.calculateTanStackData(newData);
@@ -75014,11 +75014,6 @@ img.ProseMirror-separator {
    * Computations calculates and stores different measures which are used in the Wafermap
    */
   class Computations {
-      constructor(wafermap) {
-          this.wafermap = wafermap;
-          this.defaultPadding = 0;
-          this.baseMarginPercentage = 0.04;
-      }
       get containerDimensions() {
           return this._containerDimensions;
       }
@@ -75043,6 +75038,11 @@ img.ProseMirror-separator {
       get invertedVerticalScale() {
           return this._invertedVerticalScale;
       }
+      constructor(wafermap) {
+          this.wafermap = wafermap;
+          this.defaultPadding = 0;
+          this.baseMarginPercentage = 0.04;
+      }
       updateContainerDimensions() {
           const canvasDimensions = {
               width: this.wafermap.canvasWidth,
@@ -75196,6 +75196,12 @@ img.ProseMirror-separator {
    * Prerendering prepares render-ready dies data to be used by the rendering module
    */
   class Prerendering {
+      get labelsFontSize() {
+          return this._labelsFontSize;
+      }
+      get diesRenderInfo() {
+          return this._diesRenderInfo;
+      }
       constructor(wafermap, dataManager) {
           this.wafermap = wafermap;
           this.dataManager = dataManager;
@@ -75204,21 +75210,16 @@ img.ProseMirror-separator {
           this.emptyDieColor = 'rgba(218,223,236,1)';
           this.nanDieColor = 'rgba(122,122,122,1)';
       }
-      get labelsFontSize() {
-          return this._labelsFontSize;
-      }
-      get diesRenderInfo() {
-          return this._diesRenderInfo;
-      }
       updateLabelsFontSize() {
           this._labelsFontSize = this.calculateLabelsFontSize(this.dataManager.dieDimensions, this.wafermap.maxCharacters);
           this.updateDiesRenderInfo();
       }
       updateDiesRenderInfo() {
           this.d3ColorScale = this.createD3ColorScale(this.wafermap.colorScale, this.wafermap.colorScaleMode);
+          const isDieRenderInfo = (info) => info !== null;
           this._diesRenderInfo = this.wafermap.dies
               .map(die => this.computeDieRenderInfo(die))
-              .filter(info => info !== null);
+              .filter(isDieRenderInfo);
       }
       computeDieRenderInfo(die) {
           const margin = this.dataManager.margin;
@@ -75306,11 +75307,6 @@ img.ProseMirror-separator {
    * Data Manager uses Computations and Prerendering modules in order and exposes the results
    */
   class DataManager {
-      constructor(wafermap) {
-          this.wafermap = wafermap;
-          this.computations = new Computations(wafermap);
-          this.prerendering = new Prerendering(wafermap, this);
-      }
       get containerDimensions() {
           return this.computations.containerDimensions;
       }
@@ -75344,6 +75340,11 @@ img.ProseMirror-separator {
       get data() {
           return this.dataMap;
       }
+      constructor(wafermap) {
+          this.wafermap = wafermap;
+          this.computations = new Computations(wafermap);
+          this.prerendering = new Prerendering(wafermap, this);
+      }
       updateContainerDimensions() {
           this.computations.updateContainerDimensions();
           this.updateDataMap();
@@ -75723,6 +75724,599 @@ img.ProseMirror-separator {
       }
   }
 
+  // automatically generated by the FlatBuffers compiler, do not modify
+  var UnionMode;
+  (function (UnionMode) {
+      UnionMode[UnionMode["Sparse"] = 0] = "Sparse";
+      UnionMode[UnionMode["Dense"] = 1] = "Dense";
+  })(UnionMode || (UnionMode = {}));
+
+  // automatically generated by the FlatBuffers compiler, do not modify
+  var Precision;
+  (function (Precision) {
+      Precision[Precision["HALF"] = 0] = "HALF";
+      Precision[Precision["SINGLE"] = 1] = "SINGLE";
+      Precision[Precision["DOUBLE"] = 2] = "DOUBLE";
+  })(Precision || (Precision = {}));
+
+  // automatically generated by the FlatBuffers compiler, do not modify
+  var DateUnit;
+  (function (DateUnit) {
+      DateUnit[DateUnit["DAY"] = 0] = "DAY";
+      DateUnit[DateUnit["MILLISECOND"] = 1] = "MILLISECOND";
+  })(DateUnit || (DateUnit = {}));
+
+  // automatically generated by the FlatBuffers compiler, do not modify
+  var TimeUnit;
+  (function (TimeUnit) {
+      TimeUnit[TimeUnit["SECOND"] = 0] = "SECOND";
+      TimeUnit[TimeUnit["MILLISECOND"] = 1] = "MILLISECOND";
+      TimeUnit[TimeUnit["MICROSECOND"] = 2] = "MICROSECOND";
+      TimeUnit[TimeUnit["NANOSECOND"] = 3] = "NANOSECOND";
+  })(TimeUnit || (TimeUnit = {}));
+
+  // automatically generated by the FlatBuffers compiler, do not modify
+  var IntervalUnit;
+  (function (IntervalUnit) {
+      IntervalUnit[IntervalUnit["YEAR_MONTH"] = 0] = "YEAR_MONTH";
+      IntervalUnit[IntervalUnit["DAY_TIME"] = 1] = "DAY_TIME";
+      IntervalUnit[IntervalUnit["MONTH_DAY_NANO"] = 2] = "MONTH_DAY_NANO";
+  })(IntervalUnit || (IntervalUnit = {}));
+
+  // Licensed to the Apache Software Foundation (ASF) under one
+  // or more contributor license agreements.  See the NOTICE file
+  // distributed with this work for additional information
+  // regarding copyright ownership.  The ASF licenses this file
+  // to you under the Apache License, Version 2.0 (the
+  // "License"); you may not use this file except in compliance
+  // with the License.  You may obtain a copy of the License at
+  //
+  //   http://www.apache.org/licenses/LICENSE-2.0
+  //
+  // Unless required by applicable law or agreed to in writing,
+  // software distributed under the License is distributed on an
+  // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  // KIND, either express or implied.  See the License for the
+  // specific language governing permissions and limitations
+  // under the License.
+  /**
+   * Main data type enumeration.
+   *
+   * Data types in this library are all *logical*. They can be expressed as
+   * either a primitive physical type (bytes or bits of some fixed size), a
+   * nested type consisting of other data types, or another data type (e.g. a
+   * timestamp encoded as an int64).
+   *
+   * **Note**: Only non-negative enum values are written to an Arrow IPC payload.
+   *
+   * The rest of the values are specified here so TypeScript can narrow the type
+   * signatures further beyond the base Arrow Types. The Arrow DataTypes include
+   * metadata like `bitWidth` that impact the type signatures of the values we
+   * accept and return.
+   *
+   * For example, the `Int8Vector` reads 1-byte numbers from an `Int8Array`, an
+   * `Int32Vector` reads a 4-byte number from an `Int32Array`, and an `Int64Vector`
+   * reads a pair of 4-byte lo, hi 32-bit integers as a zero-copy slice from the
+   * underlying `Int32Array`.
+   *
+   * Library consumers benefit by knowing the narrowest type, since we can ensure
+   * the types across all public methods are propagated, and never bail to `any`.
+   * These values are _never_ used at runtime, and they will _never_ be written
+   * to the flatbuffers metadata of serialized Arrow IPC payloads.
+   */
+  var Type;
+  (function (Type) {
+      Type[Type["NONE"] = 0] = "NONE";
+      Type[Type["Null"] = 1] = "Null";
+      Type[Type["Int"] = 2] = "Int";
+      Type[Type["Float"] = 3] = "Float";
+      Type[Type["Binary"] = 4] = "Binary";
+      Type[Type["Utf8"] = 5] = "Utf8";
+      Type[Type["Bool"] = 6] = "Bool";
+      Type[Type["Decimal"] = 7] = "Decimal";
+      Type[Type["Date"] = 8] = "Date";
+      Type[Type["Time"] = 9] = "Time";
+      Type[Type["Timestamp"] = 10] = "Timestamp";
+      Type[Type["Interval"] = 11] = "Interval";
+      Type[Type["List"] = 12] = "List";
+      Type[Type["Struct"] = 13] = "Struct";
+      Type[Type["Union"] = 14] = "Union";
+      Type[Type["FixedSizeBinary"] = 15] = "FixedSizeBinary";
+      Type[Type["FixedSizeList"] = 16] = "FixedSizeList";
+      Type[Type["Map"] = 17] = "Map";
+      Type[Type["Duration"] = 18] = "Duration";
+      Type[Type["LargeBinary"] = 19] = "LargeBinary";
+      Type[Type["LargeUtf8"] = 20] = "LargeUtf8";
+      Type[Type["Dictionary"] = -1] = "Dictionary";
+      Type[Type["Int8"] = -2] = "Int8";
+      Type[Type["Int16"] = -3] = "Int16";
+      Type[Type["Int32"] = -4] = "Int32";
+      Type[Type["Int64"] = -5] = "Int64";
+      Type[Type["Uint8"] = -6] = "Uint8";
+      Type[Type["Uint16"] = -7] = "Uint16";
+      Type[Type["Uint32"] = -8] = "Uint32";
+      Type[Type["Uint64"] = -9] = "Uint64";
+      Type[Type["Float16"] = -10] = "Float16";
+      Type[Type["Float32"] = -11] = "Float32";
+      Type[Type["Float64"] = -12] = "Float64";
+      Type[Type["DateDay"] = -13] = "DateDay";
+      Type[Type["DateMillisecond"] = -14] = "DateMillisecond";
+      Type[Type["TimestampSecond"] = -15] = "TimestampSecond";
+      Type[Type["TimestampMillisecond"] = -16] = "TimestampMillisecond";
+      Type[Type["TimestampMicrosecond"] = -17] = "TimestampMicrosecond";
+      Type[Type["TimestampNanosecond"] = -18] = "TimestampNanosecond";
+      Type[Type["TimeSecond"] = -19] = "TimeSecond";
+      Type[Type["TimeMillisecond"] = -20] = "TimeMillisecond";
+      Type[Type["TimeMicrosecond"] = -21] = "TimeMicrosecond";
+      Type[Type["TimeNanosecond"] = -22] = "TimeNanosecond";
+      Type[Type["DenseUnion"] = -23] = "DenseUnion";
+      Type[Type["SparseUnion"] = -24] = "SparseUnion";
+      Type[Type["IntervalDayTime"] = -25] = "IntervalDayTime";
+      Type[Type["IntervalYearMonth"] = -26] = "IntervalYearMonth";
+      Type[Type["DurationSecond"] = -27] = "DurationSecond";
+      Type[Type["DurationMillisecond"] = -28] = "DurationMillisecond";
+      Type[Type["DurationMicrosecond"] = -29] = "DurationMicrosecond";
+      Type[Type["DurationNanosecond"] = -30] = "DurationNanosecond";
+  })(Type || (Type = {}));
+  var BufferType;
+  (function (BufferType) {
+      /**
+       * used in List type, Dense Union and variable length primitive types (String, Binary)
+       */
+      BufferType[BufferType["OFFSET"] = 0] = "OFFSET";
+      /**
+       * actual data, either fixed width primitive types in slots or variable width delimited by an OFFSET vector
+       */
+      BufferType[BufferType["DATA"] = 1] = "DATA";
+      /**
+       * Bit vector indicating if each value is null
+       */
+      BufferType[BufferType["VALIDITY"] = 2] = "VALIDITY";
+      /**
+       * Type vector used in Union type
+       */
+      BufferType[BufferType["TYPE"] = 3] = "TYPE";
+  })(BufferType || (BufferType = {}));
+
+  // Licensed to the Apache Software Foundation (ASF) under one
+  // or more contributor license agreements.  See the NOTICE file
+  // distributed with this work for additional information
+  // regarding copyright ownership.  The ASF licenses this file
+  // to you under the Apache License, Version 2.0 (the
+  // "License"); you may not use this file except in compliance
+  // with the License.  You may obtain a copy of the License at
+  //
+  //   http://www.apache.org/licenses/LICENSE-2.0
+  //
+  // Unless required by applicable law or agreed to in writing,
+  // software distributed under the License is distributed on an
+  // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  // KIND, either express or implied.  See the License for the
+  // specific language governing permissions and limitations
+  // under the License.
+  /**
+   * Converts an integer as a number or bigint to a number, throwing an error if the input cannot safely be represented as a number.
+   */
+  function bigIntToNumber(number) {
+      if (typeof number === 'bigint' && (number < Number.MIN_SAFE_INTEGER || number > Number.MAX_SAFE_INTEGER)) {
+          throw new TypeError(`${number} is not safe to convert to a number.`);
+      }
+      return Number(number);
+  }
+
+  // Licensed to the Apache Software Foundation (ASF) under one
+  // or more contributor license agreements.  See the NOTICE file
+  // distributed with this work for additional information
+  // regarding copyright ownership.  The ASF licenses this file
+  // to you under the Apache License, Version 2.0 (the
+  // "License"); you may not use this file except in compliance
+  // with the License.  You may obtain a copy of the License at
+  //
+  //   http://www.apache.org/licenses/LICENSE-2.0
+  //
+  // Unless required by applicable law or agreed to in writing,
+  // software distributed under the License is distributed on an
+  // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  // KIND, either express or implied.  See the License for the
+  // specific language governing permissions and limitations
+  // under the License.
+  var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
+  /**
+   * An abstract base class for classes that encapsulate metadata about each of
+   * the logical types that Arrow can represent.
+   */
+  class DataType {
+      /** @nocollapse */ static isNull(x) { return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Null; }
+      /** @nocollapse */ static isInt(x) { return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Int; }
+      /** @nocollapse */ static isFloat(x) { return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Float; }
+      /** @nocollapse */ static isBinary(x) { return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Binary; }
+      /** @nocollapse */ static isLargeBinary(x) { return (x === null || x === void 0 ? void 0 : x.typeId) === Type.LargeBinary; }
+      /** @nocollapse */ static isUtf8(x) { return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Utf8; }
+      /** @nocollapse */ static isLargeUtf8(x) { return (x === null || x === void 0 ? void 0 : x.typeId) === Type.LargeUtf8; }
+      /** @nocollapse */ static isBool(x) { return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Bool; }
+      /** @nocollapse */ static isDecimal(x) { return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Decimal; }
+      /** @nocollapse */ static isDate(x) { return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Date; }
+      /** @nocollapse */ static isTime(x) { return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Time; }
+      /** @nocollapse */ static isTimestamp(x) { return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Timestamp; }
+      /** @nocollapse */ static isInterval(x) { return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Interval; }
+      /** @nocollapse */ static isDuration(x) { return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Duration; }
+      /** @nocollapse */ static isList(x) { return (x === null || x === void 0 ? void 0 : x.typeId) === Type.List; }
+      /** @nocollapse */ static isStruct(x) { return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Struct; }
+      /** @nocollapse */ static isUnion(x) { return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Union; }
+      /** @nocollapse */ static isFixedSizeBinary(x) { return (x === null || x === void 0 ? void 0 : x.typeId) === Type.FixedSizeBinary; }
+      /** @nocollapse */ static isFixedSizeList(x) { return (x === null || x === void 0 ? void 0 : x.typeId) === Type.FixedSizeList; }
+      /** @nocollapse */ static isMap(x) { return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Map; }
+      /** @nocollapse */ static isDictionary(x) { return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Dictionary; }
+      /** @nocollapse */ static isDenseUnion(x) { return DataType.isUnion(x) && x.mode === UnionMode.Dense; }
+      /** @nocollapse */ static isSparseUnion(x) { return DataType.isUnion(x) && x.mode === UnionMode.Sparse; }
+      constructor(typeId) {
+          this.typeId = typeId;
+      }
+  }
+  _a = Symbol.toStringTag;
+  DataType[_a] = ((proto) => {
+      proto.children = null;
+      proto.ArrayType = Array;
+      proto.OffsetArrayType = Int32Array;
+      return proto[Symbol.toStringTag] = 'DataType';
+  })(DataType.prototype);
+  /** @ignore */
+  class Null extends DataType {
+      constructor() {
+          super(Type.Null);
+      }
+      toString() { return `Null`; }
+  }
+  _b = Symbol.toStringTag;
+  Null[_b] = ((proto) => proto[Symbol.toStringTag] = 'Null')(Null.prototype);
+  /** @ignore */
+  class Int_ extends DataType {
+      constructor(isSigned, bitWidth) {
+          super(Type.Int);
+          this.isSigned = isSigned;
+          this.bitWidth = bitWidth;
+      }
+      get ArrayType() {
+          switch (this.bitWidth) {
+              case 8: return this.isSigned ? Int8Array : Uint8Array;
+              case 16: return this.isSigned ? Int16Array : Uint16Array;
+              case 32: return this.isSigned ? Int32Array : Uint32Array;
+              case 64: return this.isSigned ? BigInt64Array : BigUint64Array;
+          }
+          throw new Error(`Unrecognized ${this[Symbol.toStringTag]} type`);
+      }
+      toString() { return `${this.isSigned ? `I` : `Ui`}nt${this.bitWidth}`; }
+  }
+  _c = Symbol.toStringTag;
+  Int_[_c] = ((proto) => {
+      proto.isSigned = null;
+      proto.bitWidth = null;
+      return proto[Symbol.toStringTag] = 'Int';
+  })(Int_.prototype);
+  /** @ignore */
+  class Float extends DataType {
+      constructor(precision) {
+          super(Type.Float);
+          this.precision = precision;
+      }
+      get ArrayType() {
+          switch (this.precision) {
+              case Precision.HALF: return Uint16Array;
+              case Precision.SINGLE: return Float32Array;
+              case Precision.DOUBLE: return Float64Array;
+          }
+          // @ts-ignore
+          throw new Error(`Unrecognized ${this[Symbol.toStringTag]} type`);
+      }
+      toString() { return `Float${(this.precision << 5) || 16}`; }
+  }
+  _d = Symbol.toStringTag;
+  Float[_d] = ((proto) => {
+      proto.precision = null;
+      return proto[Symbol.toStringTag] = 'Float';
+  })(Float.prototype);
+  /** @ignore */
+  class Binary extends DataType {
+      constructor() {
+          super(Type.Binary);
+      }
+      toString() { return `Binary`; }
+  }
+  _e = Symbol.toStringTag;
+  Binary[_e] = ((proto) => {
+      proto.ArrayType = Uint8Array;
+      return proto[Symbol.toStringTag] = 'Binary';
+  })(Binary.prototype);
+  /** @ignore */
+  class LargeBinary extends DataType {
+      constructor() {
+          super(Type.LargeBinary);
+      }
+      toString() { return `LargeBinary`; }
+  }
+  _f = Symbol.toStringTag;
+  LargeBinary[_f] = ((proto) => {
+      proto.ArrayType = Uint8Array;
+      proto.OffsetArrayType = BigInt64Array;
+      return proto[Symbol.toStringTag] = 'LargeBinary';
+  })(LargeBinary.prototype);
+  /** @ignore */
+  class Utf8 extends DataType {
+      constructor() {
+          super(Type.Utf8);
+      }
+      toString() { return `Utf8`; }
+  }
+  _g = Symbol.toStringTag;
+  Utf8[_g] = ((proto) => {
+      proto.ArrayType = Uint8Array;
+      return proto[Symbol.toStringTag] = 'Utf8';
+  })(Utf8.prototype);
+  /** @ignore */
+  class LargeUtf8 extends DataType {
+      constructor() {
+          super(Type.LargeUtf8);
+      }
+      toString() { return `LargeUtf8`; }
+  }
+  _h = Symbol.toStringTag;
+  LargeUtf8[_h] = ((proto) => {
+      proto.ArrayType = Uint8Array;
+      proto.OffsetArrayType = BigInt64Array;
+      return proto[Symbol.toStringTag] = 'LargeUtf8';
+  })(LargeUtf8.prototype);
+  /** @ignore */
+  class Bool extends DataType {
+      constructor() {
+          super(Type.Bool);
+      }
+      toString() { return `Bool`; }
+  }
+  _j = Symbol.toStringTag;
+  Bool[_j] = ((proto) => {
+      proto.ArrayType = Uint8Array;
+      return proto[Symbol.toStringTag] = 'Bool';
+  })(Bool.prototype);
+  /** @ignore */
+  class Decimal extends DataType {
+      constructor(scale, precision, bitWidth = 128) {
+          super(Type.Decimal);
+          this.scale = scale;
+          this.precision = precision;
+          this.bitWidth = bitWidth;
+      }
+      toString() { return `Decimal[${this.precision}e${this.scale > 0 ? `+` : ``}${this.scale}]`; }
+  }
+  _k = Symbol.toStringTag;
+  Decimal[_k] = ((proto) => {
+      proto.scale = null;
+      proto.precision = null;
+      proto.ArrayType = Uint32Array;
+      return proto[Symbol.toStringTag] = 'Decimal';
+  })(Decimal.prototype);
+  /** @ignore */
+  class Date_ extends DataType {
+      constructor(unit) {
+          super(Type.Date);
+          this.unit = unit;
+      }
+      toString() { return `Date${(this.unit + 1) * 32}<${DateUnit[this.unit]}>`; }
+  }
+  _l = Symbol.toStringTag;
+  Date_[_l] = ((proto) => {
+      proto.unit = null;
+      proto.ArrayType = Int32Array;
+      return proto[Symbol.toStringTag] = 'Date';
+  })(Date_.prototype);
+  /** @ignore */
+  class Time_ extends DataType {
+      constructor(unit, bitWidth) {
+          super(Type.Time);
+          this.unit = unit;
+          this.bitWidth = bitWidth;
+      }
+      toString() { return `Time${this.bitWidth}<${TimeUnit[this.unit]}>`; }
+      get ArrayType() {
+          switch (this.bitWidth) {
+              case 32: return Int32Array;
+              case 64: return BigInt64Array;
+          }
+          // @ts-ignore
+          throw new Error(`Unrecognized ${this[Symbol.toStringTag]} type`);
+      }
+  }
+  _m = Symbol.toStringTag;
+  Time_[_m] = ((proto) => {
+      proto.unit = null;
+      proto.bitWidth = null;
+      return proto[Symbol.toStringTag] = 'Time';
+  })(Time_.prototype);
+  /** @ignore */
+  class Timestamp_ extends DataType {
+      constructor(unit, timezone) {
+          super(Type.Timestamp);
+          this.unit = unit;
+          this.timezone = timezone;
+      }
+      toString() { return `Timestamp<${TimeUnit[this.unit]}${this.timezone ? `, ${this.timezone}` : ``}>`; }
+  }
+  _o = Symbol.toStringTag;
+  Timestamp_[_o] = ((proto) => {
+      proto.unit = null;
+      proto.timezone = null;
+      proto.ArrayType = Int32Array;
+      return proto[Symbol.toStringTag] = 'Timestamp';
+  })(Timestamp_.prototype);
+  /** @ignore */
+  class Interval_ extends DataType {
+      constructor(unit) {
+          super(Type.Interval);
+          this.unit = unit;
+      }
+      toString() { return `Interval<${IntervalUnit[this.unit]}>`; }
+  }
+  _p = Symbol.toStringTag;
+  Interval_[_p] = ((proto) => {
+      proto.unit = null;
+      proto.ArrayType = Int32Array;
+      return proto[Symbol.toStringTag] = 'Interval';
+  })(Interval_.prototype);
+  /** @ignore */
+  class Duration extends DataType {
+      constructor(unit) {
+          super(Type.Duration);
+          this.unit = unit;
+      }
+      toString() { return `Duration<${TimeUnit[this.unit]}>`; }
+  }
+  _q = Symbol.toStringTag;
+  Duration[_q] = ((proto) => {
+      proto.unit = null;
+      proto.ArrayType = BigInt64Array;
+      return proto[Symbol.toStringTag] = 'Duration';
+  })(Duration.prototype);
+  /** @ignore */
+  class List extends DataType {
+      constructor(child) {
+          super(Type.List);
+          this.children = [child];
+      }
+      toString() { return `List<${this.valueType}>`; }
+      get valueType() { return this.children[0].type; }
+      get valueField() { return this.children[0]; }
+      get ArrayType() { return this.valueType.ArrayType; }
+  }
+  _r = Symbol.toStringTag;
+  List[_r] = ((proto) => {
+      proto.children = null;
+      return proto[Symbol.toStringTag] = 'List';
+  })(List.prototype);
+  /** @ignore */
+  class Struct extends DataType {
+      constructor(children) {
+          super(Type.Struct);
+          this.children = children;
+      }
+      toString() { return `Struct<{${this.children.map((f) => `${f.name}:${f.type}`).join(`, `)}}>`; }
+  }
+  _s = Symbol.toStringTag;
+  Struct[_s] = ((proto) => {
+      proto.children = null;
+      return proto[Symbol.toStringTag] = 'Struct';
+  })(Struct.prototype);
+  /** @ignore */
+  class Union_ extends DataType {
+      constructor(mode, typeIds, children) {
+          super(Type.Union);
+          this.mode = mode;
+          this.children = children;
+          this.typeIds = typeIds = Int32Array.from(typeIds);
+          this.typeIdToChildIndex = typeIds.reduce((typeIdToChildIndex, typeId, idx) => (typeIdToChildIndex[typeId] = idx) && typeIdToChildIndex || typeIdToChildIndex, Object.create(null));
+      }
+      toString() {
+          return `${this[Symbol.toStringTag]}<${this.children.map((x) => `${x.type}`).join(` | `)}>`;
+      }
+  }
+  _t = Symbol.toStringTag;
+  Union_[_t] = ((proto) => {
+      proto.mode = null;
+      proto.typeIds = null;
+      proto.children = null;
+      proto.typeIdToChildIndex = null;
+      proto.ArrayType = Int8Array;
+      return proto[Symbol.toStringTag] = 'Union';
+  })(Union_.prototype);
+  /** @ignore */
+  class FixedSizeBinary extends DataType {
+      constructor(byteWidth) {
+          super(Type.FixedSizeBinary);
+          this.byteWidth = byteWidth;
+      }
+      toString() { return `FixedSizeBinary[${this.byteWidth}]`; }
+  }
+  _u = Symbol.toStringTag;
+  FixedSizeBinary[_u] = ((proto) => {
+      proto.byteWidth = null;
+      proto.ArrayType = Uint8Array;
+      return proto[Symbol.toStringTag] = 'FixedSizeBinary';
+  })(FixedSizeBinary.prototype);
+  /** @ignore */
+  class FixedSizeList extends DataType {
+      constructor(listSize, child) {
+          super(Type.FixedSizeList);
+          this.listSize = listSize;
+          this.children = [child];
+      }
+      get valueType() { return this.children[0].type; }
+      get valueField() { return this.children[0]; }
+      get ArrayType() { return this.valueType.ArrayType; }
+      toString() { return `FixedSizeList[${this.listSize}]<${this.valueType}>`; }
+  }
+  _v = Symbol.toStringTag;
+  FixedSizeList[_v] = ((proto) => {
+      proto.children = null;
+      proto.listSize = null;
+      return proto[Symbol.toStringTag] = 'FixedSizeList';
+  })(FixedSizeList.prototype);
+  /** @ignore */
+  class Map_ extends DataType {
+      constructor(entries, keysSorted = false) {
+          var _y, _z, _0;
+          super(Type.Map);
+          this.children = [entries];
+          this.keysSorted = keysSorted;
+          // ARROW-8716
+          // https://github.com/apache/arrow/issues/17168
+          if (entries) {
+              entries['name'] = 'entries';
+              if ((_y = entries === null || entries === void 0 ? void 0 : entries.type) === null || _y === void 0 ? void 0 : _y.children) {
+                  const key = (_z = entries === null || entries === void 0 ? void 0 : entries.type) === null || _z === void 0 ? void 0 : _z.children[0];
+                  if (key) {
+                      key['name'] = 'key';
+                  }
+                  const val = (_0 = entries === null || entries === void 0 ? void 0 : entries.type) === null || _0 === void 0 ? void 0 : _0.children[1];
+                  if (val) {
+                      val['name'] = 'value';
+                  }
+              }
+          }
+      }
+      get keyType() { return this.children[0].type.children[0].type; }
+      get valueType() { return this.children[0].type.children[1].type; }
+      get childType() { return this.children[0].type; }
+      toString() { return `Map<{${this.children[0].type.children.map((f) => `${f.name}:${f.type}`).join(`, `)}}>`; }
+  }
+  _w = Symbol.toStringTag;
+  Map_[_w] = ((proto) => {
+      proto.children = null;
+      proto.keysSorted = null;
+      return proto[Symbol.toStringTag] = 'Map_';
+  })(Map_.prototype);
+  /** @ignore */
+  const getId = ((atomicDictionaryId) => () => ++atomicDictionaryId)(-1);
+  /** @ignore */
+  class Dictionary extends DataType {
+      constructor(dictionary, indices, id, isOrdered) {
+          super(Type.Dictionary);
+          this.indices = indices;
+          this.dictionary = dictionary;
+          this.isOrdered = isOrdered || false;
+          this.id = id == null ? getId() : bigIntToNumber(id);
+      }
+      get children() { return this.dictionary.children; }
+      get valueType() { return this.dictionary; }
+      get ArrayType() { return this.dictionary.ArrayType; }
+      toString() { return `Dictionary<${this.indices}, ${this.dictionary}>`; }
+  }
+  _x = Symbol.toStringTag;
+  Dictionary[_x] = ((proto) => {
+      proto.id = null;
+      proto.indices = null;
+      proto.isOrdered = null;
+      proto.dictionary = null;
+      return proto[Symbol.toStringTag] = 'Dictionary';
+  })(Dictionary.prototype);
+
   /**
    * Helper class for the nimble-wafer-map to validate that the wafer maps's grid dimensions
    * configuration is valid and report which aspects of the configuration are valid or invalid.
@@ -75731,10 +76325,12 @@ img.ProseMirror-separator {
       constructor(wafermap) {
           this.wafermap = wafermap;
           this.invalidGridDimensions = false;
+          this.invalidDiesTableSchema = false;
       }
       getValidity() {
           return {
-              invalidGridDimensions: this.invalidGridDimensions
+              invalidGridDimensions: this.invalidGridDimensions,
+              invalidDiesTableSchema: this.invalidDiesTableSchema
           };
       }
       isValid() {
@@ -75758,6 +76354,81 @@ img.ProseMirror-separator {
           }
           return !this.invalidGridDimensions;
       }
+      validateDiesTableSchema() {
+          this.invalidDiesTableSchema = false;
+          if (this.wafermap.diesTable === undefined) {
+              this.invalidDiesTableSchema = false;
+          }
+          else {
+              const colIndexField = this.wafermap.diesTable.schema.fields.findIndex(f => f.name === 'colIndex');
+              const rowIndexField = this.wafermap.diesTable.schema.fields.findIndex(f => f.name === 'rowIndex');
+              const valueField = this.wafermap.diesTable.schema.fields.findIndex(f => f.name === 'value');
+              if (this.wafermap.diesTable.numCols < 3
+                  || colIndexField === -1
+                  || rowIndexField === -1
+                  || valueField === -1
+                  || !DataType.isInt(this.wafermap.diesTable.schema.fields[colIndexField].type)
+                  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                  || this.wafermap.diesTable.schema.fields[colIndexField].type
+                      .bitWidth !== 32
+                  || !DataType.isInt(this.wafermap.diesTable.schema.fields[rowIndexField].type)
+                  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                  || this.wafermap.diesTable.schema.fields[rowIndexField].type
+                      .bitWidth !== 32
+                  || !DataType.isFloat(this.wafermap.diesTable.schema.fields[valueField].type)
+                  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                  || this.wafermap.diesTable.schema.fields[valueField].type
+                      .precision !== Precision.DOUBLE) {
+                  this.invalidDiesTableSchema = true;
+              }
+          }
+          return !this.invalidDiesTableSchema;
+      }
+  }
+
+  /**
+   * Responsible for drawing the dies inside the wafer map, adding dieText and scaling the canvas
+   */
+  class WorkerRenderer {
+      constructor(wafermap) {
+          this.wafermap = wafermap;
+      }
+      updateSortedDiesAndDrawWafer() {
+          // redundant function for backwards compatibility
+          this.drawWafer();
+      }
+      drawWafer() {
+          // rendering will be implemented in a future PR
+          this.renderHover();
+      }
+      renderHover() {
+          this.wafermap.hoverWidth = this.wafermap.dataManager.dieDimensions.width
+              * this.wafermap.transform.k;
+          this.wafermap.hoverHeight = this.wafermap.dataManager.dieDimensions.height
+              * this.wafermap.transform.k;
+          this.wafermap.hoverOpacity = this.wafermap.hoverDie === undefined
+              ? HoverDieOpacity.hide
+              : HoverDieOpacity.show;
+          this.wafermap.hoverTransform = this.calculateHoverTransform();
+      }
+      calculateHoverTransform() {
+          if (this.wafermap.hoverDie !== undefined) {
+              const scaledX = this.wafermap.dataManager.horizontalScale(this.wafermap.hoverDie.x);
+              if (scaledX === undefined) {
+                  return '';
+              }
+              const scaledY = this.wafermap.dataManager.verticalScale(this.wafermap.hoverDie.y);
+              if (scaledY === undefined) {
+                  return '';
+              }
+              const transformedPoint = this.wafermap.transform.apply([
+                  scaledX + this.wafermap.dataManager.margin.left,
+                  scaledY + this.wafermap.dataManager.margin.top
+              ]);
+              return `translate(${transformedPoint[0]}, ${transformedPoint[1]})`;
+          }
+          return '';
+      }
   }
 
   /**
@@ -75788,7 +76459,12 @@ img.ProseMirror-separator {
           /**
            * @internal
            */
-          this.renderer = new RenderingModule(this);
+          this.mainRenderer = new RenderingModule(this);
+          /**
+           * @internal
+           */
+          this.workerRenderer = new WorkerRenderer(this);
+          this.renderer = this.mainRenderer;
           /**
            * @internal
            */
@@ -75847,9 +76523,12 @@ img.ProseMirror-separator {
        * The hover does not require an event update, but it's also the last update in the sequence.
        */
       update() {
+          this.validate();
+          if (this.validity.invalidDiesTableSchema) {
+              return;
+          }
           if (this.waferMapUpdateTracker.requiresEventsUpdate) {
               this.eventCoordinator.detachEvents();
-              this.waferMapValidator.validateGridDimensions();
               if (this.waferMapUpdateTracker.requiresContainerDimensionsUpdate) {
                   this.dataManager.updateContainerDimensions();
                   this.renderer.updateSortedDiesAndDrawWafer();
@@ -75875,6 +76554,10 @@ img.ProseMirror-separator {
               this.renderer.renderHover();
           }
       }
+      validate() {
+          this.waferMapValidator.validateGridDimensions();
+          this.waferMapValidator.validateDiesTableSchema();
+      }
       createResizeObserver() {
           const resizeObserver = new ResizeObserver(entries => {
               const entry = entries[0];
@@ -75933,6 +76616,16 @@ img.ProseMirror-separator {
       }
       diesChanged() {
           this.waferMapUpdateTracker.track('dies');
+          this.renderer = this.diesTable === undefined
+              ? this.mainRenderer
+              : this.workerRenderer;
+          this.waferMapUpdateTracker.queueUpdate();
+      }
+      diesTableChanged() {
+          this.waferMapUpdateTracker.track('dies');
+          this.renderer = this.diesTable === undefined
+              ? this.mainRenderer
+              : this.workerRenderer;
           this.waferMapUpdateTracker.queueUpdate();
       }
       colorScaleChanged() {
@@ -75987,6 +76680,9 @@ img.ProseMirror-separator {
   __decorate$1([
       attr({ attribute: 'color-scale-mode' })
   ], WaferMap.prototype, "colorScaleMode", void 0);
+  __decorate$1([
+      observable
+  ], WaferMap.prototype, "renderer", void 0);
   __decorate$1([
       observable
   ], WaferMap.prototype, "canvasWidth", void 0);
@@ -76017,6 +76713,9 @@ img.ProseMirror-separator {
   __decorate$1([
       observable
   ], WaferMap.prototype, "dies", void 0);
+  __decorate$1([
+      observable
+  ], WaferMap.prototype, "diesTable", void 0);
   __decorate$1([
       observable
   ], WaferMap.prototype, "colorScale", void 0);