@equinor/esv-intersection 3.0.0-beta.0 → 3.0.0-beta.2

package/dist/components/axis.d.ts

@@ -0,0 +1,47 @@
+import { Selection } from 'd3-selection';
+import { ScaleLinear } from 'd3-scale';
+import { OnResizeEvent, OnRescaleEvent } from '../interfaces';
+export declare type Options = {
+    offsetX: number;
+    offsetY: number;
+    visible: boolean;
+};
+export declare class Axis {
+    private mainGroup;
+    private _scaleX;
+    private _scaleY;
+    private _showLabels;
+    private _labelXDesc;
+    private _labelYDesc;
+    private _unitOfMeasure;
+    private _offsetX;
+    private _offsetY;
+    private _flipX;
+    private _flipY;
+    private visible;
+    constructor(mainGroup: Selection<SVGElement, unknown, null, undefined>, showLabels: boolean, labelXDesc: string, labelYDesc: string, unitOfMeasure: string, options?: Options);
+    private renderLabelx;
+    private renderLabely;
+    private renderGy;
+    private renderGx;
+    private createOrGet;
+    render(): void;
+    onResize(event: OnResizeEvent): void;
+    onRescale(event: OnRescaleEvent): void;
+    show(): Axis;
+    hide(): Axis;
+    flipX(flipX: boolean): Axis;
+    flipY(flipY: boolean): Axis;
+    showLabels(): Axis;
+    hideLabels(): Axis;
+    setLabelX(label: string): Axis;
+    setLabelY(label: string): Axis;
+    setUnitOfMeasure(uom: string): Axis;
+    setLabels(labelX: string, labelY: string, unitOfMeasure: string): Axis;
+    get offsetX(): number;
+    set offsetX(offset: number);
+    get offsetY(): number;
+    set offsetY(offset: number);
+    get scaleX(): ScaleLinear<number, number>;
+    get scaleY(): ScaleLinear<number, number>;
+}

package/dist/components/index.d.ts

@@ -0,0 +1 @@
+export * from './axis';

package/dist/constants.d.ts

@@ -0,0 +1,11 @@
+export declare const DEFAULT_LAYER_WIDTH = 200;
+export declare const DEFAULT_LAYER_HEIGHT = 300;
+export declare const HORIZONTAL_AXIS_MARGIN = 40;
+export declare const VERTICAL_AXIS_MARGIN = 30;
+export declare const EXAGGERATED_DIAMETER = 100;
+export declare const HOLE_OUTLINE = 0.6;
+export declare const SCREEN_OUTLINE = 0.3;
+export declare const SHOE_WIDTH = 8;
+export declare const SHOE_LENGTH = 16;
+export declare const DEFAULT_TEXTURE_SIZE = 64;
+export declare const SURFACE_LINE_WIDTH = 1;

package/dist/control/ExtendedCurveInterpolator.d.ts

@@ -0,0 +1,58 @@
+import { CurveInterpolator } from 'curve-interpolator';
+import { Vector } from 'curve-interpolator/dist/src/interfaces';
+import { CurveInterpolatorOptions } from 'curve-interpolator/dist/src/curve-interpolator';
+export declare class ExtendedCurveInterpolator extends CurveInterpolator {
+    arcLengthLookup: number[];
+    constructor(points: Vector[], options?: CurveInterpolatorOptions);
+    /**
+     * Function which finds t value for arc length
+     * @param {Number} arcLength Target arc length
+     * @param {Number} tolerance Tolerance for result
+     * @param {Number} iterations Max number of iterations to use
+     */
+    findTForArcLength(arcLength: number, options?: {
+        approxT?: boolean;
+        quickT?: boolean;
+        normalizedLength?: number;
+    }): number;
+    /**
+     * Function which finds t value for arc length by finding root
+     * @param {Number} arcLength Target arc length
+     * @param {Number} tolerance Tolerance for result
+     * @param {Number} iterations Max number of iterations to use
+     */
+    findTByRootForArcLength(arcLength: number, tolerance?: number, iterations?: number): number;
+    /**
+     * Function which finds t value for arc length by simple approximation
+     * @param {Number} arcLength Target arclength
+     */
+    findApproxTForArcLength(arcLength: number, normalizedLength?: number): number;
+    /**
+     * Function which finds t value for arc length using lookup table
+     * @param {Number} arcLength Target arclength
+     */
+    findTQuickForArcLength(arcLength: number): number;
+    generateArcLengthLookup(segments?: number): void;
+    /**
+     * Function calculating length along curve using interpolator.
+     * @param {Number} from t at start (default = 0)
+     * @param {Number} to t at end (default = 1)
+     */
+    getArcLength(from?: number, to?: number): number;
+    /**
+     * Function calculating length along curve using interpolator.
+     * @param {Number} from t at start (default = 0)
+     * @param {Number} to t at end (default = 1)
+     */
+    getQuickArcLength(from?: number, to?: number): number;
+    /**
+     * Function getting a point at curve length.
+     * @param {Number} arcLength
+     */
+    getPointAtArcLength(arcLength: number, options?: {
+        approxT?: boolean;
+        quickT?: boolean;
+        normalizedLength?: number;
+    }): Vector;
+    getPointAt(t: number): Vector;
+}

