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

package/dist/interfaces.d.ts

@@ -0,0 +1,86 @@
+import { ZoomTransform } from 'd3-zoom';
+import { Graphics } from 'pixi.js';
+import Vector2 from '@equinor/videx-vector2';
+import { ScaleLinear } from 'd3-scale';
+import { ExtendedCurveInterpolator } from './control/ExtendedCurveInterpolator';
+import { CurveInterpolator } from 'curve-interpolator';
+interface LayerEvent {
+    elm?: HTMLElement;
+}
+export interface OnMountEvent extends LayerEvent {
+    elm: HTMLElement;
+    width?: number;
+    height?: number;
+}
+export interface OnUnmountEvent extends LayerEvent {
+}
+export interface OnResizeEvent extends LayerEvent {
+    width: number;
+    height: number;
+}
+export interface OnRescaleEvent extends LayerEvent {
+    xScale: ScaleLinear<number, number, never>;
+    yScale: ScaleLinear<number, number, never>;
+    xBounds: [number, number];
+    yBounds: [number, number];
+    zFactor: number;
+    viewportRatio: number;
+    xRatio: number;
+    yRatio: number;
+    width: number;
+    height: number;
+    transform: ZoomTransform;
+}
+export interface OnUpdateEvent<T> extends LayerEvent {
+    data?: T;
+}
+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 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: CurveInterpolator;
+    curtain: ExtendedCurveInterpolator;
+    curve?: ExtendedCurveInterpolator;
+}
+export interface Trajectory {
+    points: number[][];
+    offset: number;
+}
+export declare type BoundingBox = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    offsetX?: number;
+    offsetY?: number;
+};
+export {};

package/dist/layers/CalloutCanvasLayer.d.ts

@@ -0,0 +1,60 @@
+import { ScaleLinear } from 'd3-scale';
+import { CanvasLayer } from './base/CanvasLayer';
+import { OnUpdateEvent, Annotation, OnRescaleEvent, BoundingBox } from '../interfaces';
+import { LayerOptions } from './base/Layer';
+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 interface CalloutOptions<T extends Annotation[]> extends LayerOptions<T> {
+    minFontSize?: number;
+    maxFontSize?: number;
+    fontSizeFactor?: number;
+    offsetMin?: number;
+    offsetMax?: number;
+    offsetFactor?: number;
+}
+export declare class CalloutCanvasLayer<T extends Annotation[]> extends CanvasLayer<T> {
+    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<T>);
+    setGroupFilter(filter: string[]): void;
+    onUpdate(event: OnUpdateEvent<T>): 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/CustomDisplayObjects/ComplexRope.d.ts

@@ -0,0 +1,22 @@
+import { IPoint, Mesh, Renderer, Texture } from 'pixi.js';
+export declare type ComplexRopeSegment = {
+    points: IPoint[];
+    diameter: number;
+};
+/**
+ * The ComplexRope allows you to draw a texture across several segments of points and then manipulate these points
+ */
+export declare class ComplexRope extends Mesh {
+    /**
+     * re-calculate vertices by rope segment-points each frame
+     * @member {boolean}
+     */
+    autoUpdate: boolean;
+    /**
+     * @param texture - The texture to use on the rope.
+     * @param segments - An array of segments with points and diaeter to construct this rope.
+     * @param {number} textureScale - Optional. Adjust interval of repeated texture
+     */
+    constructor(texture: Texture, segments: ComplexRopeSegment[], textureScale?: number);
+    _render(renderer: Renderer): void;
+}

package/dist/layers/CustomDisplayObjects/ComplexRopeGeometry.d.ts

