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

package/dist/interfaces.d.ts

@@ -1,186 +0,0 @@
-import { ZoomTransform } from 'd3-zoom';
-import { Graphics, IApplicationOptions } from 'pixi.js';
-import { Layer } from './layers/base/Layer';
-import { IntersectionReferenceSystem } from './control/IntersectionReferenceSystem';
-import Vector2 from '@equinor/videx-vector2';
-interface LayerEvent {
-    [propType: string]: any;
-    elm?: HTMLElement;
-}
-export interface OnMountEvent extends LayerEvent {
-    elm: HTMLElement;
-}
-export interface OnUnmountEvent extends LayerEvent {
-}
-export interface OnResizeEvent extends LayerEvent {
-    width: number;
-    height: number;
-}
-export interface OnRescaleEvent extends LayerEvent {
-    xBounds?: [number, number];
-    yBounds?: [number, number];
-    zFactor?: number;
-    viewportRatio?: number;
-    width?: number;
-    height?: number;
-    xRatio?: number;
-    yRatio?: number;
-    transform?: ZoomTransform;
-}
-export interface OnUpdateEvent extends LayerEvent {
-}
-export interface LayerOptions {
-    order?: number;
-    layerOpacity?: number;
-    referenceSystem?: IntersectionReferenceSystem;
-    data?: any;
-    interactive?: boolean;
-    onMount?(event: OnMountEvent, layer: Layer): void;
-    onUnmount?(event: OnUnmountEvent, layer: Layer): void;
-    onUpdate?(event: OnUpdateEvent, layer: Layer): void;
-    onRescale?(event: OnRescaleEvent, layer: Layer): void;
-    onResize?(event: OnResizeEvent, layer: Layer): void;
-}
-export interface GridLayerOptions extends LayerOptions {
-    majorWidth?: number;
-    majorColor?: string;
-    minorWidth?: number;
-    minorColor?: string;
-}
-export interface WellborepathLayerOptions extends LayerOptions {
-    stroke: string;
-    strokeWidth: string;
-    curveType?: string;
-    tension?: number;
-}
-export interface GeomodelLayerOptions extends LayerOptions {
-}
-export interface CompletionLayerOptions extends PixiLayerOptions {
-}
-export interface GeomodelLayerLabelsOptions extends LayerOptions {
-    margins?: number;
-    minFontSize?: number;
-    maxFontSize?: number;
-    textColor?: string;
-    font?: string;
-}
-export interface HoleSizeLayerOptions extends WellComponentBaseOptions {
-    firstColor?: string;
-    secondColor?: string;
-    lineColor?: number;
-}
-export interface CasingShoeSize {
-    width: number;
-    length: number;
-}
-export interface CasingLayerOptions extends WellComponentBaseOptions {
-    solidColor?: number;
-    lineColor?: number;
-    casingShoeSize?: CasingShoeSize;
-}
-export interface CementLayerOptions extends WellComponentBaseOptions {
-    firstColor?: string;
-    secondColor?: string;
-}
-export interface PixiLayerOptions extends LayerOptions {
-    pixiApplicationOptions?: IApplicationOptions;
-}
-export interface WellComponentBaseOptions extends PixiLayerOptions {
-    exaggerationFactor?: number;
-}
-export interface ZoomAndPanOptions {
-    maxZoomLevel: number;
-    minZoomLevel: number;
-}
-export interface Connector {
-    end: string;
-    endScale: number;
-}
-export interface Annotation {
-    title: string;
-    label: string;
-    color: string;
-    group: string;
-    md?: number;
-    pos?: [number, number];
-}
-export interface HoleSize {
-    diameter: number;
-    start: number;
-    end: number;
-    innerDiameter?: number;
-}
-export interface Casing {
-    diameter: number;
-    start: number;
-    end: number;
-    hasShoe: boolean;
-    innerDiameter: number;
-    casingId: string;
-}
-export interface Cement {
-    toc: number;
-    casingIds?: string[];
-    /**
-     * Should remove optional on casingIds when casingId is removed in next major release
-     * @‌deprecated use casingIds
-     */
-    casingId?: string;
-}
-export interface MDPoint {
-    point: number[];
-    normal?: Vector2;
-    md: number;
-}
-export interface WellItemGraphics {
-    graphics: Graphics;
-}
-export interface ScaleOptions {
-    xMin?: number;
-    xMax?: number;
-    yMin?: number;
-    yMax?: number;
-    xBounds?: [number, number];
-    yBounds?: [number, number];
-}
-export interface Interpolators {
-    trajectory: any;
-    curtain: any;
-    position?: any;
-    curve?: any;
-}
-export interface Interpolator {
-}
-export interface Trajectory {
-    points: number[][];
-    offset: number;
-}
-export interface ReferenceSystemOptions {
-    normalizedLength?: number;
-    arcDivisions?: number;
-    tension?: number;
-    trajectoryAngle?: number;
-    calculateDisplacementFromBottom?: boolean;
-    curveInterpolator?: Interpolator;
-    trajectoryInterpolator?: Interpolator;
-    curtainInterpolator?: Interpolator;
-    approxT?: boolean;
-    quickT?: boolean;
-}
-export declare type BoundingBox = {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    offsetX?: number;
-    offsetY?: number;
-};
-export interface CalloutOptions extends LayerOptions {
-    minFontSize?: number;
-    maxFontSize?: number;
-    fontSizeFactor?: number;
-    offsetMin?: number;
-    offsetMax?: number;
-    offsetFactor?: number;
-}
-export {};

