@ni/nimble-components 24.0.1 → 24.1.1

package/dist/esm/src/utilities/style/types.d.ts

@@ -0,0 +1,5 @@
+export declare const ZIndexLevels: {
+    readonly zIndex1: "1";
+    readonly zIndex1000: "1000";
+};
+export type ZIndexLevels = (typeof ZIndexLevels)[keyof typeof ZIndexLevels];

package/dist/esm/src/utilities/style/user-select.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Set user-select: none in a way that works across all supported browsers.
+ * https://developer.mozilla.org/en-US/docs/Web/CSS/user-select#browser_compatibility
+ */
+export declare const userSelectNone: import("@microsoft/fast-element").CSSDirective;

package/dist/esm/src/utilities/unit-format/decimal-unit-format.d.ts

@@ -0,0 +1,19 @@
+import { UnitFormat, UnitFormatOptions } from './unit-format';
+interface DecimalUnitFormatOptions extends UnitFormatOptions {
+    minimumFractionDigits?: number;
+    maximumFractionDigits?: number;
+}
+type ResolvedDecimalUnitFormatOptions = Required<DecimalUnitFormatOptions>;
+/**
+ * Format for decimal numbers with units.
+ */
+export declare class DecimalUnitFormat extends UnitFormat<DecimalUnitFormatOptions> {
+    private readonly unitScale;
+    private readonly minimumFractionDigits;
+    private readonly maximumFractionDigits;
+    private readonly scaledUnitFormatters;
+    constructor(locale: string, { minimumFractionDigits, maximumFractionDigits, unitScale }?: DecimalUnitFormatOptions);
+    resolvedOptions(): ResolvedDecimalUnitFormatOptions;
+    protected tryFormat(number: number): string;
+}
+export {};

package/dist/esm/src/utilities/unit-format/default-unit-format.d.ts

@@ -0,0 +1,22 @@
+import { UnitFormat, UnitFormatOptions } from './unit-format';
+interface DefaultUnitFormatOptions extends UnitFormatOptions {
+}
+type ResolvedDefaultUnitFormatOptions = Required<DefaultUnitFormatOptions>;
+/**
+ * Format for numbers with units to show in a tabular form.
+ * Large and tiny numbers are shown exponentially and the rest as decimal.
+ */
+export declare class DefaultUnitFormat extends UnitFormat {
+    private static readonly maximumDigits;
+    private static readonly exponentialLowerBound;
+    private static readonly exponentialUpperBound;
+    private readonly unitScale;
+    private readonly defaultIntlNumberFormatOptions;
+    private readonly defaultScaledUnitFormatters;
+    private readonly exponentialIntlNumberFormatOptions;
+    private readonly exponentialScaledUnitFormatter;
+    constructor(locale: string, { unitScale }?: DefaultUnitFormatOptions);
+    resolvedOptions(): ResolvedDefaultUnitFormatOptions;
+    protected tryFormat(number: number): string;
+}
+export {};

package/dist/esm/src/utilities/unit-format/scaled-unit/scaled-unit.d.ts

@@ -0,0 +1,16 @@
+import type { ScaledUnitFormat } from '../scaled-unit-format/scaled-unit-format';
+export interface ScaledUnitFormatFactoryOptions {
+    readonly locale: string;
+    readonly intlNumberFormatOptions?: Intl.NumberFormatOptions;
+}
+type ScaledUnitFormatFactory = (scaledUnitFormatFactoryOptions: ScaledUnitFormatFactoryOptions) => ScaledUnitFormat;
+/**
+ * A unit that represents a scaled version of a base unit.
+ */
+export declare class ScaledUnit {
+    readonly scaleFactor: number;
+    readonly scaledUnitFormatFactory: ScaledUnitFormatFactory;
+    constructor(scaleFactor: number, scaledUnitFormatFactory: ScaledUnitFormatFactory);
+    isBase(): boolean;
+}
+export {};

package/dist/esm/src/utilities/unit-format/scaled-unit-format/intl-number-format-scaled-unit-format.d.ts