@@ -0,0 +1,27 @@
+import { MeshGeometry } from 'pixi.js';
+import { ComplexRopeSegment } from './ComplexRope';
+/**
+ * RopeGeometry allows you to draw a geometry across several several segments of points and then manipulate these points.
+ */
+export declare class ComplexRopeGeometry extends MeshGeometry {
+    /** An array of segments with points and diameter that determine the rope. */
+    private segments;
+    /** Rope texture scale. */
+    private readonly textureScale;
+    /**
+     * @param segments - An array of segments with points and diameter to construct this rope.
+     * @param textureScale - scaling factor for repeated texture. To create a tiling rope
+     *     set baseTexture.wrapMode to PIXI.WRAP_MODES.REPEAT and use a power of two texture.
+     */
+    constructor(segments: ComplexRopeSegment[], textureScale?: number);
+    /**
+     * The max width (i.e., thickness) of the rope.
+     * @readonly
+     */
+    get width(): number;
+    /** Refreshes Rope indices and uvs */
+    private build;
+    /** refreshes vertices of Rope mesh */
+    updateVertices(): void;
+    update(): void;
+}

package/dist/layers/CustomDisplayObjects/FixedWidthSimpleRope.d.ts

@@ -0,0 +1,20 @@
+import { IPoint, Mesh, Renderer, Texture } from 'pixi.js';
+/**
+ * The rope allows you to draw a texture across several points and then manipulate these points
+ * Width of rope is given in constructor
+ */
+export declare class FixedWidthSimpleRope extends Mesh {
+    /**
+     * re-calculate vertices by rope points each frame
+     * @member {boolean}
+     */
+    autoUpdate: boolean;
+    /**
+     * Note: The wrap mode of the texture is set to REPEAT if `textureScale` is positive.
+     * @param texture - The texture to use on the rope. (attempt to set UV wrapping, will fail on non-power of two textures)
+     * @param points - An array of {@link PIXI.Point} objects to construct this rope.
+     * @param width - Width of rope
+     */
+    constructor(texture: Texture, points: IPoint[], width: number);
+    _render(renderer: Renderer): void;
+}

package/dist/layers/CustomDisplayObjects/FixedWidthSimpleRopeGeometry.d.ts

@@ -0,0 +1,26 @@
+import { IPoint, MeshGeometry } from 'pixi.js';
+export declare class FixedWidthSimpleRopeGeometry extends MeshGeometry {
+    points: IPoint[];
+    _width: number;
+    /**
+     * @param {number} [width=200] - The width (i.e., thickness) of the rope.
+     * @param {PIXI.Point[]} [points] - An array of PIXI.Point objects to construct this rope.
+     */
+    constructor(points: IPoint[], width?: number);
+    /**
+     * The width (i.e., thickness) of the rope.
+     * @member {number}
+     * @readOnly
+     */
+    get width(): number;
+    /**
+     * Refreshes Rope indices and uvs
+     * @private
+     */
+    private build;
+    /**
+     * refreshes vertices of Rope mesh
+     */
+    updateVertices(): void;
+    update(): void;
+}

package/dist/layers/CustomDisplayObjects/UniformTextureStretchRope.d.ts

@@ -0,0 +1,17 @@
+import { IPoint, Mesh, Renderer, Texture } from 'pixi.js';
+/**
+ * The UniformTextureStretchRope allows you to draw a texture across several points and then manipulate these points
+ */
+export declare class UniformTextureStretchRope extends Mesh {
+    /**
+     * re-calculate vertices by rope points each frame
+     * @member {boolean}
+     */
+    autoUpdate: boolean;
+    /**
+     * @param texture - The texture to use on the rope.
+     * @param points - An array of {@link PIXI.Point} objects to construct this rope.
+     */
+    constructor(texture: Texture, points: IPoint[]);
+    _render(renderer: Renderer): void;
+}

package/dist/layers/CustomDisplayObjects/UniformTextureStretchRopeGeometry.d.ts

