@equinor/videx-map 1.14.9 → 1.14.10

package/dist/EventHandler.d.ts

@@ -0,0 +1,21 @@
+export interface EventHandlerCallbacks {
+    mousemove: (event: MouseEvent) => boolean;
+    mouseout: (event: MouseEvent) => boolean;
+    mousedown: (event: MouseEvent) => boolean;
+    mouseup: (event: MouseEvent) => boolean;
+    click: (event: Event) => boolean;
+}
+export interface EventHandler {
+    map: L.Map;
+    element: HTMLElement;
+    callbacks: EventHandlerCallbacks;
+    register(map: L.Map, element: HTMLElement, callbacks: EventHandlerCallbacks): void;
+    unregister(): void;
+}
+export declare class DefaultEventHandler implements EventHandler {
+    map: L.Map;
+    element: HTMLElement;
+    callbacks: EventHandlerCallbacks;
+    register(map: L.Map, element: HTMLElement, callbacks: EventHandlerCallbacks): void;
+    unregister(): void;
+}

package/dist/ExplorationLayer.d.ts

@@ -0,0 +1,38 @@
+import * as PIXI from 'pixi.js';
+import { ModuleInterface } from './ModuleInterface';
+import { RootUniforms } from './utils/wellbores/Shader';
+import PointDictionary from './utils/PointDictionary';
+/**
+ * Data assigned each point in point dictionary.
+ */
+interface PointData {
+    mesh: PIXI.Mesh;
+    uniforms: RootUniforms;
+}
+interface selection {
+    point: PointData;
+    /** Original z-index. */
+    zIndex: number;
+}
+/**
+ * Exploration layer
+ *
+ * Layer for displaying exploration wells.
+ */
+export default class ExplorationLayer extends ModuleInterface {
+    /** Dictionary used to manage points. */
+    pointDict: PointDictionary<PointData>;
+    /** Initial scale. */
+    prevScale: number;
+    /** Current selection */
+    selection: selection;
+    appendExploration(scale?: number): void;
+    /**
+     * @param scale
+     * @returns Clamped scale
+     * @private
+     */
+    clampScale(scale: number): number;
+    highlight(lat: number, long: number): boolean;
+}
+export {};

package/dist/FaultlineModule.d.ts

@@ -0,0 +1,52 @@
+import * as PIXI from 'pixi.js';
+import { ModuleInterface } from './ModuleInterface';
+/** Data format on incoming faultlines */
+interface FaultlineData {
+    coordinates: [number, number][];
+    geometry: string;
+    modelGuid: string;
+    omniaUpdateDate: string;
+    segID: number;
+    source: string;
+    sourceCreateDate: string;
+    sourceFileName: string;
+    sourceUpdateDate: string;
+}
+/** Interface for faultline config. */
+export interface InputConfig {
+    /** Color of faultline on format 0xRRGGBB. (Default: 0x727D88) */
+    color?: number;
+    /** Alpha of faultlines. (Default: 1.0) */
+    alpha?: number;
+    /** Width of outline. (Default: 0.125) */
+    outlineWidth?: number;
+}
+interface Config {
+    /** Color of faultline on format 0xRRGGBB. (Default: 0x727D88) */
+    color: number;
+    /** Alpha of faultlines. (Default: 1.0) */
+    alpha: number;
+    /** Width of outline. (Default: 0.125) */
+    outlineWidth: number;
+}
+/** Module for displaying faultlines. */
+export default class FaultlineModule extends ModuleInterface {
+    /** Graphic elements currently existing in world space. */
+    spawned: PIXI.Graphics[];
+    /** Pool of initialized graphic elements. */
+    pool: PIXI.Graphics[];
+    /** Default config. */
+    config: Config;
+    constructor(config?: InputConfig);
+    destroy(): void;
+    /**
+     * Set collection of faultlines to display. Clears previous content on execution.
+     * @param data Faultlines to draw
+     * @param redraw Should pixiOverlay be redrawn after setting data? (Default: false)
+     */
+    set(data: FaultlineData[], redraw?: boolean): void;
+    /** Clear all spawned graphic elements and return to pool. */
+    clear(): void;
+    resize(_zoom: number): void;
+}
+export {};