@@ -0,0 +1,11 @@
+import type { ScaledUnitFormatFactoryOptions } from '../scaled-unit/scaled-unit';
+import { ScaledUnitFormat } from './scaled-unit-format';
+/**
+ * A formatter for units that can be formatted/translated by Intl.NumberFormat
+ */
+export declare class IntlNumberFormatScaledUnitFormat extends ScaledUnitFormat {
+    private readonly formatter;
+    protected constructor(scaledUnitFormatFactoryOptions: ScaledUnitFormatFactoryOptions, unitSpecificIntlNumberFormatOptions: Intl.NumberFormatOptions);
+    static createFactory(unitSpecificIntlNumberFormatOptions: Intl.NumberFormatOptions): (scaledUnitFormatFactoryOptions: ScaledUnitFormatFactoryOptions) => IntlNumberFormatScaledUnitFormat;
+    format(value: number): string;
+}

package/dist/esm/src/utilities/unit-format/scaled-unit-format/manually-translated-scaled-unit-format.d.ts

@@ -0,0 +1,43 @@
+import type { ScaledUnitFormatFactoryOptions } from '../scaled-unit/scaled-unit';
+import { ScaledUnitFormat } from './scaled-unit-format';
+/**
+ * Representations of a unit in a particular language
+ */
+export declare class UnitTranslation {
+    readonly singular: string;
+    readonly plural: string;
+    readonly symbol: string;
+    constructor(singular: string, plural: string, symbol: string);
+}
+/**
+ * A map of locales of string format "[lang]" or "[lang]-[region]", for example "en" and / or "en-us", to UnitTranslation objects
+ */
+export type UnitTranslations = ReadonlyMap<string, UnitTranslation>;
+export interface ManuallyTranslatedScaledUnitFormatOptions {
+    /**
+     * Translations for the unit by locale string.
+     * The locale strings must be of the form [lang] or [lang]-[region], for example "en" and / or "en-us".
+     * Other subtags besides lang and region are not supported.
+     * Translations for "en" must be provided.
+     */
+    readonly unitTranslations: UnitTranslations;
+    /**
+     * String for prefix of this scaled unit, for example "k" (for kilo-).
+     * Assumed the same across languages.
+     * Base unit must use "", i.e. empty string, as the scaled prefix text.
+     */
+    readonly scaledPrefixText: string;
+}
+/**
+ * A formatter for units that are not supported by Intl.NumberFormat
+ */
+export declare class ManuallyTranslatedScaledUnitFormat extends ScaledUnitFormat {
+    private readonly pluralRules;
+    private readonly formatter;
+    private readonly unitTranslation;
+    private readonly scaledPrefixText;
+    protected constructor(scaledUnitFormatFactoryOptions: ScaledUnitFormatFactoryOptions, { unitTranslations, scaledPrefixText }: ManuallyTranslatedScaledUnitFormatOptions);
+    static createFactory(manuallyTranslatedScaledUnitFormatOptions: ManuallyTranslatedScaledUnitFormatOptions): (scaledUnitFormatFactoryOptions: ScaledUnitFormatFactoryOptions) => ManuallyTranslatedScaledUnitFormat;
+    format(value: number): string;
+    private getTranslationToUse;
+}

package/dist/esm/src/utilities/unit-format/scaled-unit-format/scaled-unit-format.d.ts

@@ -0,0 +1,10 @@
+import type { ScaledUnitFormatFactoryOptions } from '../scaled-unit/scaled-unit';
+/**
+ * A class that knows how to format a numeric value as a string that includes units.
+ */
+export declare abstract class ScaledUnitFormat {
+    protected readonly locale: string;
+    protected readonly intlNumberFormatOptions?: Intl.NumberFormatOptions;
+    protected constructor(scaledUnitFormatFactoryOptions: ScaledUnitFormatFactoryOptions);
+    abstract format(value: number): string;
+}

package/dist/esm/src/utilities/unit-format/unit-format.d.ts