@@ -0,0 +1,24 @@
+import { MeshGeometry } from 'pixi.js';
+import type { IPoint } from 'pixi.js';
+/**
+ * UniformTextureStretchRopeGeometry allows you to draw a geometry across several points and then manipulate these points.
+ */
+export declare class UniformTextureStretchRopeGeometry extends MeshGeometry {
+    /** An array of points that determine the rope. */
+    points: IPoint[];
+    /**
+     * The width (i.e., thickness) of the rope.
+     * @readonly
+     */
+    _width: number;
+    /**
+     * @param width - The width (i.e., thickness) of the rope.
+     * @param points - An array of PIXI.Point objects to construct this rope.
+     */
+    constructor(points: IPoint[], width?: number);
+    /** Refreshes Rope indices and uvs */
+    private build;
+    /** refreshes vertices of Rope mesh */
+    updateVertices(): void;
+    update(): void;
+}

package/dist/layers/GeomodelCanvasLayer.d.ts

@@ -0,0 +1,28 @@
+import { SurfaceData, SurfaceLine } from '../datautils';
+import { OnUpdateEvent, OnRescaleEvent } from '../interfaces';
+import { LayerOptions } from './base';
+import { CanvasLayer } from './base/CanvasLayer';
+declare type SurfacePaths = {
+    color: string;
+    path: Path2D;
+};
+export declare class GeomodelCanvasLayer<T extends SurfaceData> extends CanvasLayer<T> {
+    rescaleEvent: OnRescaleEvent;
+    surfaceAreasPaths: SurfacePaths[];
+    surfaceLinesPaths: SurfacePaths[];
+    maxDepth: number;
+    constructor(id?: string, options?: LayerOptions<T>);
+    onUpdate(event: OnUpdateEvent<T>): 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: number[][]) => number[][];
+    generatePolygonPath: (polygon: number[]) => Path2D;
+    generateLinePaths: (s: SurfaceLine) => Path2D[];
+}
+export {};

package/dist/layers/GeomodelLabelsLayer.d.ts

@@ -0,0 +1,49 @@
+import Vector2 from '@equinor/videx-vector2';
+import { CanvasLayer } from './base/CanvasLayer';
+import { OnUpdateEvent, OnRescaleEvent, OnMountEvent } from '../interfaces';
+import { SurfaceArea, SurfaceLine, SurfaceData } from '../datautils';
+import { LayerOptions } from './base/Layer';
+export interface GeomodelLayerLabelsOptions<T extends SurfaceData> extends LayerOptions<T> {
+    margins?: number;
+    minFontSize?: number;
+    maxFontSize?: number;
+    textColor?: string;
+    font?: string;
+}
+interface SurfaceAreaWithAvgTopDepth extends SurfaceArea {
+    avgTopDepth: number;
+}
+export declare class GeomodelLabelsLayer<T extends SurfaceData> extends CanvasLayer<T> {
+    defaultMargins: number;
+    defaultMinFontSize: number;
+    defaultMaxFontSize: number;
+    defaultTextColor: string;
+    defaultFont: string;
+    rescaleEvent: OnRescaleEvent;
+    isLabelsOnLeftSide: boolean;
+    maxFontSizeInWorldCoordinates: number;
+    isXFlipped: boolean;
+    areasWithAvgTopDepth: SurfaceAreaWithAvgTopDepth[];
+    constructor(id?: string, options?: GeomodelLayerLabelsOptions<T>);
+    get options(): GeomodelLayerLabelsOptions<T>;
+    setData(data: T): void;
+    generateSurfacesWithAvgDepth(): void;
+    onMount(event: OnMountEvent): void;
+    onUpdate(event: OnUpdateEvent<T>): void;
+    onRescale(event: OnRescaleEvent): void;
+    render(): void;
+    drawAreaLabels(): void;
+    drawLineLabels(): void;
+    drawAreaLabel: (surfaceArea: SurfaceArea, nextSurfaceArea: SurfaceArea, surfaces: SurfaceArea[], 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?: SurfaceArea[] | null, currentSurfaceIndex?: number): Vector2;
+    getAlternativeYValueIfAvailable(x: number, topLimit: number, bottomLimit: number, alternativeSurfaceData: number[][], surfaces: SurfaceArea[] | null, 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?: SurfaceArea[] | null, currentSurfaceIndex?: number): number;
+    updateXFlipped(): void;
+    getMarginsInWorldCoordinates(): number;
+    getSurfacesAreaEdges(): number[];
+    checkDrawLabelsOnLeftSide(): boolean;
+}
+export {};