package/dist/FieldModule.d.ts

@@ -0,0 +1,113 @@
+import * as PIXI from 'pixi.js';
+import Vector2 from '@equinor/videx-vector2';
+import { ModuleInterface } from './ModuleInterface';
+import { MeshData, MeshNormalData } from './utils/Mesh';
+import Highlighter from './utils/fields/Highlighter';
+import LabelManager from './utils/fields/LabelManager';
+import TriangleDictionary from './utils/TriangleDictionary';
+type vec3 = [number, number, number];
+interface FillUniform {
+    col1: vec3;
+    col2: vec3;
+    opacity: number;
+    hashed: boolean;
+    hashDisp: number;
+    hashWidth: number;
+}
+interface OutlineUniform {
+    color: vec3;
+    width: number;
+}
+/** Collection of data describing colors used for fill. */
+interface FieldStyle {
+    fillColor1: vec3;
+    fillColor2: vec3;
+    fillOpacity: number;
+    outlineColor: vec3;
+    hashed: boolean;
+}
+export interface Field {
+    type: string;
+    geometry: {
+        type: string;
+        /**
+         * The type of data found within coordinates depends on type.
+         * For 'Polygon', coordinates is given as [number, number][][].
+         * for 'MultiPolygon', coordinates is given as [number, number][][][].
+         */
+        coordinates: [number, number][][] | [number, number][][][];
+    };
+    properties: {
+        discname: string;
+        group: number;
+        guid?: number;
+        hctype: string;
+        label: string;
+        lat: number;
+        long: number;
+        polygonId: number;
+        status: string;
+    };
+}
+export interface FieldMesh {
+    fill: {
+        mesh: PIXI.Mesh;
+        uniform: FillUniform;
+    };
+    outline: {
+        mesh: PIXI.Mesh;
+        uniform: OutlineUniform;
+    };
+}
+/** Interface for field config. */
+interface Config {
+    /** Initial scale of field hash (Default: 1.0). */
+    initialHash?: number;
+    /** Minimum scale of field hash (Default: 0.0). */
+    minHash?: number;
+    /** Maximum scale of field hash (Default: Infinity). */
+    maxHash?: number;
+}
+/** Module for displaying fields. */
+export default class FieldModule extends ModuleInterface {
+    /** Vertex shader for the fill. */
+    static vertexShaderFill: string;
+    /** Fragment shader for the fill. */
+    static fragmentShaderFill: string;
+    /** Vertex shader for the outlines. */
+    static vertexShaderOutline: string;
+    /** Fragment shader for the outlines. */
+    static fragmentShaderOutline: string;
+    /** Collection of fields with meshes. */
+    fields: FieldMesh[];
+    /** Settings for how to render fields. */
+    config: Config;
+    dict: TriangleDictionary<number>;
+    highlighter: Highlighter;
+    labelManager: LabelManager;
+    /** Index of previously highlighted field */
+    prevField: number;
+    constructor(config?: Config);
+    set(data: Field[]): void;
+    /**
+     * Draw each polygon in a polygon collection.
+     * @param polygons
+     */
+    drawPolygons(meshData: MeshData, outlineData: MeshNormalData, fieldStyle: FieldStyle, zIndex: number): FieldMesh;
+    /**
+     * Get the fill color of a field.
+     * @param props Properties of field
+     * @returns Color used to fill
+     */
+    getFieldStyle(guid: number, hctype: string): FieldStyle;
+    /**
+     * Project a collection of polygons.
+     * @param points Points within polygons
+     * @returns Projected polygons
+     */
+    projectPolygons(points: [number, number][]): Vector2[];
+    resize(_zoom: number): void;
+    highlight(lat: number, long: number): boolean;
+    tryUnselect(): void;
+}
+export {};