package/dist/layers/CalloutCanvasLayer.d.ts

@@ -1,51 +0,0 @@
-import { ScaleLinear } from 'd3-scale';
-import { CanvasLayer } from './base/CanvasLayer';
-import { OnUpdateEvent, Annotation, OnRescaleEvent, BoundingBox, CalloutOptions } from '../interfaces';
-export declare type Point = {
-    x: number;
-    y: number;
-};
-export declare type Callout = {
-    title: string;
-    label: string;
-    color: string;
-    pos: Point;
-    group: string;
-    alignment: string;
-    boundingBox: BoundingBox;
-    dx: number;
-    dy: number;
-};
-export declare class CalloutCanvasLayer extends CanvasLayer {
-    rescaleEvent: OnRescaleEvent;
-    xRatio: number;
-    callouts: Callout[];
-    groupFilter: string[];
-    minFontSize: number;
-    maxFontSize: number;
-    fontSizeFactor: number;
-    offsetMin: number;
-    offsetMax: number;
-    offsetFactor: number;
-    constructor(id?: string, options?: CalloutOptions);
-    setGroupFilter(filter: string[]): void;
-    onUpdate(event: OnUpdateEvent): void;
-    onRescale(event: OnRescaleEvent): void;
-    render(isPanning?: boolean): void;
-    private renderAnnotation;
-    private renderText;
-    private renderPoint;
-    private renderCallout;
-    private renderLine;
-    private getPosition;
-    positionCallouts(annotations: Annotation[], isLeftToRight: boolean, xScale: ScaleLinear<number, number>, yScale: ScaleLinear<number, number>, scale: number, fontSize: number, offset?: number): Callout[];
-    getAnnotationBoundingBox(title: string, label: string, pos: number[], xScale: ScaleLinear<number, number>, yScale: ScaleLinear<number, number>, height: number): {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-    chooseTopOrBottomPosition(nodes: Callout[], bottom: Callout[], top: Callout[]): void;
-    adjustTopPositions(top: Callout[]): void;
-    adjustBottomPositions(bottom: Callout[]): void;
-}

package/dist/layers/CasingLayer.d.ts

@@ -1,21 +0,0 @@
-import { Point, Texture } from 'pixi.js';
-import { WellboreBaseComponentLayer } from './WellboreBaseComponentLayer';
-import { CasingLayerOptions, Casing } from '..';
-export interface CasingRenderObject {
-    pathPoints: number[][];
-    polygon: Point[];
-    leftPath: Point[];
-    rightPath: Point[];
-    radius: number;
-    diameter: number;
-    casingWallWidth: number;
-}
-export declare class CasingLayer extends WellboreBaseComponentLayer {
-    constructor(id?: string, options?: CasingLayerOptions);
-    preRender(): void;
-    prepareCasingRenderObject: (casing: Casing) => CasingRenderObject;
-    drawCasing: (zippedRenderObject: [Casing, CasingRenderObject]) => void;
-    drawShoe(casingEnd: number, casingRadius: number): void;
-    generateShoe: (casingEnd: number, casingRadius: number, length: number, width: number) => Point[];
-    createTexture(diameter: number): Texture;
-}

package/dist/layers/CementLayer.d.ts

@@ -1,14 +0,0 @@
-import { Point, Texture } from 'pixi.js';
-import { WellboreBaseComponentLayer } from './WellboreBaseComponentLayer';
-import { CementLayerOptions, Cement, Casing, HoleSize } from '../interfaces';
-export interface CementShape {
-    rightPolygon: Point[];
-    leftPolygon: Point[];
-    path: Point[];
-}
-export declare class CementLayer extends WellboreBaseComponentLayer {
-    constructor(id?: string, options?: CementLayerOptions);
-    preRender(): void;
-    createCementShape: (cement: Cement, casings: Casing[], holes: HoleSize[]) => CementShape;
-    createTexture(): Texture;
-}

package/dist/layers/CompletionLayer.d.ts

@@ -1,20 +0,0 @@
-import { Graphics } from 'pixi.js';
-import { PixiLayer } from './base/PixiLayer';
-import { OnUpdateEvent } from '..';
-import { CompletionLayerOptions, OnRescaleEvent } from '../interfaces';
-export interface CompletionItem {
-}
-export declare class CompletionLayer extends PixiLayer {
-    constructor(id: string, options: CompletionLayerOptions);
-    onRescale(event: OnRescaleEvent): void;
-    onUpdate(event: OnUpdateEvent): void;
-    preRender(): void;
-    clearStage(): void;
-    getShape(type: string): Graphics;
-    getScale(type: string, length: number, width: number): {
-        scaleX: number;
-        scaleY: number;
-    };
-    generateCompletionItem(wbp: any, data: any): CompletionItem;
-    drawCompletionItem(item: any): void;
-}

package/dist/layers/GeomodelCanvasLayer.d.ts

@@ -1,27 +0,0 @@
-import { SurfaceData } from '../datautils';
-import { GeomodelLayerOptions, OnUpdateEvent, OnRescaleEvent, OnMountEvent } from '../interfaces';
-import { CanvasLayer } from './base/CanvasLayer';
-export declare class GeomodelCanvasLayer extends CanvasLayer {
-    rescaleEvent: OnRescaleEvent;
-    surfaceAreasPaths: any[];
-    surfaceLinesPaths: any[];
-    maxDepth: number;
-    constructor(id?: string, options?: GeomodelLayerOptions);
-    get data(): SurfaceData;
-    set data(data: SurfaceData);
-    getData(): SurfaceData;
-    setData(data: SurfaceData): void;
-    onMount(event: OnMountEvent): void;
-    onUpdate(event: OnUpdateEvent): void;
-    onRescale(event: OnRescaleEvent): void;
-    updatePaths(): void;
-    render(): void;
-    colorToCSSColor(color: number | string): string;
-    generateSurfaceAreasPaths(): void;
-    generateSurfaceLinesPaths(): void;
-    drawPolygonPath: (color: string, path: Path2D) => void;
-    drawLinePath: (color: string, path: Path2D) => void;
-    createPolygons: (data: any) => number[][];
-    generatePolygonPath: (polygon: number[]) => Path2D;
-    generateLinePaths: (s: any) => Path2D[];
-}

package/dist/layers/GeomodelLabelsLayer.d.ts

@@ -1,37 +0,0 @@
-import Vector2 from '@equinor/videx-vector2';
-import { CanvasLayer } from './base/CanvasLayer';
-import { GeomodelLayerLabelsOptions, OnUpdateEvent, OnRescaleEvent, OnMountEvent } from '../interfaces';
-import { SurfaceArea, SurfaceLine, SurfaceData } from '../datautils';
-export declare class GeomodelLabelsLayer extends CanvasLayer {
-    defaultMargins: number;
-    defaultMinFontSize: number;
-    defaultMaxFontSize: number;
-    defaultTextColor: string;
-    defaultFont: string;
-    rescaleEvent: OnRescaleEvent;
-    isLabelsOnLeftSide: boolean;
-    maxFontSizeInWorldCoordinates: number;
-    isXFlipped: boolean;
-    areasWithAvgTopDepth: any[];
-    constructor(id?: string, options?: GeomodelLayerLabelsOptions);
-    get options(): GeomodelLayerLabelsOptions;
-    setData(data: SurfaceData): void;
-    generateSurfacesWithAvgDepth(): any;
-    onMount(event: OnMountEvent): void;
-    onUpdate(event: OnUpdateEvent): void;
-    onRescale(event: OnRescaleEvent): void;
-    render(): void;
-    drawAreaLabels(): void;
-    drawLineLabels(): void;
-    drawAreaLabel: (surfaceArea: SurfaceArea, nextSurfaceArea: SurfaceArea, surfaces: any[], i: number) => void;
-    drawLineLabel: (s: SurfaceLine) => void;
-    colorToCSSColor(color: number | string): string;
-    calcPos(data: number[][], offset: number, count: number, step: number, topLimit?: number, bottomLimit?: number, alternativeSurfaceData?: number[][], surfaces?: any[], currentSurfaceIndex?: number): Vector2;
-    getAlternativeYValueIfAvailable(x: number, topLimit: number, bottomLimit: number, alternativeSurfaceData: number[][], surfaces: any[], currentSurfaceIndex: number): number;
-    calcLineDir(data: number[][], offset: number, count: number, step: number, zFactor: number, initalVector?: Vector2, topLimit?: number, bottomLimit?: number): Vector2;
-    calcAreaDir(top: number[][], bottom: number[][], offset: number, count: number, step: number, initalVector?: Vector2, topLimit?: number, bottomLimit?: number, minReductionAngle?: number, maxReductionAngle?: number, angleReductionExponent?: number, alternativeSurfaceBottomData?: number[][], surfaces?: any[], currentSurfaceIndex?: number): number;
-    updateXFlipped(): void;
-    getMarginsInWorldCoordinates(): number;
-    getSurfacesAreaEdges(): number[];
-    checkDrawLabelsOnLeftSide(): boolean;
-}

package/dist/layers/GeomodelLayer.d.ts

@@ -1,7 +0,0 @@
-import { GeomodelLayerV2 } from './GeomodelLayerV2';
-/**
- *
- * @deprecated The GeomodelLayer class is deprecated, use GeomodelLayerV2
- */
-export declare class GeomodelLayer extends GeomodelLayerV2 {
-}

package/dist/layers/GeomodelLayerV2.d.ts

@@ -1,13 +0,0 @@
-import { PixiLayer } from './base/PixiLayer';
-import { OnRescaleEvent, OnUpdateEvent } from '../interfaces';
-import { SurfaceArea, SurfaceLine } from '../datautils';
-export declare class GeomodelLayerV2 extends PixiLayer {
-    private isPreRendered;
-    onRescale(event: OnRescaleEvent): void;
-    onUpdate(event: OnUpdateEvent): void;
-    clearStage(): void;
-    preRender(): void;
-    createPolygons: (data: any) => number[][];
-    generateAreaPolygon: (s: SurfaceArea) => void;
-    generateSurfaceLine: (s: SurfaceLine) => void;
-}

package/dist/layers/GridLayer.d.ts

@@ -1,17 +0,0 @@
-import { CanvasLayer } from './base/CanvasLayer';
-import { GridLayerOptions, OnUpdateEvent, OnRescaleEvent } from '../interfaces';
-export declare class GridLayer extends CanvasLayer {
-    private _offsetX;
-    private _offsetY;
-    constructor(id?: string, options?: GridLayerOptions);
-    onUpdate(event: OnUpdateEvent): void;
-    onRescale(event: OnRescaleEvent): void;
-    render(event: OnRescaleEvent | OnUpdateEvent): void;
-    private renderTicksX;
-    private renderTicksY;
-    private mapMinorTicks;
-    get offsetX(): number;
-    set offsetX(offset: number);
-    get offsetY(): number;
-    set offsetY(offset: number);
-}

package/dist/layers/HoleSizeLayer.d.ts

@@ -1,11 +0,0 @@
-import { Texture } from 'pixi.js';
-import { WellboreBaseComponentLayer } from './WellboreBaseComponentLayer';
-import { HoleSizeLayerOptions, HoleSize } from '..';
-export declare class HoleSizeLayer extends WellboreBaseComponentLayer {
-    maxDiameter: number;
-    constructor(id?: string, options?: HoleSizeLayerOptions);
-    preRender(): void;
-    drawHoleSize: (holeObject: HoleSize) => void;
-    createTexture(diameter: number): Texture;
-    createBaseTexture(width: number, height: number): Texture;
-}

package/dist/layers/ImageCanvasLayer.d.ts

@@ -1,9 +0,0 @@
-import { CanvasLayer } from './base/CanvasLayer';
-import { OnUpdateEvent, OnMountEvent, OnRescaleEvent } from '../interfaces';
-export declare class ImageLayer extends CanvasLayer {
-    img: HTMLImageElement;
-    onMount(event: OnMountEvent): void;
-    onUpdate(event: OnUpdateEvent): void;
-    onRescale(event: OnRescaleEvent): void;
-    render(event: OnUpdateEvent): void;
-}

package/dist/layers/SeismicCanvasLayer.d.ts

@@ -1,8 +0,0 @@
-import { CanvasLayer } from './base/CanvasLayer';
-import { OnUpdateEvent, OnMountEvent, OnRescaleEvent } from '../interfaces';
-export declare class SeismicCanvasLayer extends CanvasLayer {
-    onMount(event: OnMountEvent): void;
-    onUpdate(event: OnUpdateEvent): void;
-    onRescale(event: OnRescaleEvent): void;
-    render(): void;
-}

package/dist/layers/WellboreBaseComponentLayer.d.ts

@@ -1,26 +0,0 @@
-import { Graphics, Texture, Point } from 'pixi.js';
-import { PixiLayer } from './base/PixiLayer';
-import { OnUpdateEvent, OnRescaleEvent, WellComponentBaseOptions, MDPoint, OnUnmountEvent } from '../interfaces';
-export declare abstract class WellboreBaseComponentLayer extends PixiLayer {
-    _textureCache: Texture;
-    rescaleEvent: OnRescaleEvent;
-    constructor(id?: string, options?: WellComponentBaseOptions);
-    abstract preRender(): void;
-    onUnmount(event?: OnUnmountEvent): void;
-    onUpdate(event: OnUpdateEvent): void;
-    onRescale(event: OnRescaleEvent): void;
-    clearStage(): void;
-    /**
-     * Calculate yRatio without zFactor
-     * TODO consider to move this into ZoomPanHandler
-     */
-    yRatio(): number;
-    getMdPoint: (md: number) => MDPoint;
-    getPathForPoints: (start: number, end: number, interestPoints: number[]) => MDPoint[];
-    getZFactorScaledPathForPoints: (start: number, end: number, interestPoints: number[]) => MDPoint[];
-    drawBigPolygon: (coords: Point[], color?: number) => Graphics;
-    drawBigTexturedPolygon: (coords: Point[], t: Texture) => Graphics;
-    drawRopeWithMask(path: Point[], maskPolygon: Point[], texture: Texture): void;
-    drawRope(path: Point[], texture: Texture, tint?: number): void;
-    drawOutline(leftPath: Point[], rightPath: Point[], lineColor: number, lineWidth?: number, close?: boolean): void;
-}

package/dist/layers/WellborePathLayer.d.ts

@@ -1,10 +0,0 @@
-import { SVGLayer } from './base/SVGLayer';
-import { WellborepathLayerOptions, OnUpdateEvent, OnRescaleEvent } from '../interfaces';
-export declare class WellborepathLayer extends SVGLayer {
-    rescaleEvent: OnRescaleEvent;
-    constructor(id?: string, options?: WellborepathLayerOptions);
-    onUpdate(event: OnUpdateEvent): void;
-    onRescale(event: OnRescaleEvent): void;
-    render(): void;
-    private renderWellborePath;
-}

package/dist/layers/base/CanvasLayer.d.ts

@@ -1,19 +0,0 @@
-import { Layer } from './Layer';
-import { OnMountEvent, OnUpdateEvent, OnResizeEvent, OnRescaleEvent } from '../../interfaces';
-export declare abstract class CanvasLayer extends Layer {
-    ctx: CanvasRenderingContext2D;
-    elm: HTMLElement;
-    canvas: HTMLCanvasElement;
-    onOpacityChanged(opacity: number): void;
-    onOrderChanged(order: number): void;
-    onInteractivityChanged(interactive: boolean): void;
-    setVisibility(visible: boolean): void;
-    updateStyle(visible?: boolean): void;
-    onMount(event: OnMountEvent): void;
-    onUnmount(): void;
-    onResize(event: OnResizeEvent): void;
-    onUpdate(event: OnUpdateEvent): void;
-    resetTransform(): void;
-    setTransform(event: OnRescaleEvent): void;
-    clearCanvas(): void;
-}

package/dist/layers/base/HTMLLayer.d.ts

@@ -1,13 +0,0 @@
-import { Selection } from 'd3-selection';
-import { Layer } from './Layer';
-import { OnMountEvent, OnResizeEvent } from '../../interfaces';
-export declare abstract class HTMLLayer extends Layer {
-    elm: Selection<HTMLElement, any, null, undefined>;
-    onMount(event: OnMountEvent): void;
-    onUnmount(): void;
-    onResize(event: OnResizeEvent): void;
-    setVisibility(visible: boolean): void;
-    onOpacityChanged(opacity: number): void;
-    onOrderChanged(order: number): void;
-    onInteractivityChanged(shouldBeInteractive: boolean): void;
-}

package/dist/layers/base/Layer.d.ts

@@ -1,49 +0,0 @@
-import { LayerOptions, OnMountEvent, OnUnmountEvent, OnUpdateEvent, OnRescaleEvent, OnResizeEvent } from '../../interfaces';
-import { IntersectionReferenceSystem } from '../../control';
-export declare abstract class Layer {
-    private _id;
-    private _order;
-    protected _options: LayerOptions;
-    private loading;
-    private _element?;
-    private _opacity;
-    private _referenceSystem?;
-    private _data?;
-    private _visible;
-    private _interactive;
-    constructor(id?: string, options?: LayerOptions);
-    get id(): string;
-    get element(): HTMLElement;
-    get options(): LayerOptions;
-    set options(options: LayerOptions);
-    set isLoading(loading: boolean);
-    get isLoading(): boolean;
-    set opacity(opacity: number);
-    get opacity(): number;
-    set order(order: number);
-    get order(): number;
-    set interactive(shouldBeInteractive: boolean);
-    get interactive(): boolean;
-    get referenceSystem(): IntersectionReferenceSystem;
-    set referenceSystem(referenceSystem: IntersectionReferenceSystem);
-    get data(): any;
-    set data(data: any);
-    get isVisible(): boolean;
-    getData(): any;
-    setData(data: any): void;
-    /**
-     * Clears data and (optionally) the reference system
-     * @param includeReferenceSystem - (optional) if true also removes reference system, default is true
-     */
-    clearData(includeReferenceSystem?: boolean): void;
-    setVisibility(visible: boolean): void;
-    onMount(event: OnMountEvent): void;
-    onUnmount(event?: OnUnmountEvent): void;
-    onResize(event: OnResizeEvent): void;
-    onUpdate(event: OnUpdateEvent): void;
-    onRescale(event: OnRescaleEvent): void;
-    optionsRescale(event: OnRescaleEvent): void;
-    onOpacityChanged(opacity: number): void;
-    onOrderChanged(order: number): void;
-    onInteractivityChanged(interactive: boolean): void;
-}

package/dist/layers/base/PixiLayer.d.ts

@@ -1,27 +0,0 @@
-import { AbstractRenderer, Container, IRendererOptionsAuto, RENDERER_TYPE } from 'pixi.js';
-import { Layer } from './Layer';
-import { OnMountEvent, OnRescaleEvent, OnResizeEvent, OnUnmountEvent, PixiLayerOptions } from '../../interfaces';
-export declare class PixiRenderApplication {
-    stage: Container;
-    renderer: AbstractRenderer;
-    constructor(pixiRenderOptions: IRendererOptionsAuto);
-    destroy(): void;
-    get view(): HTMLCanvasElement;
-    render(): void;
-}
-export declare abstract class PixiLayer extends Layer {
-    elm: HTMLElement;
-    ctx: PixiRenderApplication;
-    constructor(id?: string, options?: PixiLayerOptions);
-    onMount(event: OnMountEvent): void;
-    render(): void;
-    onUnmount(event?: OnUnmountEvent): void;
-    onResize(event: OnResizeEvent): void;
-    onRescale(event: OnRescaleEvent): void;
-    updateStyle(visible?: boolean): void;
-    setVisibility(visible: boolean): void;
-    onOpacityChanged(opacity: number): void;
-    onOrderChanged(order: number): void;
-    onInteractivityChanged(interactive: boolean): void;
-    renderType(): RENDERER_TYPE;
-}

package/dist/layers/base/SVGLayer.d.ts

@@ -1,13 +0,0 @@
-import { Selection } from 'd3-selection';
-import { Layer } from './Layer';
-import { OnMountEvent, OnResizeEvent } from '../../interfaces';
-export declare abstract class SVGLayer extends Layer {
-    elm: Selection<SVGElement, any, null, undefined>;
-    onMount(event: OnMountEvent): void;
-    onUnmount(): void;
-    onResize(event: OnResizeEvent): void;
-    setVisibility(visible: boolean): void;
-    onOpacityChanged(opacity: number): void;
-    onOrderChanged(order: number): void;
-    onInteractivityChanged(shouldBeInteractive: boolean): void;
-}

package/dist/layers/base/index.d.ts

@@ -1,5 +0,0 @@
-export * from './Layer';
-export * from './CanvasLayer';
-export * from './HTMLLayer';
-export * from './SVGLayer';
-export * from './PixiLayer';

package/dist/layers/index.d.ts

@@ -1,18 +0,0 @@
-export * from './base/Layer';
-export * from './base/CanvasLayer';
-export * from './GridLayer';
-export * from './base/SVGLayer';
-export * from './base/HTMLLayer';
-export * from './WellborePathLayer';
-export * from './GeomodelLayer';
-export * from './GeomodelCanvasLayer';
-export * from './GeomodelLayerV2';
-export * from './GeomodelLabelsLayer';
-export * from './CalloutCanvasLayer';
-export * from './ImageCanvasLayer';
-export * from './HoleSizeLayer';
-export * from './CasingLayer';
-export * from './CementLayer';
-export * from './SeismicCanvasLayer';
-export * from './base/PixiLayer';
-export * from './CompletionLayer';

package/dist/utils/arc-length.d.ts

@@ -1,23 +0,0 @@
-import { Vector } from 'curve-interpolator/dist/src/interfaces';
-declare type fx = (n: number) => Vector;
-export declare class ArcLength {
-    /**
-     * Calculate using an adaptive bisect method
-     * @param {Number} func Curve function returning [x,y]
-     * @param {Number} minLimit Min limit
-     * @param {Number} maxLimit Max limit
-     * @param {Number} tolerance Result tolerance
-     * @param {Number} minDepth Min recursive depth before accepting solution
-     * @param {Number} maxDepth Max recursive depth
-     */
-    static bisect(func: fx, minLimit?: number, maxLimit?: number, tolerance?: number, minDepth?: number, maxDepth?: number): number;
-    /**
-     * Calculate using trapezoid method
-     * @param {Number} func Curve function returning [x,y]
-     * @param {Number} minLimit Min limit
-     * @param {Number} maxLimit Max limit
-     * @param {Number} segments Number of segments
-     */
-    static trapezoid(func: fx, minLimit?: number, maxLimit?: number, segments?: number): number;
-}
-export {};

package/dist/utils/binary-search.d.ts

@@ -1,8 +0,0 @@
-/**
- * Find index where value[index] =< searchValue and value[index+1] >= searchValue using binary search
- * @param {Number} values Array of sorted values
- * @param {Number} searchValue Value to search for
- */
-export declare class BinarySearch {
-    static search(values: number[], searchValue: number): number;
-}

package/dist/utils/color.d.ts

@@ -1,5 +0,0 @@
-/**
- * Convert color string to number
- */
-export declare function convertColor(colorStr: string): number;
-export declare function colorToCSSColor(color: number | string): string;