@@ -0,0 +1,16 @@
+import type { UnitScale } from './unit-scale/unit-scale';
+export interface UnitFormatOptions {
+    unitScale?: UnitScale;
+}
+/**
+ * The base class for unit formats.
+ */
+export declare abstract class UnitFormat<Options extends UnitFormatOptions = UnitFormatOptions> {
+    /**
+     * Formats a number value to a string.
+     * For nullish values or values that result in an exception being thrown, empty string is returned
+     */
+    format(value: number | undefined | null): string;
+    abstract resolvedOptions(): Required<Options>;
+    protected abstract tryFormat(number: number): string;
+}

package/dist/esm/src/utilities/unit-format/unit-scale/byte-1024-unit-scale.d.ts

@@ -0,0 +1,9 @@
+import { UnitScale } from './unit-scale';
+/**
+ * Byte units (1024-based)
+ */
+declare class Byte1024UnitScale extends UnitScale {
+    constructor();
+}
+export declare const byte1024UnitScale: Byte1024UnitScale;
+export {};

package/dist/esm/src/utilities/unit-format/unit-scale/byte-unit-scale.d.ts

@@ -0,0 +1,9 @@
+import { UnitScale } from './unit-scale';
+/**
+ * Byte units (1000-based)
+ */
+declare class ByteUnitScale extends UnitScale {
+    constructor();
+}
+export declare const byteUnitScale: ByteUnitScale;
+export {};

package/dist/esm/src/utilities/unit-format/unit-scale/passthrough-unit-scale.d.ts

@@ -0,0 +1,9 @@
+import { UnitScale } from './unit-scale';
+/**
+ * Unit scale that is used to passthrough a number without applying scaling or units
+ */
+declare class PassthroughUnitScale extends UnitScale {
+    constructor();
+}
+export declare const passthroughUnitScale: PassthroughUnitScale;
+export {};

package/dist/esm/src/utilities/unit-format/unit-scale/unit-scale.d.ts

@@ -0,0 +1,15 @@
+import type { ScaledUnit } from '../scaled-unit/scaled-unit';
+interface ScaledNumber {
+    readonly scaledValue: number;
+    readonly scaledUnit: ScaledUnit;
+}
+/**
+ * A unit scale consisting of a set of scaled units.
+ */
+export declare abstract class UnitScale {
+    readonly supportedScaledUnits: readonly ScaledUnit[];
+    readonly baseScaledUnit: ScaledUnit;
+    constructor(supportedScaledUnits: readonly ScaledUnit[]);
+    scaleNumber(number: number): ScaledNumber;
+}
+export {};

package/dist/esm/src/utilities/unit-format/unit-scale/utilities/metrix-prefixes.d.ts

@@ -0,0 +1 @@
+export declare const metricPrefixes: readonly [readonly [number, "f"], readonly [number, "p"], readonly [number, "n"], readonly [number, "μ"], readonly [number, "m"], readonly [number, "c"], readonly [number, "d"], readonly [number, ""], readonly [number, "k"], readonly [number, "M"], readonly [number, "G"], readonly [number, "T"], readonly [number, "P"], readonly [number, "E"]];

package/dist/esm/src/utilities/unit-format/unit-scale/volt-unit-scale.d.ts

@@ -0,0 +1,9 @@
+import { UnitScale } from './unit-scale';
+/**
+ * Voltage unit scale
+ */
+declare class VoltUnitScale extends UnitScale {
+    constructor();
+}
+export declare const voltUnitScale: VoltUnitScale;
+export {};

package/dist/esm/src/utilities/wait-until-custom-elements-defined-async.d.ts

@@ -0,0 +1 @@
+export declare function waitUntilCustomElementsDefinedAsync(elements: Element[]): Promise<void>;

package/dist/esm/src/wafer-map/index.d.ts