package/dist/GeoJSONModule/GeoJSONModule.d.ts

@@ -0,0 +1,47 @@
+import * as PIXI from 'pixi.js';
+import Vector2 from '@equinor/videx-vector2';
+import { ModuleInterface } from '../ModuleInterface';
+import { EventHandler } from '../EventHandler';
+import { default as GeoJSONMultiPolygon } from './multipolygon';
+import { default as GeoJSONPolygon } from './polygon';
+import { default as GeoJSONLineString } from './linestring';
+import { default as GeoJSONPoint } from './point';
+import { ResizeConfig, LabelResizeConfig } from '../ResizeConfigInterface';
+import { FeatureProps } from './interfaces';
+/** Interface for config. */
+interface Config {
+    customEventHandler?: EventHandler;
+    onFeatureHover?: (event: MouseEvent, data: any) => void;
+    outlineResize?: ResizeConfig;
+    labelResize?: LabelResizeConfig;
+}
+/** Module for displaying fields. */
+export default class GeoJSONModule extends ModuleInterface {
+    onFeatureHover: (event: MouseEvent, data: any) => void;
+    points: GeoJSONPoint;
+    linestrings: GeoJSONLineString;
+    polygons: GeoJSONPolygon;
+    multipolygons: GeoJSONMultiPolygon;
+    _eventHandler: EventHandler;
+    mapmoving: boolean;
+    labelRoot: PIXI.Container;
+    config?: Config;
+    constructor(config?: Config);
+    set(data: GeoJSON.FeatureCollection, props?: (feature: any) => FeatureProps): void;
+    /**
+   * Check for features at the given coordinates.
+   * Will give a list of feature data if any are hit or an empty list if not.
+   * @param pos Target position in lat-long
+   * @returns List of features at the given position
+   */
+    testPosition(pos: Vector2): any;
+    onAdd(map: import('leaflet').Map): void;
+    onRemove(_map: import('leaflet').Map): void;
+    resize(zoom: number): void;
+    private handleMouseMove;
+    private handleMouseOut;
+    private handleMouseClick;
+    private handleMouseDown;
+    private handleMouseUp;
+}
+export {};

package/dist/GeoJSONModule/constants.d.ts

@@ -0,0 +1,13 @@
+export declare class Defaults {
+    static readonly DEFAULT_Z_INDEX = 1000;
+    static readonly DEFAULT_LINE_WIDTH = 0.15;
+    static readonly INITIAL_ZOOM = 20;
+    static readonly DEFAULT_FONT_FAMILY = "Arial";
+    static readonly DEFAULT_FONT_SIZE = 64;
+    static readonly DEFAULT_FONT_WEIGHT = "600";
+    static readonly DEFAULT_LABEL_COLOR = 4539717;
+    static readonly DEFAULT_LABEL_ALIGN = "center";
+    static readonly INITIAL_HASH = 1;
+    static readonly DEFAULT_MIN_HASH = 0;
+    static readonly DEFAULT_BASE_SCALE = 0.1;
+}

package/dist/GeoJSONModule/index.d.ts

@@ -0,0 +1,6 @@
+export { default as GeoJSONMultiPolygon } from './multipolygon';
+export { default as GeoJSONPolygon } from './polygon';
+export { default as GeoJSONLineString } from './linestring';
+export { default as GeoJSONPoint } from './point';
+export { default as GeoJSONModule } from './GeoJSONModule';
+export * from './interfaces';

package/dist/GeoJSONModule/interfaces.d.ts

@@ -0,0 +1,15 @@
+export interface FeatureStyle {
+    lineColor: string;
+    lineWidth: number;
+    fillColor?: string;
+    fillColor2?: string;
+    fillOpacity?: number;
+    hashed?: boolean;
+    labelScale?: number;
+}
+export interface FeatureProps {
+    id: number;
+    label: string;
+    style: FeatureStyle;
+    additionalData?: any;
+}

