GeoLeaf Core API - v3.19.0
    Preparing search index...

    Variable GeoJSONCoreConst

    GeoJSONCore: {
        get _map(): GeoJSONNativeMap | null;
        get _layers(): Map<string, GeoJSONLayerEntry>;
        get _options(): Record<string, unknown>;
        get DEFAULT_STYLES(): {
            polygon: {
                color: string;
                weight: number;
                opacity: number;
                fillColor: string;
                fillOpacity: number;
            };
            line: {
                color: string;
                weight: number;
                opacity: number;
                fillColor: string;
                fillOpacity: number;
            };
            point: {
                radius: number;
                color: string;
                weight: number;
                fillColor: string;
                fillOpacity: number;
            };
        };
        STYLE_OPERATORS: Record<string, (a: unknown, b: unknown) => boolean>;
        evaluateStyleCondition: (
            featureOrLeft: unknown,
            conditionOrOp: string | StyleConditionInput,
            rightValue?: unknown,
        ) => boolean;
        getFeatureProperty: (feature: unknown, key: unknown) => unknown;
        getGeometryType: (feature: unknown) => string | null;
        isPointGeometry: (feature: unknown) => boolean;
        isLineGeometry: (feature: unknown) => boolean;
        isPolygonGeometry: (feature: unknown) => boolean;
        validateFeature: (
            ...args: [feature: unknown, index?: number],
        ) => { valid: boolean; errors: string[] };
        validateFeatureCollection: (
            collection: unknown,
            ...rest: unknown[],
        ) => { valid: boolean; errors: string[]; featureCount: number };
        extractCoordinates: (feature: unknown) => [number, number][] | null;
        calculateBounds: (
            features?: unknown[],
        ) => [[number, number], [number, number]] | null;
        init(options?: GeoJSONInitOptions): unknown;
        getLayerById(layerId: string): GeoJSONLayerEntry | null;
        getLayerConfig(layerId: string): GeoJSONLayerDef | null;
        getLayerData(layerId: string): unknown;
        updateLayerData(layerId: string, data: unknown): void;
        getAllLayers(): unknown[];
        showLayer(layerId: string): void;
        hideLayer(layerId: string): void;
        toggleLayer(layerId: string): void;
        removeLayer(layerId: string): void;
        setLayerStyle(layerId: string, styleConfig: unknown): boolean;
        loadFromActiveProfile(
            options?: Record<string, unknown>,
        ): Promise<unknown[]>;
        setWorkerUrl(url: string | null): void;
        filterFeatures(
            filterFn: (feature: GeoJSONFeature, layerId: string) => boolean,
            options?: { layerIds?: string | string[]; geometryType?: string },
        ): { filtered: number; total: number; visible: number };
        clearFeatureFilter(
            options?: { layerIds?: string | string[]; geometryType?: string },
        ): { filtered: number; total: number; visible: number };
        getFeatures(
            options?: { geometryTypes?: string[]; layerIds?: string[] },
        ): TaggedFeature[];
        _updateLayerVisibilityByZoom(): void;
        _registerWithLayerManager(): void;
        _detectLayerType(layer: unknown): string;
    } = GeoJSONModule

    Type Declaration

    • get _map(): GeoJSONNativeMap | null

      Getters for direct state access (compatibility)

    • get _layers(): Map<string, GeoJSONLayerEntry>
    • get _options(): Record<string, unknown>
    • get DEFAULT_STYLES(): {
          polygon: {
              color: string;
              weight: number;
              opacity: number;
              fillColor: string;
              fillOpacity: number;
          };
          line: {
              color: string;
              weight: number;
              opacity: number;
              fillColor: string;
              fillOpacity: number;
          };
          point: {
              radius: number;
              color: string;
              weight: number;
              fillColor: string;
              fillOpacity: number;
          };
      }
    • STYLE_OPERATORS: Record<string, (a: unknown, b: unknown) => boolean>
    • evaluateStyleCondition: (
          featureOrLeft: unknown,
          conditionOrOp: string | StyleConditionInput,
          rightValue?: unknown,
      ) => boolean
    • getFeatureProperty: (feature: unknown, key: unknown) => unknown
    • getGeometryType: (feature: unknown) => string | null
    • isPointGeometry: (feature: unknown) => boolean
    • isLineGeometry: (feature: unknown) => boolean
    • isPolygonGeometry: (feature: unknown) => boolean
    • validateFeature: (
          ...args: [feature: unknown, index?: number],
      ) => { valid: boolean; errors: string[] }
    • validateFeatureCollection: (
          collection: unknown,
          ...rest: unknown[],
      ) => { valid: boolean; errors: string[]; featureCount: number }
    • extractCoordinates: (feature: unknown) => [number, number][] | null
    • calculateBounds: (features?: unknown[]) => [[number, number], [number, number]] | null
    • init: function

      • Initialise the module GeoJSON.

        Parameters

        • options: GeoJSONInitOptions = {}

          Options accepted by GeoJSONCore.init().

          • [key: string]: unknown
          • Optionalmap?: unknown

            Map instance or adapter. Falls back to GeoLeaf.Core.getMap() when absent.

          • OptionaldefaultStyle?: Record<string, unknown> | GeoJSONStyle
          • OptionaldefaultPointStyle?: Record<string, unknown>
          • OptionalonEachFeature?: (feature: GeoJSONFeature, layer: unknown) => void
          • OptionalpointToLayer?: (feature: GeoJSONFeature, latlng: unknown) => unknown
          • OptionalfitBoundsOnLoad?: boolean
          • OptionalmaxZoomOnFit?: number

        Returns unknown

        • The GeoJSON layer or null on failure.
    • getLayerById: function
    • getLayerConfig: function

      • Returns a loaded layer's authored config object (the layer definition stored on its runtime entry), or null when the layer is unknown.

        Runtime read seam for capability plugins (e.g. @geoleaf-plugins/feature-info) that need per-layer config at click/hover time. This is config passthrough (plumbing), not rendering: the kernel exposes the already-loaded config, the plugin interprets it. Reads the shared state directly (same source as the POI config resolution) so it works regardless of layer-manager wiring.

        Parameters

        • layerId: string

          GeoLeaf layer id.

        Returns GeoJSONLayerDef | null

    • getLayerData: function
    • updateLayerData: function

      • Replaces the GeoJSON data of an existing layer in real time.

        Updates both the MapLibre source (source.setData()) and the in-memory state so that subsequent getLayerData() calls return the fresh data.

        Announces geoleaf:layer:updated, once per call, for a layer the store holds: an open table and an active filter follow it, as they follow GeoLeaf.Layers.setData. Since 3.15.0 — the write was silent before.

        On a layer that draws icons (showIconsOnMap), each point of the collection is given the symbolId its taxonomy resolves, as at the first load — written into the features passed in — and the images it names are registered. Since 3.16.0: a layer created empty and filled through this method drew bare discs before.

        Parameters

        • layerId: string

          ID of the layer to update.

        • data: unknown

          GeoJSON FeatureCollection (or any valid GeoJSON) to set.

        Returns void

    • getAllLayers: function
    • showLayer: function
    • hideLayer: function
    • toggleLayer: function
    • removeLayer: function
    • setLayerStyle: function
    • loadFromActiveProfile: function
    • setWorkerUrl: function

      • Sets the URL of the GeoJSON Web Worker script; null restores the default.

        The default is geojson-worker.js in the directory of the LAST <script src> of the page whose URL names a geoleaf…js file, without that script's query string — looked up once, when the bundle loads. A bundle loaded by a <script type="module"> whose src names geoleaf.esm.js thus finds its own directory — unless another such tag, from another directory, comes after it in the page: a plugin's geoleaf-*.plugin.js, say. A bundle imported from an inline <script type="module"> has no such tag: the default then resolves against the PAGE, or against a plugin's directory if one is loaded by <script src>. A bundler build depends on the scripts it emits. This member is how those hosts point at the worker at all — and how a host that serves its files under a content token (?v=…) with a long cache lifetime keeps a new version of the library from running against a cached worker from the previous one.

        • Call it once the bundle has loaded and before GeoLeaf.boot() to cover the first worker. A URL set later applies to the next worker built: a running worker keeps its script until it is torn down — after an idle delay, by dispose(), or by an error.
        • The browser resolves the URL against the page, as new Worker() does, and it must be same-origin: a browser refuses a cross-origin worker script, and GeoJSON is then fetched on the main thread instead.
        • When a worker fails — its script did not load, or it crashed — the loads in flight none of whose chunks had arrived are replayed on the main thread; a load that had received chunks is rejected. Later loads go to the main thread only if the URL that failed is still the current one: a URL set after that worker was built is tried at the next load.
        • A valid call — a URL or null — also clears an earlier worker failure, which otherwise sends every later load to the main thread for the rest of the session.

        Any other value than a non-blank string or null throws a TypeError — raised by the worker manager this member delegates to.

        Parameters

        • url: string | null

          A non-blank URL, or null for the default.

        Returns void

        GeoLeaf?.GeoJSON?.setWorkerUrl("/assets/geoleaf/geojson-worker.js?v=3f9a2c");
    • filterFeatures: function

      • Filters the features of every GeoJSON layer. Shows only features that pass the predicate.

        The predicate runs in JS (so arbitrary logic — substring search, distance, nested fields — is supported), but the resulting visible set is applied on the GPU via map.setFilter on feature ids (no source re-tiling) for non-clustered layers with unique properties.id; clustered / id-less layers fall back to re-feeding the filtered data (RM-P1).

        Every geometry is filtered alike, lines included. options.geometryType narrows the pass to one family (point, line, polygon), and a layer joins it under any spelling its profile may declare (polyline, multipolygon, …). A vector-tile layer keeps no feature in memory and is left unfiltered.

        Parameters

        • filterFn: (feature: GeoJSONFeature, layerId: string) => boolean

          Fonction (feature, layerId) => boolean

        • Optionaloptions: { layerIds?: string | string[]; geometryType?: string } = {}

          Additional options

        Returns { filtered: number; total: number; visible: number }

        • { filtered: number, total: number, visible: number }
    • clearFeatureFilter: function

      • Resets the feature filter (shows all).

        Parameters

        • Optionaloptions: { layerIds?: string | string[]; geometryType?: string } = {}

          Same options as filterFeatures

        Returns { filtered: number; total: number; visible: number }

    • getFeatures: function

      • Returns all loaded features. Reads directly from state.layers (no separate feature cache).

        Parameters

        • Optionaloptions: { geometryTypes?: string[]; layerIds?: string[] } = {}

        Returns TaggedFeature[]

        features GeoJSON enrichies de { _layerId }

    • _updateLayerVisibilityByZoom: function
    • _registerWithLayerManager: function
    • _detectLayerType: function

    Settings
    Member Visibility