package/dist/control/IntersectionReferenceSystem.d.ts

@@ -0,0 +1,96 @@
+import { CurveInterpolator } from 'curve-interpolator';
+import { Interpolators, Trajectory, MDPoint } from '../interfaces';
+import { ExtendedCurveInterpolator } from './ExtendedCurveInterpolator';
+export interface ReferenceSystemOptions {
+    normalizedLength?: number;
+    arcDivisions?: number;
+    tension?: number;
+    trajectoryAngle?: number;
+    calculateDisplacementFromBottom?: boolean;
+    curveInterpolator?: ExtendedCurveInterpolator;
+    trajectoryInterpolator?: ExtendedCurveInterpolator;
+    curtainInterpolator?: ExtendedCurveInterpolator;
+    approxT?: boolean;
+    quickT?: boolean;
+}
+export declare class IntersectionReferenceSystem {
+    options: ReferenceSystemOptions;
+    path: number[][];
+    projectedPath: number[][];
+    projectedTrajectory: number[][];
+    private _offset;
+    displacement: number;
+    depthReference: number;
+    wellboreId: number;
+    trajectoryOffset: number;
+    interpolators: Interpolators;
+    startVector: number[];
+    endVector: number[];
+    _curtainPathCache: MDPoint[];
+    /**
+     * Creates a common reference system that layers and other components can use
+     * @param path (required) array of 3d coordinates: [x, y, z]
+     * @param options (optional)
+     * @param options.trajectoryAngle (optional) - trajectory angle in degrees, overrides the calculated value
+     * @param options.calculateDisplacementFromBottom - (optional) specify if the path is passed from bottom up
+     */
+    constructor(path: number[][], options?: ReferenceSystemOptions);
+    private setPath;
+    /**
+     * Map a length along the curve to intersection coordinates
+     * @param length length along the curve
+     */
+    project(length: number): number[];
+    curtainTangent(length: number): number[];
+    /**
+     * Returns as resampled version of the projected path between start and end
+     * Samples are picked from the beginning of the path at every CURTAIN_SAMPLING_INTERVAL meters
+     * If the angle between two consecutive segments is close to 180 degrees depending on CURTAIN_SAMPLING_ANGLE_THRESHOLD,
+     * a sample in between is discarded.
+     *
+     * The start and the end are not guaranteed to be part of the returned set of points
+     * @param startMd in MD
+     * @param endMd in MD
+     * @param includeStartEnd guarantee to include the starting and end points
+     */
+    getCurtainPath(startMd: number, endMd: number, includeStartEnd?: boolean): MDPoint[];
+    /**
+     * Map a displacement back to length along the curve
+     */
+    unproject(displacement: number): number;
+    /**
+     * Get the normalized displacement [0 - 1] of a specific length along the curve
+     */
+    getProjectedLength(length: number): number;
+    /**
+     * Get the trajectory position at a length along the curve
+     */
+    getPosition(length: number): number[];
+    /**
+     * Generate a set of coordinates along the trajectory of the curve
+     */
+    getTrajectory(steps: number, from?: number, to?: number): Trajectory;
+    /**
+     * Generate a set of coordinates along the trajectory of the curve
+     */
+    getExtendedTrajectory(numPoints: number, startExtensionLength?: number, endExtensionLength?: number): Trajectory;
+    getTrajectoryVector(): number[];
+    /**
+     * Perform a curtain projection on a set of points in 3D
+     * @param points
+     * @param origin
+     * @param offset
+     * @returns {array}
+     */
+    static toDisplacement(points: number[][], offset?: number): number[][];
+    /**
+     * returns a normalized vector
+     * @param interpolator interpolated curve
+     * @param from number between 0 and 1
+     * @param to number between 0 and 1
+     */
+    static getDirectionVector(interpolator: CurveInterpolator, from: number, to: number): number[];
+    get length(): number;
+    get offset(): number;
+    set offset(offset: number);
+}