package/dist/layers/GeomodelLayerV2.d.ts

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

package/dist/layers/GridLayer.d.ts

@@ -0,0 +1,29 @@
+import { CanvasLayer } from './base/CanvasLayer';
+import { OnUpdateEvent, OnRescaleEvent } from '../interfaces';
+import { ScaleLinear } from 'd3-scale';
+import { LayerOptions } from './base/Layer';
+export interface GridLayerOptions<T> extends LayerOptions<T> {
+    majorWidth?: number;
+    majorColor?: string;
+    minorWidth?: number;
+    minorColor?: string;
+}
+export interface OnGridLayerUpdateEvent<T> extends OnUpdateEvent<T> {
+    xScale?: ScaleLinear<number, number, never>;
+    yScale?: ScaleLinear<number, number, never>;
+}
+export declare class GridLayer<T> extends CanvasLayer<T> {
+    private _offsetX;
+    private _offsetY;
+    constructor(id?: string, options?: GridLayerOptions<T>);
+    onUpdate(event: OnGridLayerUpdateEvent<T>): void;
+    onRescale(event: OnRescaleEvent): void;
+    render(event: OnRescaleEvent | OnGridLayerUpdateEvent<T>): void;
+    private renderTicksX;
+    private renderTicksY;
+    private mapMinorTicks;
+    get offsetX(): number;
+    set offsetX(offset: number);
+    get offsetY(): number;
+    set offsetY(offset: number);
+}

package/dist/layers/ImageCanvasLayer.d.ts

@@ -0,0 +1,20 @@
+import { CanvasLayer } from './base/CanvasLayer';
+import { OnUpdateEvent, OnMountEvent, OnRescaleEvent } from '../interfaces';
+import { ScaleLinear } from 'd3-scale';
+export interface OnImageLayerUpdateEvent<T> extends OnUpdateEvent<T> {
+    url: string;
+    xScale: ScaleLinear<number, number, never>;
+    yScale: ScaleLinear<number, number, never>;
+    xRatio?: number;
+    yRatio?: number;
+    x?: number;
+    y?: number;
+}
+export declare type OnImageLayerRescaleEvent<T> = OnImageLayerUpdateEvent<T> & OnRescaleEvent;
+export declare class ImageLayer<T> extends CanvasLayer<T> {
+    img: HTMLImageElement;
+    onMount(event: OnMountEvent): void;
+    onUpdate(event: OnImageLayerUpdateEvent<T>): void;
+    onRescale(event: OnImageLayerRescaleEvent<T>): void;
+    render(event: OnImageLayerUpdateEvent<T>): void;
+}

package/dist/layers/SchematicLayer.d.ts