package/dist/GeoJSONModule/labels.d.ts

@@ -0,0 +1,46 @@
+import * as PIXI from 'pixi.js';
+import Vector2 from '@equinor/videx-vector2';
+/** Data for label. */
+export type GeoJSONLabelData = {
+    position: Vector2;
+    mass: number;
+};
+interface Label {
+    name: string;
+    position: Vector2;
+    instance?: PIXI.BitmapText;
+}
+/** Class used to manage field labels. Handles scaling and grouping of labels. */
+export default class GeoJSONLabels {
+    /**PIXI container  to hold all labels*/
+    container: PIXI.Container;
+    /** The textstyle used for labels. */
+    textStyle: PIXI.TextStyle;
+    /** The font used for labels. */
+    font: PIXI.BitmapFont;
+    /** font name */
+    fontName: string;
+    /** Scale of labels when size is set to 1. */
+    baseScale: number;
+    /** Collection of single-polygon fields. */
+    labels: Label[];
+    /** Visibility */
+    visible: boolean;
+    /** construct a new label container. */
+    constructor(root: PIXI.Container, textStyle: PIXI.TextStyle, baseScale: number, fontName?: string);
+    /**
+     * Add a new label.
+     * @param name label name
+     * @param data Data for each label
+     */
+    addLabel(name: string, data: GeoJSONLabelData): void;
+    /**
+     * Draw all labels
+     * @param root Target root for labels
+     */
+    draw(): void;
+    hideLabels(): void;
+    showLabels(): void;
+    resize(scale: number): void;
+}
+export {};

package/dist/GeoJSONModule/linestring.d.ts

@@ -0,0 +1,55 @@
+import * as PIXI from 'pixi.js';
+import Vector2 from '@equinor/videx-vector2';
+import { pixiOverlayBase } from '../pixiOverlayInterfaces';
+import { MeshNormalData } from '../utils/Mesh';
+import LineDictionary from '../utils/LineDictionary';
+import { FeatureProps, FeatureStyle } from '.';
+import { ResizeConfig } from '../ResizeConfigInterface';
+type vec3 = [number, number, number];
+interface OutlineUniform {
+    color: vec3;
+    width: number;
+}
+export interface FeatureMesh {
+    outline: {
+        mesh: PIXI.Mesh;
+        uniform: OutlineUniform;
+    };
+}
+/** Interface for field config. */
+interface Config {
+    outlineResize?: ResizeConfig;
+}
+/** Module for displaying fields. */
+export default class GeoJSONLineString {
+    /** Vertex shader for the outlines. */
+    static vertexShaderOutline: string;
+    /** Fragment shader for the outlines. */
+    static fragmentShaderOutline: string;
+    /** Collection of features with meshes. */
+    features: FeatureMesh[];
+    /** Settings for how to render fields. */
+    config: Config;
+    container: PIXI.Container;
+    pixiOverlay: pixiOverlayBase;
+    dict: LineDictionary<any>;
+    textStyle: PIXI.TextStyle;
+    currentZoom: number;
+    constructor(root: PIXI.Container, pixiOverlay: pixiOverlayBase, config?: Config);
+    add(feature: GeoJSON.Feature, props: (feature: object) => FeatureProps): void;
+    /**
+     * Draw each polygon in a polygon collection.
+     * @param polygons
+     */
+    drawPolygons(container: PIXI.Container, outlineData: MeshNormalData, featureStyle: FeatureStyle, zIndex: number): FeatureMesh;
+    /**
+     * Project a collection of polygons.
+     * @param points Points within polygons
+     * @returns Projected polygons
+     */
+    projectPolygons(points: [number, number][]): Vector2[];
+    resize(zoom: number): void;
+    testPosition(pos: Vector2): number;
+    getOutlineRadius(zoom?: number): number;
+}
+export {};

package/dist/GeoJSONModule/multipolygon.d.ts