package/dist/control/LayerManager.d.ts

@@ -0,0 +1,76 @@
+import { ZoomPanHandler } from './ZoomPanHandler';
+import { Layer, LayerOptions } from '../layers';
+import { ScaleOptions } from '../interfaces';
+import { Axis } from '../components';
+import { IntersectionReferenceSystem } from './IntersectionReferenceSystem';
+import { AxisOptions } from './interfaces';
+export declare class LayerManager {
+    private container;
+    private layerContainer;
+    private _zoomPanHandler;
+    private layers;
+    private _axis;
+    private _svgContainer;
+    /**
+     * Handles layers and axis also holds a zoom and pan handler object
+     * @param container root container
+     * @param scaleOptions
+     * @param axisOptions
+     */
+    constructor(container: HTMLElement, scaleOptions?: ScaleOptions, axisOptions?: AxisOptions);
+    /**
+     * Adds and mounts an array of layers
+     * @param layers array of layers
+     */
+    addLayers(layers: Layer<unknown>[]): LayerManager;
+    /**
+     * Gets all layers currently mounted
+     */
+    getLayers(): Layer<unknown>[];
+    /**
+     * Clears data from all mounted layers
+     * @param includeReferenceSystem - (optional) if true also removes reference system, default is true
+     */
+    clearAllData(includeReferenceSystem?: boolean): LayerManager;
+    /**
+     * Adds the layer to the manager, and mounts it
+     * @param layer Layer
+     * @param params extra params to pass to the onUpdate method
+     */
+    addLayer(layer: Layer<unknown>, params?: LayerOptions<unknown>): LayerManager;
+    /**
+     * Remove and unmount layer from manager
+     * @param layerId name of layer
+     */
+    removeLayer(layerId: string): LayerManager;
+    /**
+     * Remove and unmount all layers from manager
+     */
+    removeAllLayers(): LayerManager;
+    getLayer(layerId: string): Layer<unknown>;
+    initLayer(layer: Layer<unknown>, params?: LayerOptions<unknown>): LayerManager;
+    showLayer(layerId: string): LayerManager;
+    hideLayer(layerId: string): LayerManager;
+    /**
+     * Adjust layers, axis, and zoom according to inputted dimensions
+     * @param width (required)
+     * @param height (required)
+     */
+    adjustToSize(width: number, height: number): void;
+    setReferenceSystem(irs: IntersectionReferenceSystem): void;
+    showAxis(): LayerManager;
+    hideAxis(): LayerManager;
+    showAxisLabels(): LayerManager;
+    hideAxisLabels(): LayerManager;
+    setAxisOffset(x: number, y: number): LayerManager;
+    setXAxisOffset(x: number): LayerManager;
+    setYAxisOffset(y: number): LayerManager;
+    setZoomLevelBoundary(zoomlevels: [number, number]): LayerManager;
+    setMaxZoomLevel(zoomlevel: number): LayerManager;
+    setMinZoomLevel(zoomlevel: number): LayerManager;
+    destroy(): LayerManager;
+    get zoomPanHandler(): ZoomPanHandler;
+    get axis(): Axis;
+    private rescale;
+    private createAxis;
+}

package/dist/control/MainController.d.ts