@@ -0,0 +1,94 @@
+import { ScaleLinear } from 'd3-scale';
+import { Graphics, Point, Texture } from 'pixi.js';
+import { LayerOptions, PixiLayer, PixiRenderApplication } from '.';
+import { CasingOptions, CementOptions, CementPlugOptions, CementSqueezeOptions, HoleOptions, SchematicData, ScreenOptions, TubingOptions, InternalLayerOptions, PerforationOptions } from './schematicInterfaces';
+import { OnUpdateEvent, OnRescaleEvent, OnUnmountEvent } from '../interfaces';
+interface ScalingFactors {
+    height: number;
+    zFactor: number;
+    yScale: ScaleLinear<number, number, never>;
+}
+export interface SchematicLayerOptions<T extends SchematicData> extends LayerOptions<T> {
+    exaggerationFactor?: number;
+    internalLayerOptions?: InternalLayerOptions;
+    holeOptions?: HoleOptions;
+    casingOptions?: CasingOptions;
+    cementOptions?: CementOptions;
+    cementSqueezeOptions?: CementSqueezeOptions;
+    screenOptions?: ScreenOptions;
+    tubingOptions?: TubingOptions;
+    cementPlugOptions?: CementPlugOptions;
+    perforationOptions?: PerforationOptions;
+}
+export declare class SchematicLayer<T extends SchematicData> extends PixiLayer<T> {
+    private internalLayerVisibility;
+    private cementTextureCache;
+    private cementSqueezeTextureCache;
+    private cementPlugTextureCache;
+    private holeTextureCache;
+    private screenTextureCache;
+    private tubingTextureCache;
+    private textureSymbolCacheArray;
+    private maxHoleDiameter;
+    protected scalingFactors: ScalingFactors;
+    constructor(ctx: PixiRenderApplication, id?: string, options?: SchematicLayerOptions<T>);
+    onUnmount(event?: OnUnmountEvent): void;
+    onUpdate(event: OnUpdateEvent<T>): void;
+    onRescale(event: OnRescaleEvent): void;
+    setVisibility(isVisible: boolean, layerId: string): void;
+    getInternalLayerIds(): string[];
+    /**
+     * Calculate yRatio without zFactor
+     * TODO consider to move this into ZoomPanHandler
+     */
+    protected yRatio(): number;
+    protected getZFactorScaledPathForPoints: (start: number, end: number) => [number, number][];
+    protected drawBigPolygon: (coords: Point[], color?: number) => void;
+    protected drawBigTexturedPolygon: (coords: Point[], t: Texture) => Graphics;
+    protected drawRope(path: Point[], texture: Texture, tint?: number): void;
+    /**
+     *
+     * @param leftPath Points for line on left side
+     * @param rightPath Points for line on right side
+     * @param lineColor Color of line
+     * @param lineWidth Width of line
+     * @param close If line should close in top and bottom to form a loop
+     * @param lineAlignment alignment of the line to draw, (0 = inner, 0.5 = middle, 1 = outer).
+     */
+    protected drawOutline(leftPath: Point[], rightPath: Point[], lineColor: number, lineWidth?: number, close?: boolean, lineAlignment?: number): void;
+    preRender(): void;
+    private updateSymbolCache;
+    private drawCementPlug;
+    private getCementPlugTexture;
+    private createPerforationTexture;
+    private prepareSymbolRenderObject;
+    private drawSymbolComponent;
+    private drawSVGRope;
+    private getSymbolTexture;
+    private drawHoleSize;
+    private drawHoleRope;
+    private getHoleTexture;
+    /**
+     * The rendering order of these components needs to be aligned
+     * @param casingRenderObjects
+     * @param cementRenderObject
+     * @param cementSqueezes
+     * @returns ordered rendering list
+     */
+    private sortCementAndCasingRenderObjects;
+    private drawComplexRope;
+    private drawCasing;
+    private createCasingTexture;
+    private drawShoe;
+    private generateShoe;
+    private createCementSqueezeShape;
+    private getCementTexture;
+    private createPerforationShape;
+    private getCementSqueezeTexture;
+    private drawScreen;
+    private drawTubing;
+    private getTubingTexture;
+    private getScreenTexture;
+    private drawCompletionRope;
+}
+export {};

package/dist/layers/SeismicCanvasLayer.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="offscreencanvas" />
+import { CanvasLayer } from './base/CanvasLayer';
+import { OnUpdateEvent, OnMountEvent, OnRescaleEvent } from '../interfaces';
+export declare type SeismicCanvasDataOptions = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export declare type SeismicCanvasData = {
+    image: CanvasImageSource | OffscreenCanvas;
+    options: SeismicCanvasDataOptions;
+};
+export declare class SeismicCanvasLayer extends CanvasLayer<SeismicCanvasData> {
+    onMount(event: OnMountEvent): void;
+    onUpdate(event: OnUpdateEvent<SeismicCanvasData>): void;
+    onRescale(event: OnRescaleEvent): void;
+    render(): void;
+}

