@equinor/videx-map 1.14.3 → 1.14.4

package/dist/utils/wellbores/data/Group.d.ts

@@ -1,48 +1,48 @@
-import { Colors, InputColors } from '../Colors';
-import { WellboreData } from './WellboreData';
-import { SourceData } from './SourceData';
-import { Detail, DetailOptions } from './details';
-export interface GroupOptions {
-    order?: number;
-    mirrorLabels?: boolean;
-    colors?: InputColors;
-}
-interface WellboreState {
-    completionVisible: boolean;
-    wellboreVisible: boolean;
-}
-type Filter = (data: SourceData) => boolean;
-export declare class Group {
-    key: string;
-    colors: Colors;
-    order: number;
-    mirrorLabels: boolean;
-    wellbores: WellboreData[];
-    details: {
-        [key: string]: Detail;
-    };
-    active: boolean;
-    activeFilter: Filter;
-    /** Is active filter soft or hard (Ghost) */
-    isHardFilter: boolean;
-    /** State of wellbores attached to group */
-    state: WellboreState;
-    constructor(key: string, options?: GroupOptions);
-    registerDetail(key: string, detail: DetailOptions): void;
-    setDetailVisibility(key: string, visible: boolean): void;
-    resetDetails(): void;
-    append(wellbore: WellboreData): void;
-    /**
-     * Iterate over all wellbores and unique roots.
-     * @param wellboreFunc Function to call on wellbores
-     * @param rootFunc Function to call on roots
-     */
-    private forAll;
-    setActive(active: boolean): void;
-    softFilter(filter: Filter): void;
-    hardFilter(filter: Filter): void;
-    clearFilter(): void;
-    setCompletionVisibility(visible: boolean): void;
-    setWellboreVisibility(visible: boolean): void;
-}
-export {};
+import { Colors, InputColors } from '../Colors';
+import { WellboreData } from './WellboreData';
+import { SourceData } from './SourceData';
+import { Detail, DetailOptions } from './details';
+export interface GroupOptions {
+    order?: number;
+    mirrorLabels?: boolean;
+    colors?: InputColors;
+}
+interface WellboreState {
+    completionVisible: boolean;
+    wellboreVisible: boolean;
+}
+type Filter = (data: SourceData) => boolean;
+export declare class Group {
+    key: string;
+    colors: Colors;
+    order: number;
+    mirrorLabels: boolean;
+    wellbores: WellboreData[];
+    details: {
+        [key: string]: Detail;
+    };
+    active: boolean;
+    activeFilter: Filter;
+    /** Is active filter soft or hard (Ghost) */
+    isHardFilter: boolean;
+    /** State of wellbores attached to group */
+    state: WellboreState;
+    constructor(key: string, options?: GroupOptions);
+    registerDetail(key: string, detail: DetailOptions): void;
+    setDetailVisibility(key: string, visible: boolean): void;
+    resetDetails(): void;
+    append(wellbore: WellboreData): void;
+    /**
+     * Iterate over all wellbores and unique roots.
+     * @param wellboreFunc Function to call on wellbores
+     * @param rootFunc Function to call on roots
+     */
+    private forAll;
+    setActive(active: boolean): void;
+    softFilter(filter: Filter): void;
+    hardFilter(filter: Filter): void;
+    clearFilter(): void;
+    setCompletionVisibility(visible: boolean): void;
+    setWellboreVisibility(visible: boolean): void;
+}
+export {};

package/dist/utils/wellbores/data/RootData.d.ts