@@ -0,0 +1,154 @@
+import { IntersectionReferenceSystem } from './IntersectionReferenceSystem';
+import { Layer } from '../layers';
+import { ControllerOptions } from './interfaces';
+import { ZoomPanHandler } from './ZoomPanHandler';
+import { LayerOptions, OnRescaleEvent, ReferenceSystemOptions } from '..';
+import { Axis } from '../components';
+import { Overlay } from './overlay';
+/**
+ * API for controlling data and layers
+ */
+export declare class Controller {
+    private _referenceSystem;
+    private layerManager;
+    private _overlay;
+    /**
+     * Interface to control layers, reference system, axis and overlay. overlay is created on instantiation, does not currently support opt-out.
+     * @param options
+     * @param options.container (required) Currently only supports HTMLElement
+     * @param options.scaleOptions (optional) currently supports formats listed in examples below
+     * @example scaleOptions = { xMin: 0, xMax: 100, yMin: 0, yMax: 100 }
+     * @example scaleOptions = { xBounds: [0 , 100], yBounds: [0, 100] }
+     * @param options.axisOptions (optional) creates axis with supplied labels, currently only supports creating axis on instantiation
+     * @param options.layers (optional) list of layers
+     * @param options.path (optional) creates a reference system based on an array of 3d coordinates
+     * @param options.referenceSystem (optional) sets reference system, takes priority over path if both are supplied
+     */
+    constructor(options: ControllerOptions);
+    /**
+     * Sets reference system, overrides any existing reference systems in place
+     * @param referenceSystem IntersectionReferenceSystem
+     */
+    setReferenceSystem(referenceSystem: IntersectionReferenceSystem): Controller;
+    /**
+     * Creates new reference system based on path, overrides any existing reference systems in place
+     * @param path array of coords
+     * @param options optional
+     * @param options.trajectoryAngle (optional) angle in degrees
+     */
+    updatePath(path: number[][], options?: ReferenceSystemOptions): Controller;
+    /**
+     * Clears data from all mounted layers
+     * @param includeReferenceSystem - (optional) if true also removes reference system, default is true
+     */
+    clearAllData(includeReferenceSystem?: boolean): Controller;
+    /**
+     * Adds layer to list, and initializes it
+     * @param layer layer object
+     * @param params (optional) adds additional parameters to the onUpdateEvent
+     */
+    addLayer(layer: Layer<unknown>, params?: LayerOptions<unknown>): Controller;
+    /**
+     * Remove and unmount layer from list
+     * @param layerId string id
+     */
+    removeLayer(layerId: string): Controller;
+    /**
+     * Remove and unmount all layers from list
+     */
+    removeAllLayers(): Controller;
+    /**
+     * Find first layer with given id, returns undefined if none are found
+     * @param layerId string id
+     */
+    getLayer(layerId: string): Layer<unknown>;
+    /**
+     * Sets visibility to true and rescales the layer
+     * @param layerId string id
+     */
+    showLayer(layerId: string): Controller;
+    /**
+     * Sets visibility to false
+     * @param layerId string id
+     */
+    hideLayer(layerId: string): Controller;
+    /**
+     * Adjust layers, axis, overlay, and zoom according to inputted dimensions
+     * @param width (required)
+     * @param height (required)
+     */
+    adjustToSize(width: number, height: number): Controller;
+    /**
+     * Set new viewport
+     * @param  cx - center X pos
+     * @param  cy - center Y pos
+     * @param  displ - displacement
+     * @param  duration - duration of transition
+     */
+    setViewport(cx?: number, cy?: number, displacement?: number, duration?: number): Controller;
+    /**
+     * Sets bounds for zoom and pan handler
+     * @param xBounds - domain in x-direction
+     * @param yBounds - domain in y-direction
+     */
+    setBounds(xBounds: [number, number], yBounds: [number, number]): Controller;
+    /**
+     * Display both axes
+     */
+    showAxis(): Controller;
+    /**
+     * Hide both axes
+     */
+    hideAxis(): Controller;
+    /**
+     * Shows labels in x and y
+     */
+    showAxisLabels(): Controller;
+    /**
+     * Hide labels in x and y
+     */
+    hideAxisLabels(): Controller;
+    /**
+     * Sets domain offset, offset is subtracted from domain
+     * @param x
+     * @param y
+     */
+    setAxisOffset(x: number, y: number): Controller;
+    /**
+     * Sets domain offset in x-direction, offset is subtracted from domain
+     * @param x
+     */
+    setXAxisOffset(x: number): Controller;
+    /**
+     * Sets domain offset in y-direction, offset is subtracted from domain
+     * @param y
+     */
+    setYAxisOffset(y: number): Controller;
+    /**
+     * Defines min and max of how much one can zoom
+     * @param zoomlevels
+     */
+    setZoomLevelBoundary(zoomlevels: [number, number]): Controller;
+    /**
+     * Defines how far in one can zoom
+     * @param zoomlevel
+     */
+    setMaxZoomLevel(zoomlevel: number): Controller;
+    /**
+     * Defines how far out one can zoom
+     * @param zoomlevel
+     */
+    setMinZoomLevel(zoomlevel: number): Controller;
+    /**
+     * Destroy Controller
+     * Convenience method for removing from DOM and clearing references
+     */
+    destroy(): Controller;
+    private getHighestZIndex;
+    private setOverlayZIndex;
+    get overlay(): Overlay<Controller>;
+    get referenceSystem(): IntersectionReferenceSystem;
+    get zoomPanHandler(): ZoomPanHandler;
+    get axis(): Axis;
+    get currentStateAsEvent(): OnRescaleEvent;
+}