@@ -0,0 +1,94 @@
+import * as PIXI from 'pixi.js';
+import Vector2 from '@equinor/videx-vector2';
+import { pixiOverlayBase } from '../pixiOverlayInterfaces';
+import { MeshData, MeshNormalData } from '../utils/Mesh';
+import GeoJSONLabels from './labels';
+import TriangleDictionary from '../utils/TriangleDictionary';
+import { FeatureProps, FeatureStyle } from '.';
+import { ResizeConfig, LabelResizeConfig } from '../ResizeConfigInterface';
+type vec3 = [number, number, number];
+interface FillUniform {
+    col1: vec3;
+    col2: vec3;
+    opacity: number;
+    hashed: boolean;
+    hashDisp: number;
+    hashWidth: number;
+}
+interface OutlineUniform {
+    color: vec3;
+    outlineWidth: number;
+}
+export interface FeatureMesh {
+    fill: {
+        mesh: PIXI.Mesh;
+        uniform: FillUniform;
+    };
+    outline: {
+        mesh: PIXI.Mesh;
+        uniform: OutlineUniform;
+    };
+}
+/** Interface for feature config. */
+interface Config {
+    /** Initial scale of feature hash (Default: 1.0). */
+    initialHash?: number;
+    /** Minimum scale of feature hash (Default: 0.0). */
+    minHash?: number;
+    /** Maximum scale of feature hash (Default: Infinity). */
+    maxHash?: number;
+    /**Label font family, default Arial */
+    labelFontFamily?: string;
+    /**Label font size, default 64 */
+    labelFontSize?: number;
+    /**Label font weight, default 600 */
+    labelFontWeight?: string;
+    /**Label fill color, default 0x454545 */
+    labelColor?: string | number;
+    /**Label alignment, default Center  */
+    labelAlign?: string;
+    /** Resize configuration for outline. */
+    outlineResize?: ResizeConfig;
+    /** Resize configuration for labels. */
+    labelResize?: LabelResizeConfig;
+}
+/** Container for GeoJSON Polygon features. */
+export default class GeoJSONMultiPolygon {
+    /** Vertex shader for the fill. */
+    static vertexShaderFill: string;
+    /** Fragment shader for the fill. */
+    static fragmentShaderFill: string;
+    /** Vertex shader for the outlines. */
+    static vertexShaderOutline: string;
+    /** Fragment shader for the outlines. */
+    static fragmentShaderOutline: string;
+    /** Collection of features with meshes. */
+    features: FeatureMesh[];
+    /** Settings for how to render data. */
+    config: Config;
+    container: PIXI.Container;
+    pixiOverlay: pixiOverlayBase;
+    dict: TriangleDictionary<any>;
+    textStyle: PIXI.TextStyle;
+    labels: GeoJSONLabels;
+    currentZoom: number;
+    constructor(root: PIXI.Container, labelRoot: PIXI.Container, pixiOverlay: pixiOverlayBase, config?: Config);
+    add(feature: GeoJSON.Feature, props: (feature: object) => FeatureProps): void;
+    /**
+     * Draw each polygon in a polygon collection.
+     * @param polygons
+     */
+    drawPolygons(container: PIXI.Container, meshData: MeshData, outlineData: MeshNormalData, featureStyle: FeatureStyle, zIndex: number): FeatureMesh;
+    drawLabels(): void;
+    /**
+     * Project a collection of polygons.
+     * @param points Points within polygons
+     * @returns Projected polygons
+     */
+    projectPolygons(points: [number, number][]): Vector2[];
+    resize(zoom: number): void;
+    testPosition(pos: Vector2): number;
+    getOutlineRadius(zoom?: number): number;
+    getLabelSize(zoom?: number): number;
+}
+export {};

package/dist/GeoJSONModule/point.d.ts