@@ -1,29 +1,29 @@
-import * as PIXI from 'pixi.js';
-import Vector2 from '@equinor/videx-vector2';
-import { WellboreData } from './WellboreData';
-export declare class RootData {
-    static state: {
-        rootRadius: number;
-        maxScale: number;
-    };
-    mesh: PIXI.Mesh;
-    wellbores: WellboreData[];
-    position: Vector2;
-    labelIndex: number;
-    rootLabelsBBox: PIXI.Rectangle;
-    /** Target wellbore data for color */
-    target: WellboreData;
-    constructor(position: Vector2);
-    /** Active if  */
-    get active(): boolean;
-    private updateLabelsBBox;
-    /** Position wellbore label along wellbore. Should never be called if labels are disabled. */
-    private positionLabel;
-    append(wellbore: WellboreData): void;
-    /** Recalculate target and update uniforms */
-    recalculate(labelUpdate?: boolean): void;
-    private updateTarget;
-    private updateUniforms;
-    updateLabels(): void;
-    setLabelVisibility(visible: boolean): void;
-}
+import * as PIXI from 'pixi.js';
+import Vector2 from '@equinor/videx-vector2';
+import { WellboreData } from './WellboreData';
+export declare class RootData {
+    static state: {
+        rootRadius: number;
+        maxScale: number;
+    };
+    mesh: PIXI.Mesh;
+    wellbores: WellboreData[];
+    position: Vector2;
+    labelIndex: number;
+    rootLabelsBBox: PIXI.Rectangle;
+    /** Target wellbore data for color */
+    target: WellboreData;
+    constructor(position: Vector2);
+    /** Active if  */
+    get active(): boolean;
+    private updateLabelsBBox;
+    /** Position wellbore label along wellbore. Should never be called if labels are disabled. */
+    private positionLabel;
+    append(wellbore: WellboreData): void;
+    /** Recalculate target and update uniforms */
+    recalculate(labelUpdate?: boolean): void;
+    private updateTarget;
+    private updateUniforms;
+    updateLabels(): void;
+    setLabelVisibility(visible: boolean): void;
+}

package/dist/utils/wellbores/data/SourceData.d.ts

@@ -1,25 +1,25 @@
-/** Date for each interval. */
-export interface Interval {
-    /** Type of interval [Screen, Perforation]. */
-    type: string;
-    /** Start of interval as distance along wellbore. */
-    start: number;
-    /** End of interval as distance along wellbore. */
-    end: number;
-    /** Start of interval along wellbore as a value between 0 and 1. */
-    l1: number;
-    /** End of interval along wellbore as a value between 0 and 1. */
-    l2: number;
-}
-/** Wellbore data. */
-export interface SourceData {
-    [key: string]: any;
-    /** Collection of intervals. */
-    intervals: Interval[];
-    /** Full label of wellbore. */
-    label: string;
-    /** Short label of wellbore, ie. no country code. */
-    labelShort: string;
-    /** Path along wellbore on lat/long format. */
-    path: [number, number][];
-}
+/** Date for each interval. */
+export interface Interval {
+    /** Type of interval [Screen, Perforation]. */
+    type: string;
+    /** Start of interval as distance along wellbore. */
+    start: number;
+    /** End of interval as distance along wellbore. */
+    end: number;
+    /** Start of interval along wellbore as a value between 0 and 1. */
+    l1: number;
+    /** End of interval along wellbore as a value between 0 and 1. */
+    l2: number;
+}
+/** Wellbore data. */
+export interface SourceData {
+    [key: string]: any;
+    /** Collection of intervals. */
+    intervals: Interval[];
+    /** Full label of wellbore. */
+    label: string;
+    /** Short label of wellbore, ie. no country code. */
+    labelShort: string;
+    /** Path along wellbore on lat/long format. */
+    path: [number, number][];
+}

package/dist/utils/wellbores/data/WellboreData.d.ts

