@equinor/esv-intersection 3.0.3 → 3.0.4

package/dist/layers/ReferenceLineLayer.d.ts

@@ -1,29 +0,0 @@
-import { CanvasLayer, LayerOptions } from './base';
-import { OnUpdateEvent, OnRescaleEvent, OnMountEvent } from '../interfaces';
-import { ScaleLinear } from 'd3-scale';
-export type ReferenceLineType = 'wavy' | 'dashed' | 'solid';
-export type ReferenceLine = {
-    text?: string;
-    lineType: ReferenceLineType;
-    color: string;
-    depth: number;
-    lineWidth?: number;
-    textColor?: string;
-    fontSize?: string;
-};
-export interface ReferenceLineLayerOptions extends LayerOptions<ReferenceLine[]> {
-}
-export declare class ReferenceLineLayer extends CanvasLayer<ReferenceLine[]> {
-    yScale: ScaleLinear<number, number, never> | null;
-    xScale: ScaleLinear<number, number, never> | null;
-    onMount(event: OnMountEvent): void;
-    onUpdate(event: OnUpdateEvent<ReferenceLine[]>): void;
-    onRescale(event: OnRescaleEvent): void;
-    private drawDashed;
-    private drawSolid;
-    private drawWavy;
-    private drawText;
-    private setCtxLineStyle;
-    private setCtxLineWidth;
-    private render;
-}

package/dist/layers/SchematicLayer.d.ts

@@ -1,113 +0,0 @@
-import { ScaleLinear } from 'd3-scale';
-import { IPoint, Point, Texture } from 'pixi.js';
-import { LayerOptions, PixiLayer, PixiRenderApplication } from '.';
-import { CasingOptions, CementOptions, CementPlugOptions, CementSqueezeOptions, HoleOptions, SchematicData, ScreenOptions, TubingOptions, InternalLayerOptions, PerforationOptions, OutlineClosure } 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;
-    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) => Point[];
-    protected drawBigPolygon: (coords: IPoint[], color?: number) => void;
-    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 outlineClosure If line should be drawn at top and/or bottom of the paths
-     * @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, outlineClosure?: OutlineClosure, lineAlignment?: number): void;
-    /**
-     * Uses a dashed outline on one side to represent casing window
-     * The casing window should be visualized at the upper side of the wellbore path
-     * @param leftPath Points for line on left side
-     * @param pointPath Points for line on right side
-     * @param lineColor Color of line
-     * @param lineWidth Width of line
-     * @param lineAlignment alignment of the line to draw, (0 = inner, 0.5 = middle, 1 = outer).
-     */
-    protected drawCasingWindowOutline(leftPath: Point[], rightPath: Point[], { lineColor, windowOptions }: CasingOptions, lineWidth?: number): void;
-    private perforationRopeAndTextureReferences;
-    preRender(): void;
-    private updateSymbolCache;
-    private drawCementPlug;
-    private createCasingRenderObject;
-    private getCementPlugTexture;
-    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;
-    /**
-     *
-     * @param intervals
-     * @param texture
-     * optionally fetch the exaggerationFactor from a different options prop
-     * options.perforationOptions for example
-     * @param getExaggerationFactor
-     * @returns
-     */
-    private drawComplexRope;
-    private static getOutlineClosureType;
-    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

@@ -1,18 +0,0 @@
-import { CanvasLayer } from './base/CanvasLayer';
-import { OnUpdateEvent, OnMountEvent, OnRescaleEvent } from '../interfaces';
-export type SeismicCanvasDataOptions = {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-};
-export 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

@@ -1,17 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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[];
-}

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