@@ -0,0 +1,146 @@
+import { FoundationElement } from '@microsoft/fast-foundation';
+import { ZoomTransform } from 'd3-zoom';
+import type { Table } from 'apache-arrow';
+import { DataManager } from './modules/data-manager';
+import { DataManager as ExperimentalDataManager } from './modules/experimental/data-manager';
+import { RenderingModule } from './modules/rendering';
+import { HoverDie, HoverDieOpacity, WaferMapColorScale, WaferMapColorScaleMode, WaferMapDie, WaferMapOrientation, WaferMapOriginLocation, WaferMapValidity, type WaferRequiredFields } from './types';
+import { WaferMapUpdateTracker } from './modules/wafer-map-update-tracker';
+import { WorkerRenderer } from './modules/experimental/worker-renderer';
+declare global {
+    interface HTMLElementTagNameMap {
+        'nimble-wafer-map': WaferMap;
+    }
+}
+/**
+ * A nimble-styled WaferMap
+ */
+export declare class WaferMap<T extends WaferRequiredFields = WaferRequiredFields> extends FoundationElement {
+    /**
+     * @internal
+     * needs to be initialized before the properties trigger changes
+     */
+    readonly waferMapUpdateTracker: WaferMapUpdateTracker;
+    originLocation: WaferMapOriginLocation;
+    gridMinX?: number;
+    gridMaxX?: number;
+    gridMinY?: number;
+    gridMaxY?: number;
+    orientation: WaferMapOrientation;
+    maxCharacters: number;
+    dieLabelsHidden: boolean;
+    dieLabelsSuffix: string;
+    colorScaleMode: WaferMapColorScaleMode;
+    /**
+     * @internal
+     */
+    readonly canvas: HTMLCanvasElement;
+    /**
+     * @internal
+     */
+    canvasContext: CanvasRenderingContext2D;
+    /**
+     * @internal
+     */
+    readonly zoomContainer: HTMLElement;
+    /**
+     * @internal
+     */
+    readonly stableDataManager: DataManager;
+    /**
+     * @internal
+     */
+    readonly experimentalDataManager: ExperimentalDataManager;
+    dataManager: DataManager | ExperimentalDataManager;
+    /**
+     * @internal
+     */
+    readonly mainRenderer: RenderingModule;
+    /**
+     * @internal
+     */
+    readonly workerRenderer: WorkerRenderer;
+    renderer: RenderingModule | WorkerRenderer;
+    /**
+     * @internal
+     */
+    renderQueued: boolean;
+    /**
+     * @internal
+     */
+    canvasWidth: number;
+    /**
+     * @internal
+     */
+    canvasHeight: number;
+    /**
+     * @internal
+     */
+    transform: ZoomTransform;
+    /**
+     * @internal
+     */
+    hoverTransform: string;
+    /**
+     * @internal
+     */
+    hoverOpacity: HoverDieOpacity;
+    /**
+     * @internal
+     */
+    hoverWidth: number;
+    /**
+     * @internal
+     */
+    hoverHeight: number;
+    /**
+     * @internal
+     */
+    hoverDie: WaferMapDie | HoverDie | undefined;
+    highlightedTags: string[];
+    dies: WaferMapDie[];
+    diesTable: Table<T> | undefined;
+    colorScale: WaferMapColorScale;
+    private readonly hoverHandler;
+    private readonly experimentalHoverHandler;
+    private readonly zoomHandler;
+    private readonly resizeObserver;
+    private readonly waferMapValidator;
+    get validity(): WaferMapValidity;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /**
+     * @internal
+     * Update function called when an update is queued.
+     * It will check which updates are needed based on which properties have changed.
+     * Each update represents a different starting point of the same sequential update flow.
+     * The updates snowball one after the other, this function only choses the 'altitude'.
+     * The hover does not require an event update, but it's also the last update in the sequence.
+     */
+    update(): void;
+    /**
+     * @internal
+     */
+    isExperimentalRenderer(): boolean;
+    private validate;
+    private createResizeObserver;
+    private originLocationChanged;
+    private gridMinXChanged;
+    private gridMaxXChanged;
+    private gridMinYChanged;
+    private gridMaxYChanged;
+    private maxCharactersChanged;
+    private dieLabelsHiddenChanged;
+    private dieLabelsSuffixChanged;
+    private colorScaleModeChanged;
+    private highlightedTagsChanged;
+    private diesChanged;
+    private diesTableChanged;
+    private colorScaleChanged;
+    private transformChanged;
+    private canvasWidthChanged;
+    private canvasHeightChanged;
+    private hoverDieChanged;
+    private get asRequiredFieldsWaferMap();
+}
+export declare const waferMapTag = "nimble-wafer-map";

