@prashantgosai11/bisag-sidebar 1.0.0

package/dist/BisagSidebar/AddLayers/DeckGl/LineLayer.d.ts

@@ -0,0 +1,157 @@
+import { LineLayer } from "@deck.gl/layers";
+export type Color = [number, number, number, number];
+export type Position = [number, number] | [number, number, number];
+export interface LineLayerConfig {
+    id: string;
+    data: any[];
+    getSourcePosition?: (d: any) => Position;
+    getTargetPosition?: (d: any) => Position;
+    getColor?: ((d: any) => Color) | Color;
+    getWidth?: ((d: any) => number) | number;
+    widthUnits?: "meters" | "common" | "pixels";
+    widthScale?: number;
+    widthMinPixels?: number;
+    widthMaxPixels?: number;
+    pickable?: boolean;
+    visible?: boolean;
+    opacity?: number;
+    onClick?: (info: any) => void;
+    updateTriggers?: Record<string, any[]>;
+}
+/**
+ * Hook to create LineLayer configuration for use with DeckGL
+ *
+ * @param config - Configuration for the line layer
+ * @returns LineLayer instance that can be used in DeckGL layers array
+ *
+ * @example
+ * ```tsx
+ * import { DeckGL } from '@deck.gl/react';
+ * import { useLineLayer } from './LineLayer';
+ *
+ * function MyMap() {
+ *   const lineLayer = useLineLayer({
+ *     id: 'line-layer',
+ *     data: lineData,
+ *     getSourcePosition: d => d.from.coordinates,
+ *     getTargetPosition: d => d.to.coordinates,
+ *     getColor: [255, 0, 0, 180],
+ *     getWidth: 12,
+ *     pickable: true
+ *   });
+ *
+ *   return (
+ *     <DeckGL
+ *       initialViewState={{ longitude: -122.4, latitude: 37.74, zoom: 11 }}
+ *       controller={true}
+ *       layers={[lineLayer]}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+export declare const useLineLayer: (config: LineLayerConfig) => LineLayer<any, {
+    data: string | {
+        length: number;
+        attributes?: Record<string, import("@math.gl/types").TypedArray | import("@luma.gl/core").Buffer | import("@deck.gl/core").BinaryAttribute>;
+    } | Iterable<any> | AsyncIterable<any[]> | Promise<import("@deck.gl/core").LayerData<any>> | null;
+    widthUnits: "meters" | "common" | "pixels";
+    widthScale: number;
+    widthMinPixels: number;
+    widthMaxPixels: number;
+    getSourcePosition: [number, number] | [number, number, number] | Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike> | import("@deck.gl/core").AccessorFunction<any, import("@deck.gl/core").Position>;
+    getTargetPosition: [number, number] | [number, number, number] | Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike> | import("@deck.gl/core").AccessorFunction<any, import("@deck.gl/core").Position>;
+    getColor: [number, number, number, number] | [number, number, number] | Uint8Array<ArrayBufferLike> | Uint8ClampedArray<ArrayBufferLike> | import("@deck.gl/core").AccessorFunction<any, import("@deck.gl/core").Color>;
+    getWidth: number | import("@deck.gl/core").AccessorFunction<any, number>;
+    id: string;
+    dataComparator: (<LayerDataT = import("@deck.gl/core").LayerData<unknown>>(newData: LayerDataT, oldData?: LayerDataT) => boolean) | null;
+    _dataDiff: (<LayerDataT = import("@deck.gl/core").LayerData<unknown>>(newData: LayerDataT, oldData?: LayerDataT) => {
+        startRow: number;
+        endRow?: number;
+    }[]) | null;
+    dataTransform: (<LayerDataT = import("@deck.gl/core").LayerData<unknown>>(data: unknown, previousData?: LayerDataT) => LayerDataT) | null;
+    fetch: (url: string, context: {
+        propName: string;
+        layer: import("@deck.gl/core").Layer;
+        loaders?: import("@loaders.gl/loader-utils").Loader[];
+        loadOptions?: any;
+        signal?: AbortSignal;
+    }) => any;
+    updateTriggers: Record<string, any>;
+    operation: "mask" | "draw" | "terrain" | "mask+mask" | "mask+draw" | "mask+terrain" | "draw+mask" | "draw+draw" | "draw+terrain" | "terrain+mask" | "terrain+draw" | "terrain+terrain";
+    visible: boolean;
+    pickable: boolean | "3d";
+    opacity: number;
+    coordinateSystem: 0 | 2 | 1 | 3 | -1;
+    coordinateOrigin: [number, number, number];
+    modelMatrix: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Uint8ClampedArray<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike> | Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike> | import("@math.gl/core").Matrix4 | import("@math.gl/types").NumberArray16 | null;
+    wrapLongitude: boolean;
+    positionFormat: "XYZ" | "XY";
+    colorFormat: "RGBA" | "RGB";
+    parameters: {
+        cullMode?: import("@luma.gl/core").CullMode;
+        frontFace?: import("@luma.gl/core").FrontFace;
+        depthBias?: number;
+        depthBiasSlopeScale?: number;
+        depthBiasClamp?: number;
+        unclippedDepth?: boolean;
+        provokingVertex?: "first" | "last";
+        polygonMode?: "fill" | "line";
+        polygonOffsetLine?: boolean;
+        clipDistance0?: boolean;
+        clipDistance1?: boolean;
+        clipDistance2?: boolean;
+        clipDistance3?: boolean;
+        clipDistance4?: boolean;
+        clipDistance5?: boolean;
+        clipDistance6?: boolean;
+        clipDistance7?: boolean;
+    } & import("@luma.gl/core").DepthStencilParameters & import("@luma.gl/core").ColorParameters & import("@luma.gl/core").MultisampleParameters;
+    transitions: Record<string, any> | null;
+    extensions: import("@deck.gl/core").LayerExtension[];
+    loaders: import("@loaders.gl/loader-utils").Loader[];
+    loadOptions: any;
+    getPolygonOffset: ((params: {
+        layerIndex: number;
+    }) => [number, number]) | null;
+    autoHighlight: boolean;
+    highlightedObjectIndex: number | null;
+    highlightColor: number[] | ((pickingInfo: import("@deck.gl/core").PickingInfo) => number[]);
+    onDataLoad: (<LayerDataT = import("@deck.gl/core").LayerData<unknown>>(data: LayerDataT, context: {
+        propName: string;
+        layer: import("@deck.gl/core").Layer;
+    }) => void) | null;
+    onError: ((error: Error) => boolean | void) | null;
+    onHover: ((pickingInfo: import("@deck.gl/core").PickingInfo, event: import("mjolnir.js").MjolnirEvent) => boolean | void) | null;
+    onClick: ((pickingInfo: import("@deck.gl/core").PickingInfo, event: import("mjolnir.js").MjolnirEvent) => boolean | void) | null;
+    onDragStart: ((pickingInfo: import("@deck.gl/core").PickingInfo, event: import("mjolnir.js").MjolnirEvent) => boolean | void) | null;
+    onDrag: ((pickingInfo: import("@deck.gl/core").PickingInfo, event: import("mjolnir.js").MjolnirEvent) => boolean | void) | null;
+    onDragEnd: ((pickingInfo: import("@deck.gl/core").PickingInfo, event: import("mjolnir.js").MjolnirEvent) => boolean | void) | null;
+    numInstances: number | null;
+    startIndices: number[] | Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Uint8ClampedArray<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike> | Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike> | null;
+}>;
+/**
+ * Helper function to create LineLayer from data
+ *
+ * @param id - Layer ID
+ * @param data - Array of data objects with source and target positions
+ * @param options - Optional configuration
+ * @returns LineLayer instance
+ *
+ * @example
+ * ```tsx
+ * const layer = createLineLayer(
+ *   'my-line-layer',
+ *   lineData,
+ *   {
+ *     getSourcePosition: d => d.from.coordinates,
+ *     getTargetPosition: d => d.to.coordinates,
+ *     getColor: [255, 0, 0, 180],
+ *     getWidth: 12,
+ *     widthUnits: 'pixels'
+ *   }
+ * );
+ * ```
+ */
+export declare const createLineLayer: (id: string, data: any[], options?: Partial<LineLayerConfig>) => LineLayer;
+export default useLineLayer;

