Create an adaptor for the old api dies inputs

change/@ni-nimble-components-9a663b6a-ecb5-4698-bd2c-77cb3281255a.json

@@ -0,0 +1,7 @@
+{
+  "type": "minor",
+  "comment": "New Wafer Map Component API. Introduced `diesTable` and two rendering strategies switched by this input",
+  "packageName": "@ni/nimble-components",
+  "email": "[email protected]",
+  "dependentChangeType": "patch"
+}

packages/nimble-components/src/utilities/tests/wafer-sets.ts

@@ -0,0 +1,10 @@
+export const expectedColIndex: number[] = [0, 1, 1, 1, 2];
+
+export const expectedRowIndex: number[] = [1, 1, 0, 2, 1];
+
+export const expectedValues: number[] = [
+    88.55000305175781, 90.54000091552734, 92.55999755859375, 95.56999969482422,
+    85.76000213623047
+];
+
+export const expectedTags: string[][] = [['g'], ['k'], ['n'], ['s'], ['c']];

packages/nimble-components/src/wafer-map/modules/wafer-map-converter.ts

@@ -0,0 +1,45 @@
+import { Field, List, Table, Utf8, vectorFromArray } from 'apache-arrow';
+import type { WaferMapDie, WaferMapLayerData } from '../types';
+
+/**
+ * This class is used to convert old wafer map data to new wafer map data
+ */
+export class WaferMapConverter {
+    public static toApacheTable(waferMapDies: WaferMapDie[]): Table {
+        const layers = this.populateLayers(waferMapDies);
+
+        const columnData = {
+            colIndex: vectorFromArray(new Int32Array(layers.colIndex)),
+            rowIndex: vectorFromArray(new Int32Array(layers.rowIndex)),
+            value: vectorFromArray(new Float32Array(layers.values)),
+            tags: vectorFromArray(
+                layers.tags,
+                new List<Utf8>(new Field<Utf8>('', new Utf8()))
+            )
+        };
+
+        const table = new Table(columnData);
+
+        return table;
+    }
+
+    public static populateLayers(
+        waferMapDies: WaferMapDie[]
+    ): WaferMapLayerData {
+        const layers: WaferMapLayerData = {
+            colIndex: [],
+            rowIndex: [],
+            values: [],
+            tags: []
+        };
+
+        waferMapDies.forEach((die, index) => {
+            layers.colIndex.push(die.x);
+            layers.rowIndex.push(die.y);
+            layers.values.push(parseFloat(die.value));
+            layers.tags[index] = die.tags ?? [];
+        });
+
+        return layers;
+    }
+}

packages/nimble-components/src/wafer-map/tests/wafer-map-converter.spec.ts

@@ -0,0 +1,69 @@
+import {
+    Field,
+    List,
+    Table,
+    Utf8,
+    vectorFromArray,
+    Float32,
+    Int32
+} from 'apache-arrow';
+import { WaferMapConverter } from '../modules/wafer-map-converter';
+import type { WaferMapDie } from '../types';
+import { generateWaferData } from './data-generator';
+import {
+    goodValueGenerator,
+    highlightedValueGenerator
+} from './value-generator';
+import {
+    expectedTags,
+    expectedValues,
+    expectedRowIndex,
+    expectedColIndex
+} from '../../utilities/tests/wafer-sets';
+
+describe('WaferMap Converter', () => {
+    const seed = 1;
+    const waferMapDies: WaferMapDie[] = generateWaferData(
+        2,
+        goodValueGenerator(seed),
+        highlightedValueGenerator(seed)
+    );
+
+    it('should populate the wafer layers', () => {
+        const layers = WaferMapConverter.populateLayers(waferMapDies);
+        expect(layers.colIndex).toEqual(expectedColIndex);
+        expect(layers.rowIndex).toEqual(expectedRowIndex);
+        expect(layers.values).toEqual(
+            expectedValues.map(value => parseFloat(value.toFixed(2)))
+        );
+        expect(layers.tags).toEqual(expectedTags);
+    });
+
+    it('should convert wafer map data and types to apache arrow table', () => {
+        const table = WaferMapConverter.toApacheTable(waferMapDies);
+
+        const computedTable = new Table({
+            colIndex: vectorFromArray(new Int32Array(expectedColIndex)),
+            rowIndex: vectorFromArray(new Int32Array(expectedRowIndex)),
+            value: vectorFromArray(new Float32Array(expectedValues)),
+            tags: vectorFromArray(
+                expectedTags,
+                new List<Utf8>(new Field<Utf8>('', new Utf8()))
+            )
+        });
+
+        expect(table).toEqual(computedTable);
+
+        const columnNames = table.schema.fields.map(field => field.name);
+        expect(columnNames).toEqual(['colIndex', 'rowIndex', 'value', 'tags']);
+
+        const columnTypes = table.schema.fields.map(field => (field.type as Field).toString());
+        const expectedTypes = [
+            new Int32(),
+            new Int32(),
+            new Float32(),
+            new List<Utf8>(new Field<Utf8>('', new Utf8()))
+        ].map(type => type.toString());
+        expect(columnTypes).toEqual(expectedTypes);
+    });
+});

packages/nimble-components/src/wafer-map/types.ts

@@ -88,6 +88,14 @@ export interface WaferMapValidity extends ValidityObject {
     readonly invalidDiesTableSchema: boolean;
 }
 
+export interface WaferMapLayerData {
+    colIndex: number[];
+    rowIndex: number[];
+    values: number[];
+    tags: string[][];
+    readonly invalidDiesTableSchema: boolean;
+}
+
 // Apache arrow probably should not be using a Record and index types on TypeMap
 // because in strict checking they end up required.
 // See: https://github.com/apache/arrow/issues/12663#issuecomment-1088244575