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

package/dist/layers/WellborePathLayer.d.ts

@@ -1,9 +1,16 @@
 import { SVGLayer } from './base/SVGLayer';
-import { WellborepathLayerOptions, OnUpdateEvent, OnRescaleEvent } from '../interfaces';
-export declare class WellborepathLayer extends 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);
-    onUpdate(event: OnUpdateEvent): void;
+    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

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

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

@@ -1,8 +1,8 @@
 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>;
+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;

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

@@ -1,9 +1,21 @@
-import { LayerOptions, OnMountEvent, OnUnmountEvent, OnUpdateEvent, OnRescaleEvent, OnResizeEvent } from '../../interfaces';
+import { OnMountEvent, OnUnmountEvent, OnUpdateEvent, OnRescaleEvent, OnResizeEvent } from '../../interfaces';
 import { IntersectionReferenceSystem } from '../../control';
-export declare abstract class Layer {
+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;
+    protected _options: LayerOptions<T>;
     private loading;
     private _element?;
     private _opacity;
@@ -11,11 +23,11 @@ export declare abstract class Layer {
     private _data?;
     private _visible;
     private _interactive;
-    constructor(id?: string, options?: LayerOptions);
+    constructor(id?: string, options?: LayerOptions<T>);
     get id(): string;
     get element(): HTMLElement;
-    get options(): LayerOptions;
-    set options(options: LayerOptions);
+    get options(): LayerOptions<T>;
+    set options(options: LayerOptions<T>);
     set isLoading(loading: boolean);
     get isLoading(): boolean;
     set opacity(opacity: number);
@@ -26,24 +38,32 @@ export declare abstract class Layer {
     get interactive(): boolean;
     get referenceSystem(): IntersectionReferenceSystem;
     set referenceSystem(referenceSystem: IntersectionReferenceSystem);
-    get data(): any;
-    set data(data: any);
+    get data(): T;
+    set data(data: T);
     get isVisible(): boolean;
-    getData(): any;
-    setData(data: any): void;
+    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): void;
+    setVisibility(visible: boolean, _layerId?: string): void;
     onMount(event: OnMountEvent): void;
     onUnmount(event?: OnUnmountEvent): void;
     onResize(event: OnResizeEvent): void;
-    onUpdate(event: OnUpdateEvent): void;
+    onUpdate(event: OnUpdateEvent<T>): void;
     onRescale(event: OnRescaleEvent): void;
     optionsRescale(event: OnRescaleEvent): void;
-    onOpacityChanged(opacity: number): void;
-    onOrderChanged(order: number): void;
-    onInteractivityChanged(interactive: boolean): 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[];
 }

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

@@ -1,27 +1,32 @@
-import { AbstractRenderer, Container, IRendererOptionsAuto, RENDERER_TYPE } from 'pixi.js';
-import { Layer } from './Layer';
-import { OnMountEvent, OnRescaleEvent, OnResizeEvent, OnUnmountEvent, PixiLayerOptions } from '../../interfaces';
+import { AbstractRenderer, Application, Container, DisplayObject, IRendererOptionsAuto, RENDERER_TYPE } from 'pixi.js';
+import { Layer, LayerOptions } from './Layer';
+import { OnMountEvent, OnRescaleEvent, OnResizeEvent, OnUnmountEvent } from '../../interfaces';
 export declare class PixiRenderApplication {
     stage: Container;
     renderer: AbstractRenderer;
-    constructor(pixiRenderOptions: IRendererOptionsAuto);
+    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;
+export declare abstract class PixiLayer<T> extends Layer<T> {
+    private pixiViewContainer;
+    private ctx;
+    private container;
+    constructor(ctx: Application | PixiRenderApplication, id?: string, options?: LayerOptions<T>);
     render(): void;
+    addChild(child: DisplayObject): void;
+    clearLayer(): void;
+    onMount(event: OnMountEvent): void;
     onUnmount(event?: OnUnmountEvent): void;
     onResize(event: OnResizeEvent): void;
     onRescale(event: OnRescaleEvent): void;
+    protected setContainerPosition(x?: number, y?: number): void;
+    protected setContainerScale(x?: number, y?: number): void;
     updateStyle(visible?: boolean): void;
-    setVisibility(visible: boolean): void;
-    onOpacityChanged(opacity: number): void;
-    onOrderChanged(order: number): void;
-    onInteractivityChanged(interactive: boolean): void;
+    setVisibility(visible: boolean, layerId?: string): void;
+    onOpacityChanged(_opacity: number): void;
+    onOrderChanged(_order: number): void;
+    onInteractivityChanged(_interactive: boolean): void;
     renderType(): RENDERER_TYPE;
 }

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

@@ -1,8 +1,8 @@
 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>;
+export declare abstract class SVGLayer<T> extends Layer<T> {
+    elm: Selection<SVGElement, unknown, null, undefined>;
     onMount(event: OnMountEvent): void;
     onUnmount(): void;
     onResize(event: OnResizeEvent): void;

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

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

package/dist/layers/index.d.ts

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

package/dist/layers/schematicInterfaces.d.ts

@@ -0,0 +1,169 @@
+export declare function assertNever(x: never): never;
+export interface HoleSize {
+    kind: 'hole';
+    id: string;
+    diameter: number;
+    start: number;
+    end: number;
+    innerDiameter?: number;
+}
+export interface Casing {
+    kind: 'casing';
+    id: string;
+    casingId: string;
+    diameter: number;
+    start: number;
+    end: number;
+    hasShoe: boolean;
+    innerDiameter: number;
+}
+interface SymbolComponent {
+    id: string;
+    diameter: number;
+    start: number;
+    end: number;
+    symbolKey: string;
+}
+export interface PAndASymbol extends SymbolComponent {
+    kind: 'pAndASymbol';
+}
+export declare const isPAndASymbol: (item: PAndA) => item is PAndASymbol;
+export interface CementSqueeze {
+    kind: 'cementSqueeze';
+    id: string;
+    top: number;
+    bottom: number;
+    casingIds?: string[];
+}
+export declare const isCementSqueeze: (item: PAndA) => item is CementSqueeze;
+export interface CementPlug {
+    kind: 'cementPlug';
+    id: string;
+    top: number;
+    bottom: number;
+    holeId?: string;
+    casingId?: string;
+    secondCasingId?: string;
+}
+export declare const isCementPlug: (item: PAndA) => item is CementSqueeze;
+export declare type PAndA = PAndASymbol | CementSqueeze | CementPlug;
+interface BaseCompletion {
+    id: string;
+    diameter: number;
+    start: number;
+    end: number;
+}
+export interface Screen extends BaseCompletion {
+    kind: 'screen';
+}
+export interface Tubing extends BaseCompletion {
+    kind: 'tubing';
+}
+export interface CompletionSymbol extends BaseCompletion {
+    kind: 'completionSymbol';
+    symbolKey: string;
+}
+export declare type Completion = Tubing | Screen | CompletionSymbol;
+export declare const foldCompletion: <T>(fScreen: (obj: Screen) => T, fTubing: (obj: Tubing) => T, fSymbol: (obj: CompletionSymbol) => T) => (completion: Completion) => T;
+export interface Cement {
+    kind: 'cement';
+    id: string;
+    casingIds?: string[];
+    toc: number;
+}
+export interface SchematicData {
+    holeSizes: HoleSize[];
+    casings: Casing[];
+    cements: Cement[];
+    completion: Completion[];
+    pAndA: PAndA[];
+    symbols: {
+        [key: string]: string;
+    };
+}
+export interface InternalLayerOptions {
+    holeLayerId: string;
+    casingLayerId: string;
+    completionLayerId: string;
+    cementLayerId: string;
+    pAndALayerId: string;
+}
+export declare const defaultInternalLayerOptions: (layerId: string) => {
+    holeLayerId: string;
+    casingLayerId: string;
+    completionLayerId: string;
+    pAndALayerId: string;
+    cementLayerId: string;
+};
+export interface HoleOptions {
+    firstColor: string;
+    secondColor: string;
+    lineColor: string;
+}
+export declare const defaultHoleOptions: HoleOptions;
+export interface CasingShoeSize {
+    width: number;
+    length: number;
+}
+export interface CasingOptions {
+    solidColor: string;
+    lineColor: string;
+    shoeSize: CasingShoeSize;
+}
+export declare const defaultCasingOptions: {
+    solidColor: string;
+    lineColor: string;
+    shoeSize: {
+        width: number;
+        length: number;
+    };
+};
+export interface CementOptions {
+    firstColor: string;
+    secondColor: string;
+    scalingFactor: number;
+}
+export declare const defaultCementOptions: {
+    firstColor: string;
+    secondColor: string;
+    scalingFactor: number;
+};
+export interface CementSqueezeOptions {
+    firstColor: string;
+    secondColor: string;
+    scalingFactor: number;
+}
+export declare const defaultCementSqueezeOptions: {
+    firstColor: string;
+    secondColor: string;
+    scalingFactor: number;
+};
+export interface ScreenOptions {
+    scalingFactor: number;
+    lineColor: string;
+}
+export declare const defaultScreenOptions: {
+    scalingFactor: number;
+    lineColor: string;
+};
+export interface TubingOptions {
+    innerColor: string;
+    outerColor: string;
+    scalingFactor: number;
+}
+export declare const defaultTubingOptions: {
+    scalingFactor: number;
+    innerColor: string;
+    outerColor: string;
+};
+export interface CementPlugOptions {
+    firstColor: string;
+    secondColor: string;
+    scalingFactor: number;
+}
+export declare const defaultCementPlugOptions: {
+    firstColor: string;
+    secondColor: string;
+    scalingFactor: number;
+};
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@equinor/esv-intersection",
-  "version": "2.2.0",
+  "version": "3.0.0-beta.1",
   "description": "Intersection component package with testing and automatic documentation.",
   "main": "dist/index.js",
   "module": "dist/index.esm.js",
@@ -14,7 +14,9 @@
     "build": "rollup -c",
     "prepub": "npm run build",
     "pub": "npm publish --access=public",
-    "lint": "eslint --ext .js,.jsx,.ts,.tsx src",
+    "prepub-beta": "npm run build",
+    "pub-beta": "npm publish --tag=beta --access=public",
+    "lint": "eslint --ext .js,.jsx,.ts,.tsx src test",
     "test": "tsc --project tsconfig.test.json && jest",
     "test:watch": "jest --watchAll",
     "predocs": "rimraf docs_out",
@@ -61,8 +63,8 @@
     "jest-canvas-mock": "^2.4.0",
     "jest-environment-jsdom": "^29.0.3",
     "mock-raf": "^1.0.1",
-    "pixi.js": "^6.5.3",
-    "prettier": "^2.6.1",
+    "pixi.js": "^6.5.8",
+    "prettier": "^2.7.1",
     "rimraf": "^3.0.2",
     "rollup": "^2.79.0",
     "rollup-plugin-commonjs": "^10.1.0",
@@ -90,7 +92,7 @@
     ]
   },
   "peerDependencies": {
-    "pixi.js": "^6.5.3"
+    "pixi.js": "^6.5.8"
   },
   "dependencies": {
     "@equinor/videx-math": "^1.1.0",

package/dist/datautils/wellboreItemShapeGenerator.d.ts

@@ -1,22 +0,0 @@
-import { Point } from 'pixi.js';
-import { Cement, Casing, HoleSize } from '..';
-export declare const getEndLines: (rightPath: Point[], leftPath: Point[]) => {
-    top: Point[];
-    bottom: Point[];
-};
-export declare const makeTubularPolygon: (rightPath: Point[], leftPath: Point[]) => Point[];
-export declare const overlaps: (top1: number, bottom1: number, top2: number, bottom2: number) => boolean;
-export declare const uniq: <T>(arr: T[]) => T[];
-export declare const findIntersectingItems: (cement: Cement, bottomOfCement: number, parentCasings: Casing[], casings: Casing[], holes: HoleSize[]) => {
-    holes: HoleSize[];
-    outerCasings: Casing[];
-};
-export declare const cementDiameterChangeDepths: (cement: Cement, bottomOfCement: number, diameterIntervals: {
-    start: number;
-    end: number;
-}[]) => number[];
-export declare const calculateCementDiameter: (innerCasing: Casing[], nonAttachedCasings: Casing[], holes: HoleSize[]) => (depth: number) => {
-    md: number;
-    innerDiameter: number;
-    outerDiameter: number;
-};

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/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/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/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;
-}