package/dist/esm/src/wafer-map/modules/computations.d.ts

@@ -0,0 +1,39 @@
+import { ScaleBand, ScaleQuantile } from 'd3-scale';
+import type { WaferMap } from '..';
+import { Dimensions, Margin } from '../types';
+/**
+ * Computations calculates and stores different measures which are used in the Wafermap
+ */
+export declare class Computations {
+    private readonly wafermap;
+    get containerDimensions(): Dimensions;
+    get dieDimensions(): Dimensions;
+    get radius(): number;
+    get margin(): Margin;
+    get horizontalScale(): ScaleBand<number>;
+    get verticalScale(): ScaleBand<number>;
+    get invertedHorizontalScale(): ScaleQuantile<number, number>;
+    get invertedVerticalScale(): ScaleQuantile<number, number>;
+    private _containerDimensions;
+    private _dieDimensions;
+    private _radius;
+    private _margin;
+    private _horizontalScale;
+    private _verticalScale;
+    private _invertedHorizontalScale;
+    private _invertedVerticalScale;
+    private readonly defaultPadding;
+    private readonly baseMarginPercentage;
+    constructor(wafermap: WaferMap);
+    updateContainerDimensions(): void;
+    updateScales(): void;
+    private gridDimensionsValidAndDefined;
+    private calculateGridDimensionsFromBoundingBox;
+    private calculateGridDimensionsFromDies;
+    private calculateContainerDimensions;
+    private createHorizontalScale;
+    private createInvertedHorizontalScale;
+    private createVerticalScale;
+    private createInvertedVerticalScale;
+    private calculateMarginAddition;
+}

package/dist/esm/src/wafer-map/modules/create-matrix-renderer.d.ts

@@ -0,0 +1,10 @@
+import { Remote } from 'comlink';
+import type { MatrixRenderer } from '../../../build/generate-workers/dist/esm/source/matrix-renderer';
+/**
+ * Asynchronously creates and returns a Remote<MatrixRenderer> instance.
+ * This function simplifies the process of creating and accessing MatrixRenderer instances.
+ */
+export declare const createMatrixRenderer: () => Promise<{
+    matrixRenderer: Remote<MatrixRenderer>;
+    terminate: () => void;
+}>;

package/dist/esm/src/wafer-map/modules/data-manager.d.ts

@@ -0,0 +1,30 @@
+import type { ScaleBand, ScaleQuantile } from 'd3-scale';
+import type { WaferMap } from '..';
+import type { Dimensions, Margin, DieRenderInfo, WaferMapDie, PointCoordinates } from '../types';
+/**
+ * Data Manager uses Computations and Prerendering modules in order and exposes the results
+ */
+export declare class DataManager {
+    private readonly wafermap;
+    get containerDimensions(): Dimensions;
+    get dieDimensions(): Dimensions;
+    get radius(): number;
+    get margin(): Margin;
+    get horizontalScale(): ScaleBand<number>;
+    get invertedHorizontalScale(): ScaleQuantile<number, number>;
+    get verticalScale(): ScaleBand<number>;
+    get invertedVerticalScale(): ScaleQuantile<number, number>;
+    get labelsFontSize(): number;
+    get diesRenderInfo(): DieRenderInfo[];
+    get data(): Map<string, WaferMapDie>;
+    private readonly computations;
+    private readonly prerendering;
+    private dataMap;
+    constructor(wafermap: WaferMap);
+    updateContainerDimensions(): void;
+    updateScales(): void;
+    updateLabelsFontSize(): void;
+    updateDiesRenderInfo(): void;
+    getWaferMapDie(point: PointCoordinates): WaferMapDie | undefined;
+    private updateDataMap;
+}