@@ -1,32 +0,0 @@
-import { IRenderer, 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: IRenderer<HTMLCanvasElement>;
-    constructor(pixiRenderOptions?: IRendererOptionsAuto);
-    destroy(): void;
-    get view(): HTMLCanvasElement;
-    render(): void;
-}
-export declare abstract class PixiLayer<T> extends Layer<T> {
-    private pixiViewContainer;
-    private ctx;
-    private container;
-    constructor(ctx: Application<HTMLCanvasElement> | 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, 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,13 +0,0 @@
-import { Selection } from 'd3-selection';
-import { Layer } from './Layer';
-import { OnMountEvent, OnResizeEvent } from '../../interfaces';
-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;
-    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 './CanvasLayer';
-export * from './HTMLLayer';
-export * from './Layer';
-export * from './PixiLayer';
-export * from './SVGLayer';

package/dist/layers/index.d.ts

@@ -1,16 +0,0 @@
-export * from './base/CanvasLayer';
-export * from './base/Layer';
-export * from './base/HTMLLayer';
-export * from './base/SVGLayer';
-export * from './base/PixiLayer';
-export * from './schematicInterfaces';
-export * from './CalloutCanvasLayer';
-export * from './GeomodelCanvasLayer';
-export * from './GeomodelLabelsLayer';
-export * from './GeomodelLayerV2';
-export * from './GridLayer';
-export * from './ImageCanvasLayer';
-export * from './SchematicLayer';
-export * from './SeismicCanvasLayer';
-export * from './WellborePathLayer';
-export * from './ReferenceLineLayer';

package/dist/layers/schematicInterfaces.d.ts

@@ -1,209 +0,0 @@
-export declare function assertNever(x: never): never;
-/**
- * The closure type of the outline
- */
-export type OutlineClosure = 'None' | 'TopAndBottom' | 'Top' | 'Bottom';
-export interface HoleSize {
-    kind: 'hole';
-    id: string;
-    diameter: number;
-    start: number;
-    end: number;
-}
-export interface CasingWindow {
-    id: string;
-    start: number;
-    end: number;
-}
-export interface Casing {
-    kind: 'casing';
-    id: string;
-    diameter: number;
-    start: number;
-    end: number;
-    hasShoe: boolean;
-    innerDiameter: number;
-    windows?: CasingWindow[];
-}
-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;
-    start: number;
-    end: number;
-    /**
-     * Referenced Casing and Completion ids
-     */
-    referenceIds: string[];
-}
-export declare const isCementSqueeze: (item: PAndA) => item is CementSqueeze;
-export interface CementPlug {
-    kind: 'cementPlug';
-    id: string;
-    start: number;
-    end: number;
-    /**
-     * Referenced Casing, Completion ids
-     */
-    referenceIds: string[];
-}
-export declare const isCementPlug: (item: PAndA) => item is CementSqueeze;
-export 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 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;
-    /**
-     *  Referenced Casing and Completion ids
-     */
-    referenceIds: string[];
-    toc: number;
-}
-/**
- * 'Open hole' and 'Open hole screen' are not included as they are not visualized and also not included in the ruleset
- */
-export type PerforationSubKind = 'Perforation' | 'Open hole gravel pack' | 'Open hole frac pack' | 'Cased hole frac pack' | 'Cased hole gravel pack' | 'Cased hole fracturation';
-export interface Perforation {
-    kind: 'perforation';
-    subKind: PerforationSubKind;
-    id: string;
-    start: number;
-    end: number;
-    /**
-     * is the perforation open or sealed?
-     */
-    isOpen: boolean;
-}
-export declare const foldPerforationSubKind: <T>(options: {
-    Perforation: (kind: 'Perforation') => T;
-    OpenHoleGravelPack: (kind: 'Open hole gravel pack') => T;
-    OpenHoleFracPack: (kind: 'Open hole frac pack') => T;
-    CasedHoleGravelPack: (kind: 'Cased hole gravel pack') => T;
-    CasedHoleFracPack: (kind: 'Cased hole frac pack') => T;
-    CasedHoleFracturation: (kind: 'Cased hole fracturation') => T;
-}, subKind: PerforationSubKind) => T;
-export declare const shouldPerforationStartAtHoleDiameter: (perf: Perforation) => boolean;
-export declare const shouldPerforationStartAtCasingDiameter: (perf: Perforation) => boolean;
-export declare const hasPacking: (perf: Perforation) => boolean;
-export declare function hasFracLines(perf: Perforation): boolean;
-export declare function hasSpikes(perf: Perforation): boolean;
-export declare function isSubkindCasedHoleGravelPack(perf: Perforation): boolean;
-export declare function isSubKindPerforation(perf: Perforation): boolean;
-export declare function isSubKindCasedHoleFracPack(perf: Perforation): boolean;
-export declare function isOpenHoleFracPack(perf: Perforation): boolean;
-export declare const isSubKindCasedHoleFracturation: (perf: Perforation) => boolean;
-export declare const intersect: (a: Perforation, b: Perforation) => boolean;
-export interface SchematicData {
-    holeSizes: HoleSize[];
-    casings: Casing[];
-    cements: Cement[];
-    completion: Completion[];
-    pAndA: PAndA[];
-    symbols: {
-        [key: string]: string;
-    };
-    perforations: Perforation[];
-}
-export interface InternalLayerOptions {
-    holeLayerId: string;
-    casingLayerId: string;
-    completionLayerId: string;
-    cementLayerId: string;
-    pAndALayerId: string;
-    perforationLayerId: string;
-}
-export declare const defaultInternalLayerOptions: (layerId: string) => InternalLayerOptions;
-export interface HoleOptions {
-    firstColor: string;
-    secondColor: string;
-    lineColor: string;
-}
-export declare const defaultHoleOptions: HoleOptions;
-export interface CasingShoeSize {
-    width: number;
-    length: number;
-}
-export interface WindowOptions {
-    dashColor: string;
-    dashLength: number;
-    spaceLength: number;
-}
-export interface CasingOptions {
-    solidColor: string;
-    lineColor: string;
-    shoeSize: CasingShoeSize;
-    windowOptions: WindowOptions;
-}
-export declare const defaultCasingOptions: CasingOptions;
-export interface PerforationOptions {
-    stroke: string;
-    yellow: string;
-    grey: string;
-    red: string;
-    outline: string;
-    transparent: string;
-    spikeWidth: number;
-    spikeLength: number;
-    packingOpacity: number;
-    fracLineLength: number;
-    fracLineCurve: number;
-    scalingFactor: number;
-}
-export declare const defaultPerforationOptions: PerforationOptions;
-export interface CementOptions {
-    firstColor: string;
-    secondColor: string;
-    scalingFactor: number;
-}
-export declare const defaultCementOptions: CementOptions;
-export interface CementSqueezeOptions {
-    firstColor: string;
-    secondColor: string;
-    scalingFactor: number;
-}
-export declare const defaultCementSqueezeOptions: CementSqueezeOptions;
-export interface ScreenOptions {
-    scalingFactor: number;
-    lineColor: string;
-}
-export declare const defaultScreenOptions: ScreenOptions;
-export interface TubingOptions {
-    innerColor: string;
-    outerColor: string;
-    scalingFactor: number;
-}
-export declare const defaultTubingOptions: TubingOptions;
-export interface CementPlugOptions {
-    firstColor: string;
-    secondColor: string;
-    scalingFactor: number;
-}
-export declare const defaultCementPlugOptions: CementPlugOptions;
-export {};

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

