rlayers/dist/layer/RLayerBaseVector.d.ts

React Components for OpenLayers

import React from 'react';
import { Feature } from 'ol';
import { LoadingStrategy, VectorSourceEvent } from 'ol/source/Vector';
import RenderEvent from 'ol/render/Event';
import BaseVector from 'ol/layer/BaseVector';
import CanvasVectorLayerRenderer from 'ol/renderer/canvas/VectorLayer';
import CanvasVectorTileLayerRenderer from 'ol/renderer/canvas/VectorTileLayer';
import CanvasVectorImageLayerRenderer from 'ol/renderer/canvas/VectorImageLayer';
import WebGLPointsLayerRenderer from 'ol/renderer/webgl/PointsLayer';
import { Vector as SourceVector } from 'ol/source';
import FeatureFormat from 'ol/format/Feature';
import { FeatureLoader, FeatureUrlFunction } from 'ol/featureloader';
import BaseObject from 'ol/Object';
import { OLFeatureClass, RContextType } from '../context';
import { default as RLayer, RLayerProps } from './RLayer';
import { RFeatureUIEvent } from '../RFeature';
import { RStyleLike } from '../style/RStyle';
import { OLEvent } from '../REvent';
import RenderFeature from 'ol/render/Feature';
import JSONFeature from 'ol/format/JSONFeature';
export declare const featureHandlersSymbol = "_rlayers_feature_handlers";
export type FeatureHandlers = Record<OLEvent, number>;
type OLFeatureType<F extends OLFeatureClass> = RenderFeature extends ReturnType<JSONFeature['readFeatures']>[0] ? F : Feature<F>;
/**
 * @propsfor RLayerBaseVector
 */
export interface RLayerBaseVectorProps<F extends OLFeatureClass = OLFeatureClass> extends RLayerProps {
    /** URL for loading features can be a function of type `FeatureUrlFunction`, requires `format` */
    url?: string | FeatureUrlFunction;
    /**
     * Width of the frame around the viewport that shall be rendered too
     * so that the symbols, whose center is outside of the viewport,
     * but are partially inside, can be rendered
     *
     * this property currently does not support dynamic updates
     */
    renderBuffer?: number;
    /** OpenLayers features that will be loaded
     *
     * this property currently does not support dynamic updates
     */
    features?: OLFeatureType<F>[];
    /** Format of the features when `url` is used
     *
     * this property currently does not support dynamic updates
     */
    format?: FeatureFormat;
    /** Use a custom loader instead of XHR */
    loader?: FeatureLoader;
    /** OpenLayers default style for features without `style` */
    style?: RStyleLike;
    /**  OpenLayers option to specify LoadingStrategy default is `all` strategy */
    strategy?: LoadingStrategy;
    /**
     * Wrap features around the antimeridian. Cannot be dynamically updated once the layer is created.
     * @default false
     */
    wrapX?: boolean;
    /** Default onClick handler for loaded features */
    onClick?: (this: RLayerBaseVector<F, RLayerBaseVectorProps<F>>, e: RFeatureUIEvent) => boolean | void;
    /** Called when a feature is added, not called for features
     * already present at creation, ie loaded via `features` or `url`
     *
     * use onFeaturesLoadEnd for features loaded via `url`
     */
    onAddFeature?: (this: RLayerBaseVector<F, RLayerBaseVectorProps<F>>, e: VectorSourceEvent<OLFeatureClass>) => boolean | void;
    /**
     * Called upon initiating the request for new features
     */
    onFeaturesLoadStart?: (this: RLayerBaseVector<F, RLayerBaseVectorProps<F>>, e: VectorSourceEvent<OLFeatureClass>) => boolean | void;
    /**
     * Called when the external features have been loaded from `url`
     *
     * e.features will contain the new features
     *
     * This callback is invoked before the features are loaded
     */
    onFeaturesLoadEnd?: (this: RLayerBaseVector<F, RLayerBaseVectorProps<F>>, e: VectorSourceEvent<OLFeatureClass>) => boolean | void;
    /**
     * Called on failure while loading features
     */
    onFeaturesLoadError?: (this: RLayerBaseVector<F, RLayerBaseVectorProps<F>>, e: VectorSourceEvent<OLFeatureClass>) => boolean | void;
    /** onPointerMove handler for all loaded features */
    onPointerMove?: (this: RLayerBaseVector<F, RLayerBaseVectorProps<F>>, e: RFeatureUIEvent) => boolean | void;
    /** onPointerEnter handler for all loaded features */
    onPointerEnter?: (this: RLayerBaseVector<F, RLayerBaseVectorProps<F>>, e: RFeatureUIEvent) => boolean | void;
    /** onPointerLeave handler for all loaded features */
    onPointerLeave?: (this: RLayerBaseVector<F, RLayerBaseVectorProps<F>>, e: RFeatureUIEvent) => boolean | void;
    onPostRender?: (this: RLayerBaseVector<F, RLayerBaseVectorProps<F>>, e: RenderEvent) => boolean | void;
    onPreRender?: (this: RLayerBaseVector<F, RLayerBaseVectorProps<F>>, e: RenderEvent) => boolean | void;
}
/**
 * An abstract class used for grouping code common to all Vector layers
 *
 * Meant to be extended
 */
export default class RLayerBaseVector<F extends OLFeatureClass, P extends RLayerBaseVectorProps<F>> extends RLayer<P> {
    ol: BaseVector<SourceVector<OLFeatureClass>, CanvasVectorLayerRenderer | CanvasVectorTileLayerRenderer | CanvasVectorImageLayerRenderer | WebGLPointsLayerRenderer>;
    source: SourceVector<OLFeatureClass>;
    constructor(props: Readonly<P>, context?: React.Context<RContextType>);
    protected createSource(props: Readonly<P>): BaseObject[];
    protected refresh(prevProps?: P): void;
    incrementHandlers(ev: OLEvent): void;
    decrementHandlers(ev: OLEvent): void;
    render(): JSX.Element;
}
export {};
//# sourceMappingURL=RLayerBaseVector.d.ts.map