package/dist/esm/src/wafer-map/modules/experimental/computations.d.ts

@@ -0,0 +1,31 @@
+import { ScaleLinear } from 'd3-scale';
+import type { WaferMap } from '../..';
+import { Dimensions, Margin } from '../../types';
+/**
+ * Computations calculates and stores different measures which are used in the Wafermap
+ */
+export declare class Computations {
+    private readonly wafermap;
+    get containerDimensions(): Dimensions;
+    get dieDimensions(): Dimensions;
+    get margin(): Margin;
+    get horizontalScale(): ScaleLinear<number, number>;
+    get verticalScale(): ScaleLinear<number, number>;
+    private _containerDimensions;
+    private _dieDimensions;
+    private _margin;
+    private _horizontalScale;
+    private _verticalScale;
+    private readonly defaultPadding;
+    private readonly baseMarginPercentage;
+    constructor(wafermap: WaferMap);
+    updateContainerDimensions(): void;
+    updateScales(): void;
+    private gridDimensionsValidAndDefined;
+    private calculateGridDimensionsFromBoundingBox;
+    private calculateGridDimensionsFromDies;
+    private calculateContainerDimensions;
+    private createHorizontalScale;
+    private createVerticalScale;
+    private calculateMarginAddition;
+}

package/dist/esm/src/wafer-map/modules/experimental/data-manager.d.ts

@@ -0,0 +1,27 @@
+import type { ScaleLinear } from 'd3-scale';
+import type { WaferMap } from '../..';
+import type { Dimensions, Margin, DieRenderInfo, WaferMapDie, PointCoordinates } from '../../types';
+/**
+ * Data Manager uses Computations and Prerendering modules in order and exposes the results
+ */
+export declare class DataManager {
+    private readonly wafermap;
+    get containerDimensions(): Dimensions;
+    get dieDimensions(): Dimensions;
+    get margin(): Margin;
+    get horizontalScale(): ScaleLinear<number, number>;
+    get verticalScale(): ScaleLinear<number, number>;
+    get labelsFontSize(): number;
+    get diesRenderInfo(): DieRenderInfo[];
+    get data(): Map<string, WaferMapDie>;
+    private readonly computations;
+    private readonly prerendering;
+    private dataMap;
+    constructor(wafermap: WaferMap);
+    updateContainerDimensions(): void;
+    updateScales(): void;
+    updateLabelsFontSize(): void;
+    updateDiesRenderInfo(): void;
+    getWaferMapDie(point: PointCoordinates): WaferMapDie | undefined;
+    private updateDataMap;
+}

package/dist/esm/src/wafer-map/modules/experimental/hover-handler.d.ts

@@ -0,0 +1,23 @@
+import type { WaferMap } from '../..';
+/**
+ * HoverHandler deals with user interactions and events like hovering
+ */
+export declare class HoverHandler {
+    private readonly wafermap;
+    constructor(wafermap: WaferMap);
+    /**
+     * @internal
+     */
+    connect(): void;
+    /**
+     * @internal
+     */
+    disconnect(): void;
+    /**
+     * @internal
+     * keep public for testing until data manager refactor
+     */
+    readonly onMouseMove: (event: MouseEvent) => void;
+    private readonly onMouseOut;
+    private calculateDieCoordinates;
+}

package/dist/esm/src/wafer-map/modules/experimental/worker-renderer.d.ts

@@ -0,0 +1,12 @@
+import type { WaferMap } from '../..';
+/**
+ * Responsible for drawing the dies inside the wafer map, adding dieText and scaling the canvas
+ */
+export declare class WorkerRenderer {
+    private readonly wafermap;
+    constructor(wafermap: WaferMap);
+    updateSortedDiesAndDrawWafer(): void;
+    drawWafer(): void;
+    renderHover(): void;
+    private calculateHoverTransform;
+}

package/dist/esm/src/wafer-map/modules/hover-handler.d.ts