@@ -0,0 +1,26 @@
+import * as PIXI from 'pixi.js';
+import Vector2 from '@equinor/videx-vector2';
+import { pixiOverlayBase } from '../pixiOverlayInterfaces';
+import PointDictionary from '../utils/PointDictionary';
+import { FeatureProps } from '.';
+/** Module for displaying fields. */
+export default class GeoJSONPoint {
+    /** Graphic elements currently existing in world space. */
+    spawned: PIXI.Graphics[];
+    /** Pool of initialized graphic elements. */
+    pool: PIXI.Graphics[];
+    container: PIXI.Container;
+    pixiOverlay: pixiOverlayBase;
+    dict: PointDictionary<any>;
+    textStyle: PIXI.TextStyle;
+    constructor(root: PIXI.Container, pixiOverlay: pixiOverlayBase);
+    add(feature: GeoJSON.Feature, props: (feature: object) => FeatureProps): void;
+    /**
+      * Project a point coordinate.
+      * @param point x,y pair
+      * @returns Projected point
+      */
+    projectPoint(point: [number, number]): Vector2;
+    resize(_zoom: number): void;
+    testPosition(pos: Vector2): any;
+}

package/dist/GeoJSONModule/polygon.d.ts

@@ -0,0 +1,96 @@
+import * as PIXI from 'pixi.js';
+import Vector2 from '@equinor/videx-vector2';
+import { pixiOverlayBase } from '../pixiOverlayInterfaces';
+import { MeshData, MeshNormalData } from '../utils/Mesh';
+import GeoJSONLabels from './labels';
+import TriangleDictionary from '../utils/TriangleDictionary';
+import { FeatureProps, FeatureStyle } from '.';
+import { ResizeConfig, LabelResizeConfig } from '../ResizeConfigInterface';
+type vec3 = [number, number, number];
+interface FillUniform {
+    col1: vec3;
+    col2: vec3;
+    opacity: number;
+    hashed: boolean;
+    hashDisp: number;
+    hashWidth: number;
+}
+interface OutlineUniform {
+    color: vec3;
+    outlineWidth: number;
+}
+export interface FeatureMesh {
+    fill: {
+        mesh: PIXI.Mesh;
+        uniform: FillUniform;
+    };
+    outline: {
+        mesh: PIXI.Mesh;
+        uniform: OutlineUniform;
+    };
+}
+/** Interface for feature config. */
+interface Config {
+    /** Initial scale of feature hash (Default: 1.0). */
+    initialHash?: number;
+    /** Minimum scale of feature hash (Default: 0.0). */
+    minHash?: number;
+    /** Maximum scale of feature hash (Default: Infinity). */
+    maxHash?: number;
+    /**Label font family, default Arial */
+    labelFontFamily?: string;
+    /**Label font size, default 64 */
+    labelFontSize?: number;
+    /**Label font weight, default 600 */
+    labelFontWeight?: string;
+    /**Label fill color, default 0x454545 */
+    labelColor?: string | number;
+    /**Label alignment, default Center  */
+    labelAlign?: string;
+    /** Resize configuration of outline. */
+    outlineResize?: ResizeConfig;
+    /** Resize configuration for labels. */
+    labelResize?: LabelResizeConfig;
+}
+/** Container for GeoJSON Polygon features. */
+export default class GeoJSONPolygon {
+    /** Vertex shader for the fill. */
+    static vertexShaderFill: string;
+    /** Fragment shader for the fill. */
+    static fragmentShaderFill: string;
+    /** Vertex shader for the outlines. */
+    static vertexShaderOutline: string;
+    /** Fragment shader for the outlines. */
+    static fragmentShaderOutline: string;
+    /** Collection of features with meshes. */
+    features: FeatureMesh[];
+    /** Settings for how to render data. */
+    config: Config;
+    container: PIXI.Container;
+    pixiOverlay: pixiOverlayBase;
+    dict: TriangleDictionary<any>;
+    textStyle: PIXI.TextStyle;
+    labels: GeoJSONLabels;
+    currentZoom: number;
+    outlineThickness: number;
+    zIndex: number;
+    constructor(root: PIXI.Container, labelRoot: PIXI.Container, pixiOverlay: pixiOverlayBase, config?: Config);
+    add(feature: GeoJSON.Feature, props: (feature: object) => FeatureProps): void;
+    /**
+     * Draw each polygon in a polygon collection.
+     * @param polygons
+     */
+    drawPolygons(container: PIXI.Container, meshData: MeshData, outlineData: MeshNormalData, featureStyle: FeatureStyle, zIndex: number): FeatureMesh;
+    drawLabels(): void;
+    /**
+     * Project a collection of polygons.
+     * @param points Points within polygons
+     * @returns Projected polygons
+     */
+    projectPolygons(points: [number, number][]): Vector2[];
+    resize(zoom: number): void;
+    testPosition(pos: Vector2): any;
+    getOutlineRadius(zoom?: number): number;
+    getLabelSize(zoom?: number): number;
+}
+export {};