@@ -1,76 +1,76 @@
-import * as PIXI from 'pixi.js';
-import Vector2 from '@equinor/videx-vector2';
-import { SourceData } from './SourceData';
-import { RootData } from './RootData';
-import { Group } from './Group';
-import { LineInterpolator } from '../../LineInterpolator';
-import { WellboreUniforms } from '../Shader';
-import { Label } from '../labels/Label';
-import { Colors, Color } from '../Colors';
-import { TickConfig } from '../Config';
-import { Detail } from './details';
-export interface WellboreDataInput {
-    data: SourceData;
-    group: Group;
-    root: RootData;
-    /** Projected coordinates. */
-    coords: Vector2[];
-    /** Threshold for radius considered to be single point. */
-    pointThreshold: number;
-    wellboreWidth: number;
-    tick: TickConfig;
-}
-export declare enum WellboreStatus {
-    normal = 0,
-    highlighted = 1,
-    multiHighlighted = 2,
-    selected = 3
-}
-/** Current filter status. Soft leaves gray wellbores, while hard leaves "ghost"-lines */
-export declare enum FilterStatus {
-    none = 0,
-    soft = 1,
-    hard = 2
-}
-export declare class WellboreData {
-    static state: {
-        wellboreRadius: number;
-        rootRadius: number;
-    };
-    data: SourceData;
-    group: Group;
-    wellboreWidth: number;
-    interpolator: LineInterpolator;
-    container: PIXI.Container;
-    label: Label;
-    private _zIndex;
-    private details;
-    private detailsDict;
-    private mesh;
-    root: RootData;
-    status: WellboreStatus;
-    private filter;
-    constructor(input: WellboreDataInput);
-    set zIndex(val: number);
-    get colors(): Colors;
-    get color(): Color;
-    get active(): boolean;
-    /**
-     * Render wellbore details if data is available.
-     * @param key - Unique identifier for the detail to render
-     * @param detail - Object containing information to draw
-     */
-    tryDrawDetail(key: string, detail: Detail): void;
-    setFilter(filter: FilterStatus): void;
-    get selected(): boolean;
-    get highlighted(): boolean;
-    get order(): number;
-    get uniforms(): WellboreUniforms;
-    private createWellboreMesh;
-    setCompletionVisibility(visible: boolean): void;
-    setWellboreVisibility(visible: boolean): void;
-    setDetailsVisibility(key: string, visible: boolean): void;
-    setHighlight(isHighlighted: boolean, multiple?: boolean): void;
-    setSelected(isSelected: boolean): void;
-    update(): void;
-}
+import * as PIXI from 'pixi.js';
+import Vector2 from '@equinor/videx-vector2';
+import { SourceData } from './SourceData';
+import { RootData } from './RootData';
+import { Group } from './Group';
+import { LineInterpolator } from '../../LineInterpolator';
+import { WellboreUniforms } from '../Shader';
+import { Label } from '../labels/Label';
+import { Colors, Color } from '../Colors';
+import { TickConfig } from '../Config';
+import { Detail } from './details';
+export interface WellboreDataInput {
+    data: SourceData;
+    group: Group;
+    root: RootData;
+    /** Projected coordinates. */
+    coords: Vector2[];
+    /** Threshold for radius considered to be single point. */
+    pointThreshold: number;
+    wellboreWidth: number;
+    tick: TickConfig;
+}
+export declare enum WellboreStatus {
+    normal = 0,
+    highlighted = 1,
+    multiHighlighted = 2,
+    selected = 3
+}
+/** Current filter status. Soft leaves gray wellbores, while hard leaves "ghost"-lines */
+export declare enum FilterStatus {
+    none = 0,
+    soft = 1,
+    hard = 2
+}
+export declare class WellboreData {
+    static state: {
+        wellboreRadius: number;
+        rootRadius: number;
+    };
+    data: SourceData;
+    group: Group;
+    wellboreWidth: number;
+    interpolator: LineInterpolator;
+    container: PIXI.Container;
+    label: Label;
+    private _zIndex;
+    private details;
+    private detailsDict;
+    private mesh;
+    root: RootData;
+    status: WellboreStatus;
+    private filter;
+    constructor(input: WellboreDataInput);
+    set zIndex(val: number);
+    get colors(): Colors;
+    get color(): Color;
+    get active(): boolean;
+    /**
+     * Render wellbore details if data is available.
+     * @param key - Unique identifier for the detail to render
+     * @param detail - Object containing information to draw
+     */
+    tryDrawDetail(key: string, detail: Detail): void;
+    setFilter(filter: FilterStatus): void;
+    get selected(): boolean;
+    get highlighted(): boolean;
+    get order(): number;
+    get uniforms(): WellboreUniforms;
+    private createWellboreMesh;
+    setCompletionVisibility(visible: boolean): void;
+    setWellboreVisibility(visible: boolean): void;
+    setDetailsVisibility(key: string, visible: boolean): void;
+    setHighlight(isHighlighted: boolean, multiple?: boolean): void;
+    setSelected(isSelected: boolean): void;
+    update(): void;
+}

