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

    Interface ConfigFacade

    The COMPLETE GeoLeaf.Config façade — single source of truth for its shape.

    ⚠️ The singleton is assembled in two stages, which is why this type exists. config-core.ts builds an object literal carrying only the lifecycle core; three sibling modules then graft the rest onto it at import time, as side effects (globals.config.ts imports them for that purpose alone):

    Module Grafts
    config-accessors.ts getAll get getModuleConfig set getSection getActiveProfile* isProfilePoiMappingEnabled
    config-loaders.ts loadUrl loadActiveProfileResources
    config-validation.ts _validateConfig

    Before S5 each grafting module redeclared its own partial interface and reached the singleton through an as unknown as cast — four declarations that ignored one another, two of them redeclaring _config, and no type anywhere describing a complete Config. They now all target this one. The single remaining widening cast lives in config-core.ts, where the two-stage assembly actually happens.

    interface ConfigFacade {
        _config: GeoLeafConfig;
        _isLoaded: boolean;
        _subModulesInitialized: boolean;
        _source: string | null;
        _options: { autoEvent: boolean };
        init(options?: ConfigInitOptions): Promise<GeoLeafConfig>;
        isLoaded(): boolean;
        getSource(): string | null;
        _initSubModules(): void;
        _applyConfig(cfg: Record<string, unknown> | null, source: string): void;
        _maybeFireLoadedEvent(): void;
        getAll(): GeoLeafConfig;
        get<T = unknown>(path: string, defaultValue?: T): T;
        getModuleConfig<T = unknown>(
            moduleId: string,
            key?: string,
            defaultValue?: T,
        ): T;
        set(path: string, value: unknown): void;
        getSection(sectionName: string, defaultValue?: unknown): unknown;
        getActiveProfileId(): string | null;
        getActiveProfile(): Record<string, unknown> | null;
        getActiveProfileMapping(): Record<string, unknown> | null;
        isProfilePoiMappingEnabled(): boolean;
        loadUrl(url: string, options?: LoadUrlOptions): Promise<GeoLeafConfig>;
        loadActiveProfileResources(
            options?: {
                headers?: Record<string, string>;
                strictContentType?: boolean;
            },
        ): Promise<GeoLeafConfig>;
        _validateConfig?: (cfg: GeoLeafConfig | null | undefined) => void;
    }
    Index
    _config _isLoaded _subModulesInitialized _source _options _validateConfig?
    init isLoaded getSource _initSubModules _applyConfig _maybeFireLoadedEvent getAll get getModuleConfig set getSection getActiveProfileId getActiveProfile getActiveProfileMapping isProfilePoiMappingEnabled loadUrl loadActiveProfileResources

    _config

    _config: GeoLeafConfig

    _isLoaded

    _isLoaded: boolean

    _subModulesInitialized

    _subModulesInitialized: boolean

    _source

    _source: string | null

    _options

    _options: { autoEvent: boolean }

    Optional_validateConfig

    _validateConfig?: (cfg: GeoLeafConfig | null | undefined) => void

    • Loads the configuration and brings the sub-modules up.

      Three paths, in this order of precedence: an inline config is applied synchronously; a url is fetched; neither yields an empty configuration rather than an error — a map can boot with defaults. onLoaded fires on all three, and the DOM event only when autoEvent is left on.

      Parameters

      Returns Promise<GeoLeafConfig>

      await GeoLeaf.Config.init({
          url: "../data/geoleaf.config.json",
          autoEvent: true,
          onLoaded: (config) => {
              console.log("Config loaded:", config);
          },
      });

    _initSubModules

    _applyConfig

    _maybeFireLoadedEvent

    • The complete configuration currently loaded.

      ⚠️ Through the ambient global, this returns a loose record: GeoLeafGlobal.Config is hand-typed and declares getAll(): Record<string, unknown>, not GeoLeafConfig. To read a field with its real type, use ConfigFacade.get — which is generic — or import Config from @geoleaf/core/kernel. Typing the ambient member from this interface only ever shrinks — never widened back.

      Returns GeoLeafConfig

      const config = GeoLeaf.Config.getAll();
      console.log(Object.keys(config));

    • Reads one field by dotted path, with a fallback when it is absent.

      Type Parameters

      • T = unknown

      Parameters

      • path: string
      • OptionaldefaultValue: T

      Returns T

      const theme = GeoLeaf.Config.get("ui.theme", "light");
      const zoom = GeoLeaf.Config.get("map.zoom", 10);

    • Writes one field by dotted path, creating the intermediate objects.

      ⚠️ Before boot(), a value set here is not final. The boot then loads the application configuration, which is merged over it key by key. Then it loads the active profile. A modular profile (the kind the repository ships) REPLACES, whole, each top-level section it carries (ui among them). Two exceptions: layers, themes and mapping stay on the profile, and the modules bag is merged module by module. So a value that the profile also declares does not survive the boot.

      To override a value that the profile declares, call set from the beforeBoot hook. It runs after both loads, and before any module reads the configuration.

      Parameters

      • path: string
      • value: unknown

      Returns void

      GeoLeaf.boot({
          beforeBoot: () => {
              // The profile declares "fr"; this host's user reads English.
              GeoLeaf.Config.set("ui.language", "en");
          },
      });

    • The active profile object, as resolved by ProfileManager, or null when none is active.

      Returns Record<string, unknown> | null

      const profile = GeoLeaf.Config.getActiveProfile();
      if (profile) {
          console.log("active profile loaded");
      }

    • Fetches a JSON configuration and applies it.

      🔻 Failure REJECTS, since 20/08/2026 — and this sentence said the exact opposite. It read « Failure is contained, not thrown: […] a bad fetch degrades the map rather than breaking its boot ». That was true until the loader's catch was changed to re-throw, and the sentence was not updated with it: for a few hours a published .d.ts promised an integrator the inverse of what the runtime did. No gate can catch that — nothing checks whether a sentence is still true.

      An unreachable URL, invalid JSON, or a response that is not application/json when strictContentType is set: the cause is logged, then the promise REJECTS. The boot stops instead of continuing on an empty configuration and rendering a blank map under a "Configuration loaded successfully" message.

      ⚠️ Breaking for a caller that relied on the degradation — even without knowing it. If the configuration is already in memory, GeoLeaf.boot({ config }) removes the request entirely and the question does not arise.

      Parameters

      Returns Promise<GeoLeafConfig>

      When the fetch fails, the payload is not valid JSON, or strictContentType rejects the response's content type.

      await GeoLeaf.Config.loadUrl("../data/config.json", {
          headers: { Authorization: "Bearer token" },
      });

    Settings
    Member Visibility

    On This Page
    Properties
    Methods