@@ -1,23 +0,0 @@
-import { Vector } from 'curve-interpolator/dist/src/core/interfaces';
-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;

package/dist/utils/index.d.ts

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

package/dist/utils/root-finder.d.ts

@@ -1,34 +0,0 @@
-type fx = (n: number) => number;
-export declare class RootFinder {
-    /**
-     * Find root using newthons method
-     * @param {Number} func f(x)
-     * @param {Number} precision Accuracy of result
-     * @param {Number} maxIterations Max number of iterations to use
-     * @param {Number} start Starting position
-     * @param {Number} minLimit Min limit of result
-     * @param {Number} maxLimit Max limit of result
-     */
-    static newton(func: fx, precision?: number, maxIterations?: number, start?: number, minLimit?: number, maxLimit?: number): number;
-    /**
-     * Find root using bisect method
-     * @param {Number} func f(x)
-     * @param {Number} precision Accuracy of result
-     * @param {Number} maxIterations Max number of iterations to use
-     * @param {Number} start Starting position
-     * @param {Number} minLimit Min limit of result
-     * @param {Number} maxLimit Max limit of result
-     */
-    static bisect(func: fx, precision?: number, maxIterations?: number, start?: number, minLimit?: number, maxLimit?: number): number;
-    /**
-     * Find root by trying available methods
-     * @param {Number} func f(x)
-     * @param {Number} precision Accuracy of result
-     * @param {Number} maxIterations Max number of iterations to use
-     * @param {Number} start Starting position
-     * @param {Number} minLimit Min limit of result
-     * @param {Number} maxLimit Max limit of result
-     */
-    static findRoot(func: fx, precision?: number, maxIterations?: number, start?: number, minLimit?: number, maxLimit?: number): number;
-}
-export {};

package/dist/utils/text.d.ts

@@ -1,14 +0,0 @@
-import { BoundingBox } from '../interfaces';
-import { ScaleLinear } from 'd3-scale';
-export declare function pixelsPerUnit(x: ScaleLinear<number, number>): number;
-export declare function calcSize(factor: number, min: number, max: number, x: ScaleLinear<number, number>): number;
-export declare function isOverlappingHorizontally(r1: BoundingBox, r2: BoundingBox): boolean;
-export declare function isOverlapping(r1: BoundingBox, r2: BoundingBox, horizontalPadding?: number, verticalPadding?: number): boolean;
-export declare function getOverlap(r1: BoundingBox, r2: BoundingBox): {
-    dx: number;
-    dy: number;
-};
-export declare function getOverlapOffset(r1: BoundingBox, r2: BoundingBox, horizontalPadding?: number, verticalPadding?: number): {
-    dx: number;
-    dy: number;
-};

package/dist/utils/vectorUtils.d.ts

@@ -1,15 +0,0 @@
-import { IPoint, Point } from 'pixi.js';
-import Vector2 from '@equinor/videx-vector2';
-export declare const pointToVector: (p: IPoint) => Vector2;
-export declare const pointToArray: (p: IPoint) => [number, number];
-export declare const vectorToPoint: (v: Vector2) => Point;
-export declare const vectorToArray: (v: Vector2) => [number, number];
-export declare const arrayToPoint: (a: number[]) => Point;
-export declare const arrayToVector: (a: number[]) => Vector2;
-export declare const calcDist: (prev: [number, number], point: [number, number]) => number;
-export declare const calcDistPoint: (prev: Point, point: Point) => number;
-export declare const calcNormal: (p1: Point, p2: Point) => Point;
-export declare const convertToUnitVector: (p: Point) => Point;
-export declare const createNormals: (points: IPoint[]) => Vector2[];
-export declare const offsetPoint: (point: IPoint, vector: Vector2, offset: number) => Point;
-export declare const offsetPoints: (points: IPoint[], vectors: Vector2[], offset: number) => Point[];