package/dist/BisagSidebar/AddLayers/DeckGl/PathLayer.d.ts

@@ -0,0 +1,167 @@
+import { PathLayer } from "@deck.gl/layers";
+export type Color = [number, number, number, number];
+export interface PathLayerConfig {
+    id: string;
+    data: any[];
+    getPath?: (d: any) => any;
+    getColor?: ((d: any) => Color) | Color;
+    getWidth?: ((d: any) => number) | number;
+    widthUnits?: "meters" | "common" | "pixels";
+    widthScale?: number;
+    widthMinPixels?: number;
+    widthMaxPixels?: number;
+    capRounded?: boolean;
+    jointRounded?: boolean;
+    billboard?: boolean;
+    miterLimit?: number;
+    _pathType?: "loop" | "open" | null;
+    positionFormat?: "XYZ" | "XY";
+    pickable?: boolean;
+    visible?: boolean;
+    opacity?: number;
+    onClick?: (info: any) => void;
+    updateTriggers?: Record<string, any[]>;
+    extensions?: any[];
+    getDashArray?: ((d: any) => [number, number]) | [number, number];
+}
+/**
+ * Hook to create PathLayer configuration for use with DeckGL
+ *
+ * @param config - Configuration for the path layer
+ * @returns PathLayer instance that can be used in DeckGL layers array
+ *
+ * @example
+ * ```tsx
+ * import { DeckGL } from '@deck.gl/react';
+ * import { usePathLayer } from './PathLayer';
+ *
+ * function MyMap() {
+ *   const pathLayer = usePathLayer({
+ *     id: 'path-layer',
+ *     data: pathData,
+ *     getPath: d => d.path,
+ *     getColor: d => [255, 0, 0, 180],
+ *     getWidth: 100,
+ *     pickable: true
+ *   });
+ *
+ *   return (
+ *     <DeckGL
+ *       initialViewState={{ longitude: -122.4, latitude: 37.74, zoom: 11 }}
+ *       controller={true}
+ *       layers={[pathLayer]}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+export declare const usePathLayer: (config: PathLayerConfig) => PathLayer<any, {
+    data: string | {
+        length: number;
+        attributes?: Record<string, import("@math.gl/types").TypedArray | import("@luma.gl/core").Buffer | import("@deck.gl/core").BinaryAttribute>;
+    } | Iterable<any> | AsyncIterable<any[]> | Promise<import("@deck.gl/core").LayerData<any>> | null;
+    widthUnits: "meters" | "common" | "pixels";
+    widthScale: number;
+    widthMinPixels: number;
+    widthMaxPixels: number;
+    jointRounded: boolean;
+    capRounded: boolean;
+    miterLimit: number;
+    billboard: boolean;
+    _pathType: null | "loop" | "open";
+    getPath: import("@deck.gl/core").AccessorFunction<any, import("node_modules/@deck.gl/layers/dist/path-layer/path").PathGeometry>;
+    getColor: [number, number, number, number] | [number, number, number] | Uint8Array<ArrayBufferLike> | Uint8ClampedArray<ArrayBufferLike> | import("@deck.gl/core").Color[] | import("@deck.gl/core").AccessorFunction<any, import("@deck.gl/core").Color | import("@deck.gl/core").Color[]>;
+    getWidth: number | number[] | import("@deck.gl/core").AccessorFunction<any, number | number[]>;
+    rounded: boolean;
+    id: string;
+    dataComparator: (<LayerDataT = import("@deck.gl/core").LayerData<unknown>>(newData: LayerDataT, oldData?: LayerDataT) => boolean) | null;
+    _dataDiff: (<LayerDataT = import("@deck.gl/core").LayerData<unknown>>(newData: LayerDataT, oldData?: LayerDataT) => {
+        startRow: number;
+        endRow?: number;
+    }[]) | null;
+    dataTransform: (<LayerDataT = import("@deck.gl/core").LayerData<unknown>>(data: unknown, previousData?: LayerDataT) => LayerDataT) | null;
+    fetch: (url: string, context: {
+        propName: string;
+        layer: import("@deck.gl/core").Layer;
+        loaders?: import("@loaders.gl/loader-utils").Loader[];
+        loadOptions?: any;
+        signal?: AbortSignal;
+    }) => any;
+    updateTriggers: Record<string, any>;
+    operation: "mask" | "draw" | "terrain" | "mask+mask" | "mask+draw" | "mask+terrain" | "draw+mask" | "draw+draw" | "draw+terrain" | "terrain+mask" | "terrain+draw" | "terrain+terrain";
+    visible: boolean;
+    pickable: boolean | "3d";
+    opacity: number;
+    coordinateSystem: 0 | 2 | 1 | 3 | -1;
+    coordinateOrigin: [number, number, number];
+    modelMatrix: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Uint8ClampedArray<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike> | Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike> | import("@math.gl/core").Matrix4 | import("@math.gl/types").NumberArray16 | null;
+    wrapLongitude: boolean;
+    positionFormat: "XYZ" | "XY";
+    colorFormat: "RGBA" | "RGB";
+    parameters: {
+        cullMode?: import("@luma.gl/core").CullMode;
+        frontFace?: import("@luma.gl/core").FrontFace;
+        depthBias?: number;
+        depthBiasSlopeScale?: number;
+        depthBiasClamp?: number;
+        unclippedDepth?: boolean;
+        provokingVertex?: "first" | "last";
+        polygonMode?: "fill" | "line";
+        polygonOffsetLine?: boolean;
+        clipDistance0?: boolean;
+        clipDistance1?: boolean;
+        clipDistance2?: boolean;
+        clipDistance3?: boolean;
+        clipDistance4?: boolean;
+        clipDistance5?: boolean;
+        clipDistance6?: boolean;
+        clipDistance7?: boolean;
+    } & import("@luma.gl/core").DepthStencilParameters & import("@luma.gl/core").ColorParameters & import("@luma.gl/core").MultisampleParameters;
+    transitions: Record<string, any> | null;
+    extensions: import("@deck.gl/core").LayerExtension[];
+    loaders: import("@loaders.gl/loader-utils").Loader[];
+    loadOptions: any;
+    getPolygonOffset: ((params: {
+        layerIndex: number;
+    }) => [number, number]) | null;
+    autoHighlight: boolean;
+    highlightedObjectIndex: number | null;
+    highlightColor: number[] | ((pickingInfo: import("@deck.gl/core").PickingInfo) => number[]);
+    onDataLoad: (<LayerDataT = import("@deck.gl/core").LayerData<unknown>>(data: LayerDataT, context: {
+        propName: string;
+        layer: import("@deck.gl/core").Layer;
+    }) => void) | null;
+    onError: ((error: Error) => boolean | void) | null;
+    onHover: ((pickingInfo: import("@deck.gl/core").PickingInfo, event: import("mjolnir.js").MjolnirEvent) => boolean | void) | null;
+    onClick: ((pickingInfo: import("@deck.gl/core").PickingInfo, event: import("mjolnir.js").MjolnirEvent) => boolean | void) | null;
+    onDragStart: ((pickingInfo: import("@deck.gl/core").PickingInfo, event: import("mjolnir.js").MjolnirEvent) => boolean | void) | null;
+    onDrag: ((pickingInfo: import("@deck.gl/core").PickingInfo, event: import("mjolnir.js").MjolnirEvent) => boolean | void) | null;
+    onDragEnd: ((pickingInfo: import("@deck.gl/core").PickingInfo, event: import("mjolnir.js").MjolnirEvent) => boolean | void) | null;
+    numInstances: number | null;
+    startIndices: number[] | Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Uint8ClampedArray<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike> | Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike> | null;
+}>;
+/**
+ * Helper function to create PathLayer from data
+ *
+ * @param id - Layer ID
+ * @param data - Array of data objects with path geometries
+ * @param options - Optional configuration
+ * @returns PathLayer instance
+ *
+ * @example
+ * ```tsx
+ * const layer = createPathLayer(
+ *   'my-path-layer',
+ *   pathData,
+ *   {
+ *     getPath: d => d.path,
+ *     getColor: [255, 0, 0, 180],
+ *     getWidth: 100,
+ *     capRounded: true,
+ *     jointRounded: true
+ *   }
+ * );
+ * ```
+ */
+export declare const createPathLayer: (id: string, data: any[], options?: Partial<PathLayerConfig>) => PathLayer;
+export default usePathLayer;

