@phila/layerboard 3.0.0-beta.20 → 3.0.0-beta.22

package/dist/components/LayerCheckboxSet.vue.d.ts

@@ -0,0 +1,36 @@
+import { LayerConfig } from '../types/layer';
+type __VLS_Props = {
+    /** Array of layer configurations to display */
+    layers: LayerConfig[];
+    /** Set of currently visible layer IDs */
+    visibleLayerIds: Set<string>;
+    /** Map of layer IDs to opacity values (0-1) */
+    layerOpacities?: Record<string, number>;
+    /** Set of layer IDs currently loading */
+    loadingLayerIds?: Set<string>;
+    /** Map of layer IDs to error messages */
+    layerErrors?: Record<string, string>;
+    /** Current map zoom level (for zoom-based availability) */
+    currentZoom?: number;
+    /** Whether to show opacity sliders (can be overridden per-layer) */
+    showOpacity?: boolean;
+    /** Whether to show legends (can be overridden per-layer) */
+    showLegend?: boolean;
+    /** Accessible label for the group */
+    groupLabel?: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    toggleLayer: (layerId: string) => any;
+    setOpacity: (layerId: string, opacity: number) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onToggleLayer?: ((layerId: string) => any) | undefined;
+    onSetOpacity?: ((layerId: string, opacity: number) => any) | undefined;
+}>, {
+    layerOpacities: Record<string, number>;
+    layerErrors: Record<string, string>;
+    currentZoom: number;
+    showOpacity: boolean;
+    showLegend: boolean;
+    loadingLayerIds: Set<string>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLFieldSetElement>;
+export default _default;

package/dist/components/LayerPanel.vue.d.ts

@@ -0,0 +1,63 @@
+import { LayerConfig } from '../types/layer';
+type __VLS_Props = {
+    /** Array of layer configurations with component type */
+    layerList: Array<{
+        config: LayerConfig;
+        component: string;
+    }>;
+    /** Set of currently visible layer IDs */
+    visibleLayers: Set<string>;
+    /** Map of layer IDs to opacity values (0-1) */
+    layerOpacities: Record<string, number>;
+    /** Set of layer IDs currently loading */
+    loadingLayers: Set<string>;
+    /** Map of layer IDs to error messages */
+    layerErrors: Record<string, string>;
+    /** Current map zoom level */
+    currentZoom: number;
+    /** Current search query */
+    searchQuery: string;
+    /** Map of layer URLs to metadata page URLs */
+    layerMetadata: Record<string, string>;
+    /** Display mode: 'flat' for simple list, 'topics' for accordion grouping */
+    mode?: "flat" | "topics";
+    /** Whether to show the search box */
+    showSearch?: boolean;
+    /** Whether to show opacity sliders */
+    showOpacity?: boolean;
+    /** Whether to show legends */
+    showLegend?: boolean;
+    /** Placeholder text for search input */
+    searchPlaceholder?: string;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        topics?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    toggleLayer: (layerId: string) => any;
+    setOpacity: (layerId: string, opacity: number) => any;
+    updateSearch: (query: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onToggleLayer?: ((layerId: string) => any) | undefined;
+    onSetOpacity?: ((layerId: string, opacity: number) => any) | undefined;
+    onUpdateSearch?: ((query: string) => any) | undefined;
+}>, {
+    mode: "flat" | "topics";
+    showSearch: boolean;
+    showOpacity: boolean;
+    showLegend: boolean;
+    searchPlaceholder: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/LayerRadioButtonSet.vue.d.ts

@@ -0,0 +1,39 @@
+import { LayerConfig } from '../types/layer';
+type __VLS_Props = {
+    /** Array of layer configurations to display */
+    layers: LayerConfig[];
+    /** Set of currently visible layer IDs */
+    visibleLayerIds: Set<string>;
+    /** Map of layer IDs to opacity values (0-1) */
+    layerOpacities?: Record<string, number>;
+    /** Set of layer IDs currently loading */
+    loadingLayerIds?: Set<string>;
+    /** Map of layer IDs to error messages */
+    layerErrors?: Record<string, string>;
+    /** Current map zoom level (for zoom-based availability) */
+    currentZoom?: number;
+    /** Whether to show opacity sliders (can be overridden per-layer) */
+    showOpacity?: boolean;
+    /** Whether to show legends (can be overridden per-layer) */
+    showLegend?: boolean;
+    /** Unique name for the radio button group */
+    groupName?: string;
+    /** Accessible label for the group */
+    groupLabel?: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    setOpacity: (layerId: string, opacity: number) => any;
+    selectLayer: (layerId: string, previousLayerIds: string[]) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSetOpacity?: ((layerId: string, opacity: number) => any) | undefined;
+    onSelectLayer?: ((layerId: string, previousLayerIds: string[]) => any) | undefined;
+}>, {
+    layerOpacities: Record<string, number>;
+    layerErrors: Record<string, string>;
+    currentZoom: number;
+    showOpacity: boolean;
+    showLegend: boolean;
+    loadingLayerIds: Set<string>;
+    groupName: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/components/Layerboard.vue.d.ts

@@ -0,0 +1,332 @@
+import { CyclomediaConfig, PictometryCredentials } from '@phila/phila-ui-map-core';
+import { LayerConfig, TiledLayerConfig, LayerStyleOverride, PopupOverride } from '../types/layer';
+import { DataSourceConfig } from '../types/dataSource';
+type ControlPosition = "top-left" | "top-right" | "bottom-left" | "bottom-right";
+type __VLS_Props = {
+    /** App title displayed in header */
+    title: string;
+    /** Optional subtitle displayed in header */
+    subtitle?: string;
+    /** WebMap ID to load layers from */
+    webMapId: string;
+    /** Primary theme color for header/footer (CSS color value) */
+    themeColor?: string;
+    /** Cyclomedia street-level imagery configuration */
+    cyclomediaConfig?: CyclomediaConfig;
+    /** Pictometry oblique imagery credentials */
+    pictometryCredentials?: PictometryCredentials;
+    /** Whether to show the default LayerPanel in sidebar (set false when using sidebar slot) */
+    showDefaultSidebar?: boolean;
+    /** Sidebar width in CSS units */
+    sidebarWidth?: string;
+    /** Label for mobile toggle button when showing map */
+    sidebarLabel?: string;
+    /** Label for mobile toggle button when showing sidebar */
+    mapLabel?: string;
+    /** Whether to fetch metadata from Carto for layer info links */
+    fetchMetadata?: boolean;
+    /** Tiled layer configurations (ESRI MapServer tiles separate from WebMap) */
+    tiledLayers?: TiledLayerConfig[];
+    /** API data source configurations for fetching external data (notices, status, etc.) */
+    dataSources?: DataSourceConfig[];
+    /** Layer style overrides - override paint/legend for specific layers by ID */
+    layerStyleOverrides?: Record<string, LayerStyleOverride>;
+    /** Popup overrides - override popup behavior for specific layers by ID */
+    popupOverrides?: Record<string, PopupOverride>;
+    /** Position of basemap toggle/dropdown control */
+    basemapControlPosition?: ControlPosition;
+    /** Position of zoom in/out navigation control */
+    navigationControlPosition?: ControlPosition;
+    /** Position of geolocation (find me) control */
+    geolocationControlPosition?: ControlPosition;
+    /** Position of address search control */
+    searchControlPosition?: ControlPosition;
+    /** Position of draw tool control (set to null to remove) */
+    drawControlPosition?: ControlPosition | null;
+    /** Position of Cyclomedia street view button */
+    cyclomediaButtonPosition?: ControlPosition;
+    /** Position of Pictometry oblique imagery button */
+    pictometryButtonPosition?: ControlPosition;
+    /** Initial map zoom level */
+    initialZoom?: number;
+    /** Initial map center [lng, lat] */
+    initialCenter?: [number, number];
+};
+declare function toggleTiledLayer(layerId: string): void;
+declare function setTiledLayerVisible(layerId: string, visible: boolean): void;
+declare function setTiledLayerOpacity(layerId: string, opacity: number): void;
+declare function getDataSourceData<T = unknown>(id: string): T | null;
+declare function refetchDataSource(id: string): Promise<void>;
+declare function loadLayerConfigs(): Promise<void>;
+declare function toggleLayer(layerId: string): void;
+declare function setLayerVisible(layerId: string, visible: boolean): void;
+declare function setLayersVisible(layerIds: string[], visible: boolean): void;
+declare function setLayerOpacity(layerId: string, opacity: number): void;
+declare function openModal(): void;
+declare function closeModal(): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        header?(_: {}): any;
+        footer?(_: {
+            openModal: typeof openModal;
+            closeModal: typeof closeModal;
+            isModalOpen: boolean;
+        }): any;
+        footer?(_: {
+            openModal: typeof openModal;
+            closeModal: typeof closeModal;
+            isModalOpen: boolean;
+        }): any;
+        sidebar?(_: {
+            layers: {
+                config: {
+                    id: string;
+                    title: string;
+                    type: "fill" | "line" | "circle";
+                    url: string;
+                    where?: string | undefined;
+                    minZoom?: number | undefined;
+                    maxZoom?: number | undefined;
+                    opacity: number;
+                    paint?: Record<string, unknown> | undefined;
+                    outlinePaint?: Record<string, unknown> | undefined;
+                    legend: {
+                        type: "fill" | "line" | "circle";
+                        color: string;
+                        label: string;
+                        width?: number | undefined;
+                        radius?: number | undefined;
+                    }[];
+                    popup: {
+                        title: string;
+                        fields: {
+                            field: string;
+                            label: string;
+                            format?: {
+                                dateFormat?: string | undefined;
+                                digitSeparator?: boolean | undefined;
+                                places?: number | undefined;
+                            } | undefined;
+                        }[];
+                        showTime?: boolean | undefined;
+                    } | null;
+                    displayOptions?: {
+                        shouldShowCheckbox?: boolean | undefined;
+                        shouldShowSlider?: boolean | undefined;
+                        shouldShowLegendBox?: boolean | undefined;
+                        layerNameChange?: string | undefined;
+                    } | undefined;
+                };
+                component: string;
+            }[];
+            visibleLayers: Set<string> & Omit<Set<string>, keyof Set<any>>;
+            layerOpacities: Record<string, number>;
+            loadingLayers: Set<string> & Omit<Set<string>, keyof Set<any>>;
+            layerErrors: Record<string, string>;
+            currentZoom: number;
+            toggleLayer: typeof toggleLayer;
+            setLayerVisible: typeof setLayerVisible;
+            setLayersVisible: typeof setLayersVisible;
+            setOpacity: typeof setLayerOpacity;
+            tiledLayers: TiledLayerConfig[];
+            visibleTiledLayers: Set<string> & Omit<Set<string>, keyof Set<any>>;
+            tiledLayerOpacities: Record<string, number>;
+            toggleTiledLayer: typeof toggleTiledLayer;
+            setTiledLayerVisible: typeof setTiledLayerVisible;
+            setTiledLayerOpacity: typeof setTiledLayerOpacity;
+            dataSourcesState: import('../types/dataSource').DataSourcesState;
+            dataSourcesLoading: boolean;
+            getDataSource: typeof getDataSourceData;
+            refetchDataSource: typeof refetchDataSource;
+        }): any;
+        modal?(_: {
+            closeModal: typeof closeModal;
+        }): any;
+    };
+    refs: {
+        hamburgerRef: HTMLButtonElement;
+        mobileMenuRef: HTMLDivElement;
+        mobileMenuCloseRef: HTMLButtonElement;
+        sidebarRef: HTMLElement;
+        mobileToggleRef: HTMLButtonElement;
+        modalRef: HTMLDivElement;
+        modalCloseRef: HTMLButtonElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {
+    /** Layer configurations */
+    layerList: import('vue').Ref<{
+        config: {
+            id: string;
+            title: string;
+            type: "fill" | "line" | "circle";
+            url: string;
+            where?: string | undefined;
+            minZoom?: number | undefined;
+            maxZoom?: number | undefined;
+            opacity: number;
+            paint?: Record<string, unknown> | undefined;
+            outlinePaint?: Record<string, unknown> | undefined;
+            legend: {
+                type: "fill" | "line" | "circle";
+                color: string;
+                label: string;
+                width?: number | undefined;
+                radius?: number | undefined;
+            }[];
+            popup: {
+                title: string;
+                fields: {
+                    field: string;
+                    label: string;
+                    format?: {
+                        dateFormat?: string | undefined;
+                        digitSeparator?: boolean | undefined;
+                        places?: number | undefined;
+                    } | undefined;
+                }[];
+                showTime?: boolean | undefined;
+            } | null;
+            displayOptions?: {
+                shouldShowCheckbox?: boolean | undefined;
+                shouldShowSlider?: boolean | undefined;
+                shouldShowLegendBox?: boolean | undefined;
+                layerNameChange?: string | undefined;
+            } | undefined;
+        };
+        component: string;
+    }[], {
+        config: LayerConfig;
+        component: string;
+    }[] | {
+        config: {
+            id: string;
+            title: string;
+            type: "fill" | "line" | "circle";
+            url: string;
+            where?: string | undefined;
+            minZoom?: number | undefined;
+            maxZoom?: number | undefined;
+            opacity: number;
+            paint?: Record<string, unknown> | undefined;
+            outlinePaint?: Record<string, unknown> | undefined;
+            legend: {
+                type: "fill" | "line" | "circle";
+                color: string;
+                label: string;
+                width?: number | undefined;
+                radius?: number | undefined;
+            }[];
+            popup: {
+                title: string;
+                fields: {
+                    field: string;
+                    label: string;
+                    format?: {
+                        dateFormat?: string | undefined;
+                        digitSeparator?: boolean | undefined;
+                        places?: number | undefined;
+                    } | undefined;
+                }[];
+                showTime?: boolean | undefined;
+            } | null;
+            displayOptions?: {
+                shouldShowCheckbox?: boolean | undefined;
+                shouldShowSlider?: boolean | undefined;
+                shouldShowLegendBox?: boolean | undefined;
+                layerNameChange?: string | undefined;
+            } | undefined;
+        };
+        component: string;
+    }[]>;
+    /** Set of visible layer IDs */
+    visibleLayers: import('vue').Ref<Set<string> & Omit<Set<string>, keyof Set<any>>, Set<string> | (Set<string> & Omit<Set<string>, keyof Set<any>>)>;
+    /** Layer opacity values */
+    layerOpacities: import('vue').Ref<Record<string, number>, Record<string, number>>;
+    /** Set of currently loading layer IDs */
+    loadingLayers: import('vue').Ref<Set<string> & Omit<Set<string>, keyof Set<any>>, Set<string> | (Set<string> & Omit<Set<string>, keyof Set<any>>)>;
+    /** Map of layer errors by ID */
+    layerErrors: import('vue').Ref<Record<string, string>, Record<string, string>>;
+    /** Current map zoom level */
+    currentZoom: import('vue').Ref<number, number>;
+    /** Toggle a layer's visibility */
+    toggleLayer: typeof toggleLayer;
+    /** Set a layer's visibility explicitly */
+    setLayerVisible: typeof setLayerVisible;
+    /** Set multiple layers' visibility at once */
+    setLayersVisible: typeof setLayersVisible;
+    /** Set a layer's opacity */
+    setLayerOpacity: typeof setLayerOpacity;
+    /** Reload layer configurations */
+    reloadConfigs: typeof loadLayerConfigs;
+    /** Clear configuration cache */
+    clearCache: () => void;
+    /** Set of visible tiled layer IDs */
+    visibleTiledLayers: import('vue').Ref<Set<string> & Omit<Set<string>, keyof Set<any>>, Set<string> | (Set<string> & Omit<Set<string>, keyof Set<any>>)>;
+    /** Tiled layer opacity values */
+    tiledLayerOpacities: import('vue').Ref<Record<string, number>, Record<string, number>>;
+    /** Toggle a tiled layer's visibility */
+    toggleTiledLayer: typeof toggleTiledLayer;
+    /** Set a tiled layer's visibility explicitly */
+    setTiledLayerVisible: typeof setTiledLayerVisible;
+    /** Set a tiled layer's opacity */
+    setTiledLayerOpacity: typeof setTiledLayerOpacity;
+    /** State of all data sources */
+    dataSourcesState: import('vue').ComputedRef<import('../types/dataSource').DataSourcesState>;
+    /** Whether any data source is loading */
+    dataSourcesLoading: import('vue').ComputedRef<boolean>;
+    /** Get data from a specific data source */
+    getDataSourceData: typeof getDataSourceData;
+    /** Refetch a specific data source */
+    refetchDataSource: typeof refetchDataSource;
+    /** Whether the modal is currently open */
+    isModalOpen: import('vue').Ref<boolean, boolean>;
+    /** Open the modal */
+    openModal: typeof openModal;
+    /** Close the modal */
+    closeModal: typeof closeModal;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    zoom: (zoom: number) => any;
+    "configs-loaded": (configs: LayerConfig[]) => any;
+    "load-error": (error: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onZoom?: ((zoom: number) => any) | undefined;
+    "onConfigs-loaded"?: ((configs: LayerConfig[]) => any) | undefined;
+    "onLoad-error"?: ((error: string) => any) | undefined;
+}>, {
+    tiledLayers: TiledLayerConfig[];
+    basemapControlPosition: ControlPosition;
+    navigationControlPosition: ControlPosition;
+    geolocationControlPosition: ControlPosition;
+    searchControlPosition: ControlPosition;
+    drawControlPosition: ControlPosition | null;
+    cyclomediaButtonPosition: ControlPosition;
+    pictometryButtonPosition: ControlPosition;
+    themeColor: string;
+    showDefaultSidebar: boolean;
+    sidebarWidth: string;
+    sidebarLabel: string;
+    mapLabel: string;
+    fetchMetadata: boolean;
+    dataSources: DataSourceConfig[];
+    layerStyleOverrides: Record<string, LayerStyleOverride>;
+    popupOverrides: Record<string, PopupOverride>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    hamburgerRef: HTMLButtonElement;
+    mobileMenuRef: HTMLDivElement;
+    mobileMenuCloseRef: HTMLButtonElement;
+    sidebarRef: HTMLElement;
+    mobileToggleRef: HTMLButtonElement;
+    modalRef: HTMLDivElement;
+    modalCloseRef: HTMLButtonElement;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/MapPanel.vue.d.ts

@@ -0,0 +1,45 @@
+import { CyclomediaConfig, PictometryCredentials } from '@phila/phila-ui-map-core';
+import { TiledLayerConfig } from '../types/layer';
+type ControlPosition = "top-left" | "top-right" | "bottom-left" | "bottom-right";
+type __VLS_Props = {
+    visibleLayers: Set<string>;
+    layerOpacities: Record<string, number>;
+    layerList: Array<{
+        config: any;
+        component: string;
+    }>;
+    tiledLayers?: TiledLayerConfig[];
+    visibleTiledLayers?: Set<string>;
+    tiledLayerOpacities?: Record<string, number>;
+    cyclomediaConfig?: CyclomediaConfig;
+    pictometryCredentials?: PictometryCredentials;
+    basemapControlPosition?: ControlPosition;
+    navigationControlPosition?: ControlPosition;
+    geolocationControlPosition?: ControlPosition;
+    searchControlPosition?: ControlPosition;
+    drawControlPosition?: ControlPosition | null;
+    cyclomediaButtonPosition?: ControlPosition;
+    pictometryButtonPosition?: ControlPosition;
+    initialZoom?: number;
+    initialCenter?: [number, number];
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    zoom: (zoom: number) => any;
+    layerLoading: (layerId: string, loading: boolean) => any;
+    layerError: (layerId: string, error: string | null) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onZoom?: ((zoom: number) => any) | undefined;
+    onLayerLoading?: ((layerId: string, loading: boolean) => any) | undefined;
+    onLayerError?: ((layerId: string, error: string | null) => any) | undefined;
+}>, {
+    basemapControlPosition: ControlPosition;
+    navigationControlPosition: ControlPosition;
+    geolocationControlPosition: ControlPosition;
+    searchControlPosition: ControlPosition;
+    drawControlPosition: ControlPosition | null;
+    cyclomediaButtonPosition: ControlPosition;
+    pictometryButtonPosition: ControlPosition;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    mapRef: any;
+}, HTMLDivElement>;
+export default _default;

package/dist/components/TopicAccordion.vue.d.ts

@@ -0,0 +1,39 @@
+type __VLS_Props = {
+    /** Title displayed in the accordion header */
+    title: string;
+    /** Optional icon name or component */
+    icon?: string;
+    /** Whether the accordion is initially expanded */
+    expanded?: boolean;
+    /** Array of layer IDs associated with this topic */
+    layerIds?: string[];
+    /** Optional CSS class for custom styling */
+    headerClass?: string;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        icon?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    toggle: (expanded: boolean) => any;
+    layerChange: (layerId: string, visible: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onToggle?: ((expanded: boolean) => any) | undefined;
+    onLayerChange?: ((layerId: string, visible: boolean) => any) | undefined;
+}>, {
+    expanded: boolean;
+    layerIds: string[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/index.d.ts

@@ -0,0 +1,6 @@
+export { default as Layerboard } from './Layerboard.vue';
+export { default as LayerPanel } from './LayerPanel.vue';
+export { default as MapPanel } from './MapPanel.vue';
+export { default as TopicAccordion } from './TopicAccordion.vue';
+export { default as LayerCheckboxSet } from './LayerCheckboxSet.vue';
+export { default as LayerRadioButtonSet } from './LayerRadioButtonSet.vue';

package/dist/composables/index.d.ts

@@ -0,0 +1,4 @@
+export { useLayerboard, type UseLayerboardReturn } from './useLayerboard';
+export { useLayerConfig } from './useLayerConfig';
+export { useDataSource, useReactiveDataSource, type UseDataSourceReturn, type DataSourceConfig as LayerDataSourceConfig, type FetchOptions, type Bounds, } from './useDataSource';
+export { useApiDataSources, type UseApiDataSourcesReturn } from './useApiDataSources';

package/dist/composables/useApiDataSources.d.ts

@@ -0,0 +1,38 @@
+import { Ref } from 'vue';
+import { DataSourceConfig, DataSourcesState } from '../types/dataSource';
+/**
+ * Composable for managing multiple API data sources.
+ *
+ * @example
+ * ```typescript
+ * const dataSources: DataSourceConfig[] = [
+ *   { id: 'notices', url: 'https://api.example.com/notices', type: 'http-get' },
+ *   { id: 'trashDay', url: 'https://api.example.com/trash', type: 'http-get' },
+ * ]
+ *
+ * const { state, getData, refetch, isLoading } = useApiDataSources(dataSources)
+ *
+ * // Access data for a specific source
+ * const notices = computed(() => state.value.notices?.data)
+ * ```
+ */
+export declare function useApiDataSources(configs: DataSourceConfig[]): {
+    /** Reactive state for all data sources */
+    state: Readonly<Ref<DataSourcesState>>;
+    /** Whether any data source is currently loading */
+    isLoading: import('vue').ComputedRef<boolean>;
+    /** Fetch all data sources */
+    fetchAll: () => Promise<void>;
+    /** Refetch a specific data source by id */
+    refetch: (id: string) => Promise<void>;
+    /** Get data for a specific source */
+    getData: <T = unknown>(id: string) => T | null;
+    /** Check if a specific source is loading */
+    isSourceLoading: (id: string) => boolean;
+    /** Get error for a specific source */
+    getError: (id: string) => string | null;
+    /** Stop all polling (useful for cleanup) */
+    stopPolling: () => void;
+};
+/** Type for the return value of useApiDataSources */
+export type UseApiDataSourcesReturn = ReturnType<typeof useApiDataSources>;