package/dist/utils/wellbores/data/WellboreEventData.d.ts

@@ -1,16 +1,16 @@
-import { SourceData } from './SourceData';
-import { WellboreData } from './WellboreData';
-export declare class WellboreEventData {
-    group: string;
-    data: SourceData;
-    constructor(group: string, data: SourceData);
-    static from(wellbore: WellboreData): WellboreEventData;
-}
-export declare class HighlightEvent {
-    changed: boolean;
-    originalEvent?: any;
-    eventData: WellboreEventData[];
-    constructor(eventData: WellboreEventData[], changed: boolean, originalEvent: any);
-    static from(wellbores: WellboreData[], changed: boolean, originalEvent: any): HighlightEvent;
-    get count(): number;
-}
+import { SourceData } from './SourceData';
+import { WellboreData } from './WellboreData';
+export declare class WellboreEventData {
+    group: string;
+    data: SourceData;
+    constructor(group: string, data: SourceData);
+    static from(wellbore: WellboreData): WellboreEventData;
+}
+export declare class HighlightEvent {
+    changed: boolean;
+    originalEvent?: any;
+    eventData: WellboreEventData[];
+    constructor(eventData: WellboreEventData[], changed: boolean, originalEvent: any);
+    static from(wellbores: WellboreData[], changed: boolean, originalEvent: any): HighlightEvent;
+    get count(): number;
+}

package/dist/utils/wellbores/data/details/Detail.d.ts

@@ -1,20 +1,20 @@
-import * as PIXI from 'pixi.js';
-import { SourceData } from '../SourceData';
-import { LineInterpolator } from '../../../LineInterpolator';
-import { DetailOptions, RelativePosition } from './DetailOptions';
-/** Detail represents graphics displayed along the wellbore, such as casing. */
-export declare abstract class Detail {
-    initialized: boolean;
-    visible: boolean;
-    protected getData: (wellbore: SourceData, group: string) => RelativePosition[];
-    protected color: PIXI.Color;
-    protected group: string;
-    constructor(options: DetailOptions, group?: string);
-    /**
-     * Obtain the relative position along the wellbore required for rendering graphics.
-     * @param wellbore - Source data for the wellbore
-     * @returns Relative position along the wellbore needed for drawing graphics
-     */
-    getRelative(wellbore: SourceData): RelativePosition[];
-    abstract getGraphics(relative: RelativePosition, interpolator: LineInterpolator): PIXI.Graphics;
-}
+import * as PIXI from 'pixi.js';
+import { SourceData } from '../SourceData';
+import { LineInterpolator } from '../../../LineInterpolator';
+import { DetailOptions, RelativePosition } from './DetailOptions';
+/** Detail represents graphics displayed along the wellbore, such as casing. */
+export declare abstract class Detail {
+    initialized: boolean;
+    visible: boolean;
+    protected getData: (wellbore: SourceData, group: string) => RelativePosition[];
+    protected color: PIXI.Color;
+    protected group: string;
+    constructor(options: DetailOptions, group?: string);
+    /**
+     * Obtain the relative position along the wellbore required for rendering graphics.
+     * @param wellbore - Source data for the wellbore
+     * @returns Relative position along the wellbore needed for drawing graphics
+     */
+    getRelative(wellbore: SourceData): RelativePosition[];
+    abstract getGraphics(relative: RelativePosition, interpolator: LineInterpolator): PIXI.Graphics;
+}

package/dist/utils/wellbores/data/details/DetailOptions.d.ts

@@ -1,7 +1,7 @@
-import { SourceData } from '../SourceData';
-export type RelativePosition = (number | [number, number]);
-export interface DetailOptions {
-    getData: (wellbore: SourceData, group: string) => RelativePosition[];
-    shape?: string;
-    color?: [number, number, number];
-}
+import { SourceData } from '../SourceData';
+export type RelativePosition = (number | [number, number]);
+export interface DetailOptions {
+    getData: (wellbore: SourceData, group: string) => RelativePosition[];
+    shape?: string;
+    color?: [number, number, number];
+}