package/dist/GeoJSONModule/shader.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shared shaders for polygon and multipolygon
+ */
+export declare const GeoJSONVertexShaderFill = "\n  attribute vec2 inputVerts;\n\n  uniform mat3 translationMatrix;\n  uniform mat3 projectionMatrix;\n\n  varying vec2 verts;\n\n  void main() {\n    verts = inputVerts;\n    gl_Position = vec4((projectionMatrix * translationMatrix * vec3(inputVerts, 1.0)).xy, 0.0, 1.0);\n  }\n  ";
+export declare const GeoJSONFragmentShaderFill = "\n  precision mediump float;\n\n  varying vec2 verts;\n\n  uniform vec3 col1;\n  uniform vec3 col2;\n  uniform float opacity;\n\n  uniform bool hashed;\n  uniform float hashDisp;\n  uniform float hashWidth;\n\n  void main() {\n    if(hashed && mod(verts.y + hashDisp, hashWidth * 2.0) > hashWidth) {\n      gl_FragColor = vec4(col2 / 255., 1.0) * opacity;\n    }\n    else {\n      gl_FragColor = vec4(col1 / 255., 1.0) * opacity;\n    }\n  }\n  ";
+/**
+ * Shared shaders for polygon, multipolygon and linestring
+ */
+export declare const GeoJSONVertexShaderOutline = "\n  attribute vec2 inputVerts;\n  attribute vec2 inputNormals;\n\n  uniform mat3 translationMatrix;\n  uniform mat3 projectionMatrix;\n\n  uniform float outlineWidth;\n\n  void main() {\n    vec2 pos = inputVerts + inputNormals * outlineWidth;\n    gl_Position = vec4((projectionMatrix * translationMatrix * vec3(pos, 1.0)).xy, 0.0, 1.0);\n  }\n  ";
+export declare const GeoJSONFragmentShaderOutline = "\n  precision mediump float;\n\n  uniform vec3 color;\n\n  void main() {\n    gl_FragColor = vec4(color / 255., 1.0);\n  }\n  ";

package/dist/ModuleInterface.d.ts

@@ -0,0 +1,26 @@
+import { pixiOverlayBase } from './pixiOverlayInterfaces';
+import * as PIXI from 'pixi.js';
+/** Class with common functions shared by all layers. */
+export declare abstract class ModuleInterface {
+    /** Function for pixi overlay. */
+    pixiOverlay: pixiOverlayBase;
+    /** Root container for layer. */
+    root: PIXI.Container;
+    /** True if layer is currently visible. */
+    visibility: boolean;
+    /** Common constructor for all map layers. */
+    constructor();
+    destroy(): void;
+    /** Toggle the visibility of the root PIXI container. */
+    toggle(): void;
+    /**
+     * Set visibility of the root PIXI container to a given value.
+     *
+     * @param visible Should layer be visible?
+     * @returns True if new visibility was set
+     */
+    setVisibility(visible: boolean): boolean;
+    onAdd(_map: L.Map): void;
+    onRemove(_map: L.Map): void;
+    resize(_zoom: number): void;
+}