package/dist/layers/WellborePathLayer.d.ts

@@ -0,0 +1,17 @@
+import { SVGLayer } from './base/SVGLayer';
+import { OnUpdateEvent, OnRescaleEvent } from '../interfaces';
+import { LayerOptions } from '..';
+export interface WellborepathLayerOptions<T extends [number, number][]> extends LayerOptions<T> {
+    stroke: string;
+    strokeWidth: string;
+    curveType?: string;
+    tension?: number;
+}
+export declare class WellborepathLayer<T extends [number, number][]> extends SVGLayer<T> {
+    rescaleEvent: OnRescaleEvent;
+    constructor(id?: string, options?: WellborepathLayerOptions<T>);
+    onUpdate(event: OnUpdateEvent<T>): void;
+    onRescale(event: OnRescaleEvent): void;
+    render(): void;
+    private renderWellborePath;
+}

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

@@ -0,0 +1,19 @@
+import { Layer } from './Layer';
+import { OnMountEvent, OnUpdateEvent, OnResizeEvent, OnRescaleEvent } from '../../interfaces';
+export declare abstract class CanvasLayer<T> extends Layer<T> {
+    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<T>): void;
+    resetTransform(): void;
+    setTransform(event: OnRescaleEvent): void;
+    clearCanvas(): void;
+}

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

@@ -0,0 +1,13 @@
+import { Selection } from 'd3-selection';
+import { Layer } from './Layer';
+import { OnMountEvent, OnResizeEvent } from '../../interfaces';
+export declare abstract class HTMLLayer<T> extends Layer<T> {
+    elm: Selection<HTMLElement, unknown, 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

@@ -0,0 +1,69 @@
+import { OnMountEvent, OnUnmountEvent, OnUpdateEvent, OnRescaleEvent, OnResizeEvent } from '../../interfaces';
+import { IntersectionReferenceSystem } from '../../control';
+export interface LayerOptions<T> {
+    order?: number;
+    layerOpacity?: number;
+    referenceSystem?: IntersectionReferenceSystem;
+    data?: T;
+    interactive?: boolean;
+    onMount?(event: OnMountEvent, layer: Layer<T>): void;
+    onUnmount?(event: OnUnmountEvent, layer: Layer<T>): void;
+    onUpdate?(event: OnUpdateEvent<T>, layer: Layer<T>): void;
+    onRescale?(event: OnRescaleEvent, layer: Layer<T>): void;
+    onResize?(event: OnResizeEvent, layer: Layer<T>): void;
+}
+export declare abstract class Layer<T> {
+    private _id;
+    private _order;
+    protected _options: LayerOptions<T>;
+    private loading;
+    private _element?;
+    private _opacity;
+    private _referenceSystem?;
+    private _data?;
+    private _visible;
+    private _interactive;
+    constructor(id?: string, options?: LayerOptions<T>);
+    get id(): string;
+    get element(): HTMLElement;
+    get options(): LayerOptions<T>;
+    set options(options: LayerOptions<T>);
+    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(): T;
+    set data(data: T);
+    get isVisible(): boolean;
+    getData(): T;
+    setData(data: T): 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, _layerId?: string): void;
+    onMount(event: OnMountEvent): void;
+    onUnmount(event?: OnUnmountEvent): void;
+    onResize(event: OnResizeEvent): void;
+    onUpdate(event: OnUpdateEvent<T>): void;
+    onRescale(event: OnRescaleEvent): void;
+    optionsRescale(event: OnRescaleEvent): void;
+    abstract onOpacityChanged(opacity: number): void;
+    abstract onOrderChanged(order: number): void;
+    abstract onInteractivityChanged(interactive: boolean): void;
+    /**
+     *
+     * Some layers might be built up of several internal layers that should individually be visibility-togglable.
+     * Reasons for having multiple internal layers might be tightly related data between layers or need for sharing render context
+     *
+     * @returns list of internal layer ids
+     */
+    getInternalLayerIds(): string[];
+}