package/dist/BisagSidebar/AddLayers/DeckGl/PolygonLayer.d.ts

@@ -0,0 +1,136 @@
+import { PolygonLayer } from "@deck.gl/layers";
+export type Color = [number, number, number, number];
+export interface PolygonLayerConfig {
+    id: string;
+    data: any[];
+    getPolygon?: (d: any) => number[][][] | number[][];
+    getFillColor?: ((d: any) => Color) | Color;
+    getLineColor?: ((d: any) => Color) | Color;
+    getLineWidth?: ((d: any) => number) | number;
+    getElevation?: ((d: any) => number) | number;
+    lineWidthScale?: number;
+    lineWidthMinPixels?: number;
+    lineWidthMaxPixels?: number;
+    elevationScale?: number;
+    extruded?: boolean;
+    wireframe?: boolean;
+    stroked?: boolean;
+    filled?: boolean;
+    pickable?: boolean;
+    visible?: boolean;
+    opacity?: number;
+    onClick?: (info: any) => void;
+    updateTriggers?: Record<string, any[]>;
+}
+/**
+ * Hook to create PolygonLayer configuration for use with DeckGL
+ * Polygon layer: Display polygon geometries
+ * Reference: https://deck.gl/docs/api-reference/layers/polygon-layer
+ *
+ * @param config - Configuration for the Polygon layer
+ * @returns PolygonLayer instance
+ */
+export declare const usePolygonLayer: (config: PolygonLayerConfig) => PolygonLayer<any, {
+    data: string | {
+        length: number;
+        attributes?: Record<string, import("@math.gl/types").TypedArray | import("@luma.gl/core").Buffer | import("@deck.gl/core").BinaryAttribute>;
+    } | Iterable<any> | AsyncIterable<any[]> | Promise<import("@deck.gl/core").LayerData<any>> | null;
+    stroked: boolean;
+    filled: boolean;
+    extruded: boolean;
+    elevationScale: number;
+    wireframe: boolean;
+    lineWidthUnits: "meters" | "common" | "pixels";
+    lineWidthScale: number;
+    lineWidthMinPixels: number;
+    lineWidthMaxPixels: number;
+    lineJointRounded: boolean;
+    lineMiterLimit: number;
+    lineDashJustified: boolean;
+    getPolygon: import("@deck.gl/core").AccessorFunction<any, any>;
+    getFillColor: [number, number, number, number] | [number, number, number] | Uint8Array<ArrayBufferLike> | Uint8ClampedArray<ArrayBufferLike> | import("@deck.gl/core").AccessorFunction<any, import("@deck.gl/core").Color>;
+    getLineColor: [number, number, number, number] | [number, number, number] | Uint8Array<ArrayBufferLike> | Uint8ClampedArray<ArrayBufferLike> | import("@deck.gl/core").AccessorFunction<any, import("@deck.gl/core").Color>;
+    getLineWidth: number | import("@deck.gl/core").AccessorFunction<any, number>;
+    getElevation: number | import("@deck.gl/core").AccessorFunction<any, number>;
+    getLineDashArray: number | import("@deck.gl/core").AccessorFunction<any, number> | null;
+    _normalize: boolean;
+    _windingOrder: "CW" | "CCW";
+    material: import("@deck.gl/core").Material;
+    id: string;
+    dataComparator: (<LayerDataT = import("@deck.gl/core").LayerData<unknown>>(newData: LayerDataT, oldData?: LayerDataT) => boolean) | null;
+    _dataDiff: (<LayerDataT = import("@deck.gl/core").LayerData<unknown>>(newData: LayerDataT, oldData?: LayerDataT) => {
+        startRow: number;
+        endRow?: number;
+    }[]) | null;
+    dataTransform: (<LayerDataT = import("@deck.gl/core").LayerData<unknown>>(data: unknown, previousData?: LayerDataT) => LayerDataT) | null;
+    fetch: (url: string, context: {
+        propName: string;
+        layer: import("@deck.gl/core").Layer;
+        loaders?: import("@loaders.gl/loader-utils").Loader[];
+        loadOptions?: any;
+        signal?: AbortSignal;
+    }) => any;
+    updateTriggers: Record<string, any>;
+    operation: "mask" | "draw" | "terrain" | "mask+mask" | "mask+draw" | "mask+terrain" | "draw+mask" | "draw+draw" | "draw+terrain" | "terrain+mask" | "terrain+draw" | "terrain+terrain";
+    visible: boolean;
+    pickable: boolean | "3d";
+    opacity: number;
+    coordinateSystem: 0 | 2 | 1 | 3 | -1;
+    coordinateOrigin: [number, number, number];
+    modelMatrix: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Uint8ClampedArray<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike> | Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike> | import("@math.gl/core").Matrix4 | import("@math.gl/types").NumberArray16 | null;
+    wrapLongitude: boolean;
+    positionFormat: "XYZ" | "XY";
+    colorFormat: "RGBA" | "RGB";
+    parameters: {
+        cullMode?: import("@luma.gl/core").CullMode;
+        frontFace?: import("@luma.gl/core").FrontFace;
+        depthBias?: number;
+        depthBiasSlopeScale?: number;
+        depthBiasClamp?: number;
+        unclippedDepth?: boolean;
+        provokingVertex?: "first" | "last";
+        polygonMode?: "fill" | "line";
+        polygonOffsetLine?: boolean;
+        clipDistance0?: boolean;
+        clipDistance1?: boolean;
+        clipDistance2?: boolean;
+        clipDistance3?: boolean;
+        clipDistance4?: boolean;
+        clipDistance5?: boolean;
+        clipDistance6?: boolean;
+        clipDistance7?: boolean;
+    } & import("@luma.gl/core").DepthStencilParameters & import("@luma.gl/core").ColorParameters & import("@luma.gl/core").MultisampleParameters;
+    transitions: Record<string, any> | null;
+    extensions: import("@deck.gl/core").LayerExtension[];
+    loaders: import("@loaders.gl/loader-utils").Loader[];
+    loadOptions: any;
+    getPolygonOffset: ((params: {
+        layerIndex: number;
+    }) => [number, number]) | null;
+    autoHighlight: boolean;
+    highlightedObjectIndex: number | null;
+    highlightColor: number[] | ((pickingInfo: import("@deck.gl/core").PickingInfo) => number[]);
+    onDataLoad: (<LayerDataT = import("@deck.gl/core").LayerData<unknown>>(data: LayerDataT, context: {
+        propName: string;
+        layer: import("@deck.gl/core").Layer;
+    }) => void) | null;
+    onError: ((error: Error) => boolean | void) | null;
+    onHover: ((pickingInfo: import("@deck.gl/core").PickingInfo, event: import("mjolnir.js").MjolnirEvent) => boolean | void) | null;
+    onClick: ((pickingInfo: import("@deck.gl/core").PickingInfo, event: import("mjolnir.js").MjolnirEvent) => boolean | void) | null;
+    onDragStart: ((pickingInfo: import("@deck.gl/core").PickingInfo, event: import("mjolnir.js").MjolnirEvent) => boolean | void) | null;
+    onDrag: ((pickingInfo: import("@deck.gl/core").PickingInfo, event: import("mjolnir.js").MjolnirEvent) => boolean | void) | null;
+    onDragEnd: ((pickingInfo: import("@deck.gl/core").PickingInfo, event: import("mjolnir.js").MjolnirEvent) => boolean | void) | null;
+    numInstances: number | null;
+    startIndices: number[] | Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Uint8ClampedArray<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike> | Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike> | null;
+    _subLayerProps: {
+        [subLayerId: string]: {
+            type?: import("@deck.gl/core")._ConstructorOf<import("@deck.gl/core").Layer>;
+            [propName: string]: any;
+        };
+    } | null;
+}>;
+/**
+ * Helper function to create PolygonLayer from data
+ */
+export declare const createPolygonLayer: (id: string, data: any[], options?: Partial<PolygonLayerConfig>) => PolygonLayer;
+export default usePolygonLayer;