package/dist/control/ZoomPanHandler.d.ts

@@ -0,0 +1,158 @@
+import { Selection } from 'd3-selection';
+import { ScaleLinear } from 'd3-scale';
+import { ZoomBehavior, ZoomTransform } from 'd3-zoom';
+import { ZoomAndPanOptions, OnRescaleEvent } from '../interfaces';
+export declare type RescaleFunction = (event: OnRescaleEvent) => void;
+/**
+ * Handle zoom and pan for intersection layers
+ */
+export declare class ZoomPanHandler {
+    zoom: ZoomBehavior<Element, unknown>;
+    elm: HTMLElement;
+    container: Selection<HTMLElement, unknown, null, undefined>;
+    onRescale: RescaleFunction;
+    options: ZoomAndPanOptions;
+    xBounds: [number, number];
+    yBounds: [number, number];
+    translateBoundsX: [number, number];
+    translateBoundsY: [number, number];
+    scaleX: ScaleLinear<number, number>;
+    scaleY: ScaleLinear<number, number>;
+    _zFactor: number;
+    _enableTranslateExtent: boolean;
+    currentTransform: ZoomTransform;
+    /**
+     * Constructor
+     * @param  elm, -
+     * @param  options - options
+     */
+    constructor(elm: HTMLElement, onRescale: RescaleFunction, options?: ZoomAndPanOptions);
+    /**
+     * Getter returning width of target
+     * @returns  width
+     */
+    get width(): number;
+    /**
+     * Getter returning height of target
+     * @returns  height
+     */
+    get height(): number;
+    /**
+     * Getter which calculate span from x bounds
+     * @returns  x span
+     */
+    get xSpan(): number;
+    /**
+     * Calculate span from y bounds
+     * @returns  y span
+     */
+    get ySpan(): number;
+    /**
+     * Ratio between height and width
+     * @returns  ratio
+     */
+    get viewportRatio(): number;
+    /**
+     * x ratios screen to value ratio
+     * @returns  ratio
+     */
+    get xRatio(): number;
+    /**
+     * y scale screen to value ratio
+     * @returns  ratio
+     */
+    get yRatio(): number;
+    /**
+     * Get z-factor
+     * @returns  z-factor
+     */
+    get zFactor(): number;
+    /**
+     * Set z factor
+     * @param  factor
+     */
+    set zFactor(factor: number);
+    /**
+     * Check if x is inverted (right to left is positive) from x bounds
+     * @returns  true if inverted
+     */
+    get isXInverted(): boolean;
+    /**
+     * Check if y is inverted (bottom to top is positive) from y bounds
+     * @returns  true if inverted
+     */
+    get isYInverted(): boolean;
+    /**
+     * Get if enable translate extent (pan limit)
+     * @returns  true if enabled
+     */
+    get enableTranslateExtent(): boolean;
+    /**
+     * Set enable translate extent (pan limit)
+     * @param  enabled - If should be enabled
+     */
+    set enableTranslateExtent(enabled: boolean);
+    /**
+     * Update translate extent (pan limits)
+     */
+    updateTranslateExtent(): void;
+    /**
+     * Create an event object from current state
+     */
+    currentStateAsEvent(): OnRescaleEvent;
+    /**
+     * Update scale
+     */
+    rescale(): void;
+    /**
+     * Initialized handler
+     */
+    init(): void;
+    /**
+     * Handle zoom
+     */
+    onZoom(event: {
+        transform: ZoomTransform;
+    }): void;
+    /**
+     * Update scale
+     */
+    applyTransform(transform: ZoomTransform): void;
+    /**
+     * Set new viewport
+     * @param  cx - center X pos
+     * @param  cy - center Y pos
+     * @param  displ
+     * @param  duration - duration of transition
+     * @returns  a merge of filter and payload
+     */
+    setViewport(cx?: number, cy?: number, displ?: number, duration?: number): void;
+    /**
+     * Set bounds
+     */
+    setBounds(xBounds: [number, number], yBounds: [number, number]): void;
+    /**
+     * Set bounds
+     */
+    setTranslateBounds(xBounds: [number, number], yBounds: [number, number]): void;
+    /**
+     * Adjust zoom due to changes in size of target
+     * @param  force - force update even if size did not change
+     */
+    adjustToSize(width?: number | boolean, height?: number, force?: boolean): void;
+    /**
+     * Calculate new transform
+     * @param  dx0
+     * @param  dx1
+     * @param  dy
+     * @returns  New transformation matrix
+     */
+    calculateTransform(dx0: number, dx1: number, dy: number): ZoomTransform;
+    /**
+     * Recalcualate the transform
+     */
+    recalculateZoomTransform(): void;
+    setZoomLevelBoundary(zoomlevels: [number, number]): ZoomPanHandler;
+    setMaxZoomLevel(zoomlevel: number): ZoomPanHandler;
+    setMinZoomLevel(zoomlevel: number): ZoomPanHandler;
+}