@@ -0,0 +1,20 @@
+import type { WaferMap } from '..';
+/**
+ * HoverHandler deals with user interactions and events like hovering
+ */
+export declare class HoverHandler {
+    private readonly wafermap;
+    constructor(wafermap: WaferMap);
+    /**
+     * @internal
+     */
+    connect(): void;
+    /**
+     * @internal
+     */
+    disconnect(): void;
+    private readonly onMouseMove;
+    private readonly onMouseOut;
+    private calculateDieCoordinates;
+    private hoversOverDie;
+}

package/dist/esm/src/wafer-map/modules/prerendering.d.ts

@@ -0,0 +1,30 @@
+import { ScaleLinear, ScaleOrdinal } from 'd3-scale';
+import type { DieRenderInfo } from '../types';
+import type { WaferMap } from '..';
+/**
+ * Prerendering prepares render-ready dies data to be used by the rendering module
+ */
+export declare class Prerendering {
+    private readonly wafermap;
+    get labelsFontSize(): number;
+    get diesRenderInfo(): DieRenderInfo[];
+    d3ColorScale: ScaleOrdinal<string, string> | ScaleLinear<string, string>;
+    private _labelsFontSize;
+    private _diesRenderInfo;
+    private readonly fontSizeFactor;
+    private readonly nonHighlightedOpacity;
+    private readonly emptyDieColor;
+    private readonly nanDieColor;
+    constructor(wafermap: WaferMap);
+    updateLabelsFontSize(): void;
+    updateDiesRenderInfo(): void;
+    private computeDieRenderInfo;
+    private calculateLabelsFontSize;
+    private createD3ColorScale;
+    private dieHasData;
+    private buildLabel;
+    private calculateOpacity;
+    private isColorScaleLinear;
+    private isColorScaleOrdinal;
+    private calculateFillStyle;
+}

package/dist/esm/src/wafer-map/modules/rendering.d.ts

@@ -0,0 +1,19 @@
+import type { WaferMap } from '..';
+/**
+ * Responsible for drawing the dies inside the wafer map, adding dieText and scaling the canvas
+ */
+export declare class RenderingModule {
+    private readonly wafermap;
+    private dies;
+    private readonly minDieDim;
+    constructor(wafermap: WaferMap);
+    updateSortedDiesAndDrawWafer(): void;
+    drawWafer(): void;
+    renderHover(): void;
+    private calculateHoverTransform;
+    private renderDies;
+    private renderText;
+    private clearCanvas;
+    private scaleCanvas;
+    private isDieVisible;
+}

package/dist/esm/src/wafer-map/modules/wafer-map-update-tracker.d.ts

@@ -0,0 +1,25 @@
+import type { WaferMap } from '..';
+import { UpdateTracker } from '../../utilities/models/update-tracker';
+declare const trackedItems: readonly ["highlightedTags", "canvasWidth", "canvasHeight", "originLocation", "gridMinX", "gridMaxX", "gridMinY", "gridMaxY", "dies", "maxCharacters", "colorScale", "colorScaleMode", "dieLabelsHidden", "dieLabelsSuffix", "transform", "hoverDie"];
+/**
+ * Helper class to track what updates are needed to the wafer based on configuration
+ * changes.
+ */
+export declare class WaferMapUpdateTracker extends UpdateTracker<typeof trackedItems> {
+    private readonly wafermap;
+    private updateQueued;
+    constructor(wafermap: WaferMap);
+    get requiresEventsUpdate(): boolean;
+    get requiresContainerDimensionsUpdate(): boolean;
+    get requiresScalesUpdate(): boolean;
+    get requiresLabelsFontSizeUpdate(): boolean;
+    get requiresDiesRenderInfoUpdate(): boolean;
+    get requiresDrawnWaferUpdate(): boolean;
+    get requiresRenderHoverUpdate(): boolean;
+    /**
+     * Queues an update using the DOM and until the update is run no other updates are queued.
+     * After the update is finished, all the tracked items are reset.
+     */
+    queueUpdate(): void;
+}
+export {};