package/dist/BisagSidebar/AddLayers/DeckGl/QuadkeyLayer.d.ts

@@ -0,0 +1,168 @@
+import { QuadkeyLayer } from "@deck.gl/geo-layers";
+export type Color = [number, number, number, number];
+export interface QuadkeyLayerConfig {
+    id: string;
+    data: any[];
+    getQuadkey?: (d: any) => string;
+    getFillColor?: ((d: any) => Color) | Color;
+    getElevation?: ((d: any) => number) | number;
+    elevationScale?: number;
+    extruded?: boolean;
+    pickable?: boolean;
+    visible?: boolean;
+    opacity?: number;
+    stroked?: boolean;
+    filled?: boolean;
+    lineWidthMinPixels?: number;
+    getLineColor?: ((d: any) => Color) | Color;
+    getLineWidth?: ((d: any) => number) | number;
+    onClick?: (info: any) => void;
+    updateTriggers?: Record<string, any[]>;
+}
+/**
+ * Hook to create QuadkeyLayer configuration for use with DeckGL
+ * Quadkey visualization: Display data aggregated by quadkey cells (Bing Maps tile system)
+ * Reference: https://deck.gl/docs/api-reference/geo-layers/quadkey-layer
+ *
+ * Quadkey is a tile indexing system used by Bing Maps. Each quadkey represents
+ * a specific tile at a specific zoom level on the map.
+ *
+ * @param config - Configuration for the Quadkey layer
+ * @returns QuadkeyLayer instance
+ *
+ * @example
+ * ```tsx
+ * const layer = useQuadkeyLayer({
+ *   id: 'quadkey-layer',
+ *   data: quadkeyData,
+ *   getQuadkey: d => d.quadkey,
+ *   getFillColor: d => [255, 0, 0, 180],
+ *   extruded: true,
+ *   getElevation: d => d.count
+ * });
+ * ```
+ */
+export declare const useQuadkeyLayer: (config: QuadkeyLayerConfig) => QuadkeyLayer<any, {
+    getQuadkey: import("@deck.gl/core").AccessorFunction<any, string>;
+    data: string | {
+        length: number;
+        attributes?: Record<string, import("@math.gl/types").TypedArray | import("@luma.gl/core").Buffer | import("@deck.gl/core").BinaryAttribute>;
+    } | Iterable<any> | AsyncIterable<any[]> | Promise<import("@deck.gl/core").LayerData<any>> | null;
+    stroked: boolean;
+    filled: boolean;
+    extruded: boolean;
+    elevationScale: number;
+    wireframe: boolean;
+    lineWidthUnits: "meters" | "common" | "pixels";
+    lineWidthScale: number;
+    lineWidthMinPixels: number;
+    lineWidthMaxPixels: number;
+    lineJointRounded: boolean;
+    lineMiterLimit: number;
+    lineDashJustified: boolean;
+    getPolygon: import("@deck.gl/core").AccessorFunction<any, any>;
+    getFillColor: [number, number, number, number] | [number, number, number] | Uint8Array<ArrayBufferLike> | Uint8ClampedArray<ArrayBufferLike> | import("@deck.gl/core").AccessorFunction<any, import("@deck.gl/core").Color>;
+    getLineColor: [number, number, number, number] | [number, number, number] | Uint8Array<ArrayBufferLike> | Uint8ClampedArray<ArrayBufferLike> | import("@deck.gl/core").AccessorFunction<any, import("@deck.gl/core").Color>;
+    getLineWidth: number | import("@deck.gl/core").AccessorFunction<any, number>;
+    getElevation: number | import("@deck.gl/core").AccessorFunction<any, number>;
+    getLineDashArray: number | import("@deck.gl/core").AccessorFunction<any, number> | null;
+    _normalize: boolean;
+    _windingOrder: "CW" | "CCW";
+    material: import("@deck.gl/core").Material;
+    id: string;
+    dataComparator: (<LayerDataT = import("@deck.gl/core").LayerData<unknown>>(newData: LayerDataT, oldData?: LayerDataT) => boolean) | null;
+    _dataDiff: (<LayerDataT = import("@deck.gl/core").LayerData<unknown>>(newData: LayerDataT, oldData?: LayerDataT) => {
+        startRow: number;
+        endRow?: number;
+    }[]) | null;
+    dataTransform: (<LayerDataT = import("@deck.gl/core").LayerData<unknown>>(data: unknown, previousData?: LayerDataT) => LayerDataT) | null;
+    fetch: (url: string, context: {
+        propName: string;
+        layer: import("@deck.gl/core").Layer;
+        loaders?: import("@loaders.gl/loader-utils").Loader[];
+        loadOptions?: any;
+        signal?: AbortSignal;
+    }) => any;
+    updateTriggers: Record<string, any>;
+    operation: "mask" | "draw" | "terrain" | "mask+mask" | "mask+draw" | "mask+terrain" | "draw+mask" | "draw+draw" | "draw+terrain" | "terrain+mask" | "terrain+draw" | "terrain+terrain";
+    visible: boolean;
+    pickable: boolean | "3d";
+    opacity: number;
+    coordinateSystem: 0 | 2 | 1 | 3 | -1;
+    coordinateOrigin: [number, number, number];
+    modelMatrix: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Uint8ClampedArray<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike> | Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike> | import("@math.gl/core").Matrix4 | import("@math.gl/types").NumberArray16 | null;
+    wrapLongitude: boolean;
+    positionFormat: "XYZ" | "XY";
+    colorFormat: "RGBA" | "RGB";
+    parameters: {
+        cullMode?: import("@luma.gl/core").CullMode;
+        frontFace?: import("@luma.gl/core").FrontFace;
+        depthBias?: number;
+        depthBiasSlopeScale?: number;
+        depthBiasClamp?: number;
+        unclippedDepth?: boolean;
+        provokingVertex?: "first" | "last";
+        polygonMode?: "fill" | "line";
+        polygonOffsetLine?: boolean;
+        clipDistance0?: boolean;
+        clipDistance1?: boolean;
+        clipDistance2?: boolean;
+        clipDistance3?: boolean;
+        clipDistance4?: boolean;
+        clipDistance5?: boolean;
+        clipDistance6?: boolean;
+        clipDistance7?: boolean;
+    } & import("@luma.gl/core").DepthStencilParameters & import("@luma.gl/core").ColorParameters & import("@luma.gl/core").MultisampleParameters;
+    transitions: Record<string, any> | null;
+    extensions: import("@deck.gl/core").LayerExtension[];
+    loaders: import("@loaders.gl/loader-utils").Loader[];
+    loadOptions: any;
+    getPolygonOffset: ((params: {
+        layerIndex: number;
+    }) => [number, number]) | null;
+    autoHighlight: boolean;
+    highlightedObjectIndex: number | null;
+    highlightColor: number[] | ((pickingInfo: import("@deck.gl/core").PickingInfo) => number[]);
+    onDataLoad: (<LayerDataT = import("@deck.gl/core").LayerData<unknown>>(data: LayerDataT, context: {
+        propName: string;
+        layer: import("@deck.gl/core").Layer;
+    }) => void) | null;
+    onError: ((error: Error) => boolean | void) | null;
+    onHover: ((pickingInfo: import("@deck.gl/core").PickingInfo, event: import("mjolnir.js").MjolnirEvent) => boolean | void) | null;
+    onClick: ((pickingInfo: import("@deck.gl/core").PickingInfo, event: import("mjolnir.js").MjolnirEvent) => boolean | void) | null;
+    onDragStart: ((pickingInfo: import("@deck.gl/core").PickingInfo, event: import("mjolnir.js").MjolnirEvent) => boolean | void) | null;
+    onDrag: ((pickingInfo: import("@deck.gl/core").PickingInfo, event: import("mjolnir.js").MjolnirEvent) => boolean | void) | null;
+    onDragEnd: ((pickingInfo: import("@deck.gl/core").PickingInfo, event: import("mjolnir.js").MjolnirEvent) => boolean | void) | null;
+    numInstances: number | null;
+    startIndices: number[] | Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Uint8ClampedArray<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike> | Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike> | null;
+    _subLayerProps: {
+        [subLayerId: string]: {
+            type?: import("@deck.gl/core")._ConstructorOf<import("@deck.gl/core").Layer>;
+            [propName: string]: any;
+        };
+    } | null;
+}>;
+/**
+ * Helper function to create QuadkeyLayer from data
+ *
+ * @param id - Layer ID
+ * @param data - Array of data objects with quadkey strings
+ * @param options - Optional configuration
+ * @returns QuadkeyLayer instance
+ *
+ * @example
+ * ```tsx
+ * const layer = createQuadkeyLayer(
+ *   'my-quadkey-layer',
+ *   quadkeyData,
+ *   {
+ *     getQuadkey: d => d.quadkey,
+ *     getFillColor: [255, 0, 0, 180],
+ *     extruded: true,
+ *     getElevation: d => d.count * 10
+ *   }
+ * );
+ * ```
+ */
+export declare const createQuadkeyLayer: (id: string, data: any[], options?: Partial<QuadkeyLayerConfig>) => QuadkeyLayer;
+export default useQuadkeyLayer;