package/dist/control/index.d.ts

@@ -0,0 +1,5 @@
+export * from './interfaces';
+export * from './IntersectionReferenceSystem';
+export * from './LayerManager';
+export * from './MainController';
+export * from './ZoomPanHandler';

package/dist/control/interfaces.d.ts

@@ -0,0 +1,37 @@
+import { IntersectionReferenceSystem } from './IntersectionReferenceSystem';
+import { ScaleOptions } from '../interfaces';
+import { Layer } from '../layers';
+export interface AxisOptions {
+    xLabel: string;
+    yLabel: string;
+    unitOfMeasure: string;
+}
+export interface ControllerOptions {
+    container: HTMLElement;
+    axisOptions?: AxisOptions;
+    scaleOptions?: ScaleOptions;
+    referenceSystem?: IntersectionReferenceSystem;
+    layers?: Layer<unknown>[];
+    path?: number[][];
+}
+interface OverlayEvent<T> {
+    target?: Element;
+    source: Element;
+    caller: T;
+}
+export interface OverlayResizeEvent<T> extends OverlayEvent<T> {
+    width: number;
+    height: number;
+}
+export interface OverlayMouseMoveEvent<T> extends OverlayEvent<T> {
+    x: number;
+    y: number;
+}
+export interface OverlayMouseExitEvent<T> extends OverlayEvent<T> {
+}
+export interface OverlayCallbacks<T> {
+    onMouseMove?(event: OverlayMouseMoveEvent<T>): void;
+    onMouseExit?(event: OverlayMouseExitEvent<T>): void;
+    onResize?(event: OverlayResizeEvent<T>): void;
+}
+export {};

package/dist/control/overlay.d.ts

@@ -0,0 +1,20 @@
+import { Selection } from 'd3-selection';
+import { OverlayCallbacks } from './interfaces';
+export declare class Overlay<T> {
+    elm: Selection<Element, unknown, null, undefined>;
+    source: Element;
+    elements: {
+        [propName: string]: Element;
+    };
+    listeners: {
+        [propName: string]: OverlayCallbacks<T>;
+    };
+    enabled: boolean;
+    constructor(caller: T, container: HTMLElement);
+    create(key: string, callbacks?: OverlayCallbacks<T>): HTMLElement;
+    register(key: string, callbacks: OverlayCallbacks<T>): void;
+    remove(key: string): void;
+    setZIndex(zIndex: number): void;
+    destroy(): void;
+}
+export declare const overlay: <T>(caller: T, container: HTMLElement) => Overlay<T>;

package/dist/datautils/camelcase.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Convert json input keys to camelcase
+ * @param {*} data
+ */
+export declare function convertToCamelCase(data: any): any;

package/dist/datautils/colortable.d.ts

@@ -0,0 +1 @@
+export declare function createColorTable(colorMap: string[], size: number): number[][];

package/dist/datautils/findsample.d.ts

@@ -0,0 +1,2 @@
+export declare function findIndexOfSample(data: number[][], pos: number): number;
+export declare function findSampleAtPos(data: number[][], pos: number, topLimit?: number, bottomLimit?: number): number;