package/dist/utils/wellbores/data/details/ShoeDetail.d.ts

@@ -1,14 +1,14 @@
-import * as PIXI from 'pixi.js';
-import { LineInterpolator } from '../../../LineInterpolator';
-import { DetailOptions } from './DetailOptions';
-import { Detail } from './Detail';
-export interface ShoeOptions extends DetailOptions {
-    widthTop: number;
-    widthBottom: number;
-}
-export declare class ShoeDetail extends Detail {
-    private widthTop;
-    private widthBottom;
-    constructor(options: ShoeOptions, group?: string);
-    getGraphics([top, bottom]: [number, number], interpolator: LineInterpolator): PIXI.Graphics;
-}
+import * as PIXI from 'pixi.js';
+import { LineInterpolator } from '../../../LineInterpolator';
+import { DetailOptions } from './DetailOptions';
+import { Detail } from './Detail';
+export interface ShoeOptions extends DetailOptions {
+    widthTop: number;
+    widthBottom: number;
+}
+export declare class ShoeDetail extends Detail {
+    private widthTop;
+    private widthBottom;
+    constructor(options: ShoeOptions, group?: string);
+    getGraphics([top, bottom]: [number, number], interpolator: LineInterpolator): PIXI.Graphics;
+}

package/dist/utils/wellbores/data/details/index.d.ts

@@ -1,11 +1,11 @@
-export { Detail } from './Detail';
-export { DetailOptions } from './DetailOptions';
-import { DetailOptions } from './DetailOptions';
-import { ShoeDetail } from './ShoeDetail';
-/**
- * Retrieve the appropriate detail based on the shape specified in the options.
- * @param options - Detail configuration parameters
- * @param group - Group to which the detail belongs
- * @returns The correct detail based on the provided shape
- */
-export declare const getDetail: (options: DetailOptions, group?: string) => ShoeDetail;
+export { Detail } from './Detail';
+export { DetailOptions } from './DetailOptions';
+import { DetailOptions } from './DetailOptions';
+import { ShoeDetail } from './ShoeDetail';
+/**
+ * Retrieve the appropriate detail based on the shape specified in the options.
+ * @param options - Detail configuration parameters
+ * @param group - Group to which the detail belongs
+ * @returns The correct detail based on the provided shape
+ */
+export declare const getDetail: (options: DetailOptions, group?: string) => ShoeDetail;

package/dist/utils/wellbores/data/index.d.ts

@@ -1,6 +1,6 @@
-export { RootData } from './RootData';
-export { WellboreData } from './WellboreData';
-export { SourceData, Interval } from './SourceData';
-export { Group, GroupOptions } from './Group';
-export { Detail, DetailOptions } from './details';
-export { WellboreEventData, HighlightEvent } from './WellboreEventData';
+export { RootData } from './RootData';
+export { WellboreData } from './WellboreData';
+export { SourceData, Interval } from './SourceData';
+export { Group, GroupOptions } from './Group';
+export { Detail, DetailOptions } from './details';
+export { WellboreEventData, HighlightEvent } from './WellboreEventData';

package/dist/utils/wellbores/highlight-helper.d.ts

@@ -1,6 +1,6 @@
-import Vector2 from '@equinor/videx-vector2';
-import { WellboreData, HighlightEvent } from './data';
-import WellboreModule from '../../WellboreModule';
-export declare function updateHighlighted(module: WellboreModule, pos: Vector2, onHighlightOn?: (event: HighlightEvent) => void, onHighlightOff?: () => void, originalEvent?: any): void;
-export declare function forceHighlight(module: WellboreModule, wellbore: WellboreData): void;
-export declare function clearHighlight(module: WellboreModule, onHighlightOff?: () => void): void;
+import Vector2 from '@equinor/videx-vector2';
+import { WellboreData, HighlightEvent } from './data';
+import WellboreModule from '../../WellboreModule';
+export declare function updateHighlighted(module: WellboreModule, pos: Vector2, onHighlightOn?: (event: HighlightEvent) => void, onHighlightOff?: () => void, originalEvent?: any): void;
+export declare function forceHighlight(module: WellboreModule, wellbore: WellboreData): void;
+export declare function clearHighlight(module: WellboreModule, onHighlightOff?: () => void): void;

package/dist/utils/wellbores/intervals.d.ts

@@ -1,15 +1,15 @@
-import { Interval } from './data';
-/**
- * Combines overlapping intervals.
- * @param intervals A collection of intervals on the format: [start, stop]
- * @returns Array with compressed intervals
- *
- * @example compressInterval([ [1, 5], [4, 7] ]); // Returns: [[1, 7]]
- */
-export declare function compressIntervals(intervals: [number, number][]): [number, number][];
-/**
- * Sorts intervals by length and compresses.
- * @param intervals Intervals to process
- * @returns Processed intervals
- */
-export declare function processIntervals(intervals: Interval[]): [number, number][];
+import { Interval } from './data';
+/**
+ * Combines overlapping intervals.
+ * @param intervals A collection of intervals on the format: [start, stop]
+ * @returns Array with compressed intervals
+ *
+ * @example compressInterval([ [1, 5], [4, 7] ]); // Returns: [[1, 7]]
+ */
+export declare function compressIntervals(intervals: [number, number][]): [number, number][];
+/**
+ * Sorts intervals by length and compresses.
+ * @param intervals Intervals to process
+ * @returns Processed intervals
+ */
+export declare function processIntervals(intervals: Interval[]): [number, number][];

package/dist/utils/wellbores/labels/Label.d.ts

@@ -1,39 +1,39 @@
-import * as PIXI from 'pixi.js';
-interface State {
-    zoom: number;
-    scale: number;
-    visible: boolean;
-    /** Displacement from root. */
-    rootDisplacement: number;
-}
-/** Common configurations. */
-interface Common {
-    backgroundOpacity: number;
-}
-export declare class Label {
-    static state: State;
-    private static style;
-    static config: Common;
-    static height: number;
-    container: PIXI.Container;
-    private text;
-    background: PIXI.Graphics;
-    metrics: PIXI.TextMetrics;
-    private _attachToRoot;
-    static setStyle(fontSize: number): void;
-    static setCommon(config: Common): void;
-    /**
-     * Create a new label
-     * @param label Content of label
-     * @param fontColor Color of font
-     * @param bgColor Color of background
-     */
-    constructor(label: string, fontColor: number, bgColor: number);
-    get visible(): boolean;
-    set visible(flag: boolean);
-    set fontColor(color: number);
-    get attachToRoot(): boolean;
-    set attachToRoot(val: boolean);
-    getBoundingBox(): PIXI.Rectangle;
-}
-export {};
+import * as PIXI from 'pixi.js';
+interface State {
+    zoom: number;
+    scale: number;
+    visible: boolean;
+    /** Displacement from root. */
+    rootDisplacement: number;
+}
+/** Common configurations. */
+interface Common {
+    backgroundOpacity: number;
+}
+export declare class Label {
+    static state: State;
+    private static style;
+    static config: Common;
+    static height: number;
+    container: PIXI.Container;
+    private text;
+    background: PIXI.Graphics;
+    metrics: PIXI.TextMetrics;
+    private _attachToRoot;
+    static setStyle(fontSize: number): void;
+    static setCommon(config: Common): void;
+    /**
+     * Create a new label
+     * @param label Content of label
+     * @param fontColor Color of font
+     * @param bgColor Color of background
+     */
+    constructor(label: string, fontColor: number, bgColor: number);
+    get visible(): boolean;
+    set visible(flag: boolean);
+    set fontColor(color: number);
+    get attachToRoot(): boolean;
+    set attachToRoot(val: boolean);
+    getBoundingBox(): PIXI.Rectangle;
+}
+export {};

package/dist/utils/wellbores/labels/index.d.ts

@@ -1,2 +1,2 @@
-export { Label } from './Label';
-export * from './label-helper';
+export { Label } from './Label';
+export * from './label-helper';