@honua/react 0.0.20-alpha.0

package/exploration/reducer.js

@@ -0,0 +1,332 @@
+/**
+ * Pure reducer for `ExplorationState`. Every transition returns a new
+ * state object — readers may use referential equality to detect change on
+ * any slice (e.g. `prev.filters !== next.filters`).
+ *
+ * The reducer does not own scheduling, propagation, or events; those live
+ * in `./context.ts`.
+ *
+ * @module
+ */
+import { featureSelectionKey } from "./selection.js";
+/**
+ * Apply one intent. Returns the next state plus the set of slices that
+ * actually changed (by reference). Callers compare the set rather than
+ * re-deriving it so that "no-op" intents (e.g. setting the same sort)
+ * do not wake listeners.
+ */
+export function reduce(state, intent) {
+    switch (intent.kind) {
+        case "set-filter": {
+            const existing = state.filters[intent.id];
+            if (existing && filtersEqual(existing, intent.clause)) {
+                return { state, changedSlices: EMPTY };
+            }
+            const filters = { ...state.filters, [intent.id]: intent.clause };
+            return { state: { ...state, filters }, changedSlices: only("filters") };
+        }
+        case "clear-filter": {
+            if (!(intent.id in state.filters))
+                return { state, changedSlices: EMPTY };
+            const filters = { ...state.filters };
+            delete filters[intent.id];
+            return { state: { ...state, filters }, changedSlices: only("filters") };
+        }
+        case "set-spatial-filter": {
+            if (spatialFiltersEqual(state.spatialFilter, intent.spatialFilter)) {
+                return { state, changedSlices: EMPTY };
+            }
+            return {
+                state: cloneWithOptional(state, "spatialFilter", intent.spatialFilter),
+                changedSlices: only("spatialFilter"),
+            };
+        }
+        case "set-extent": {
+            if (extentsEqual(state.extent, intent.extent)) {
+                return { state, changedSlices: EMPTY };
+            }
+            return {
+                state: cloneWithOptional(state, "extent", intent.extent),
+                changedSlices: only("extent"),
+            };
+        }
+        case "select": {
+            const incoming = intent.ids;
+            let selection;
+            if (intent.replace === true) {
+                selection = dedupeSelection(incoming);
+            }
+            else {
+                selection = dedupeSelection([...state.selection, ...incoming]);
+            }
+            if (selectionEqual(state.selection, selection)) {
+                return { state, changedSlices: EMPTY };
+            }
+            return {
+                state: { ...state, selection },
+                changedSlices: only("selection"),
+            };
+        }
+        case "deselect": {
+            if (!intent.ids || intent.ids.length === 0) {
+                if (state.selection.length === 0)
+                    return { state, changedSlices: EMPTY };
+                return { state: { ...state, selection: [] }, changedSlices: only("selection") };
+            }
+            const removeSet = new Set(intent.ids.map((target) => featureSelectionKey(target)));
+            const selection = state.selection.filter((target) => !removeSet.has(featureSelectionKey(target)));
+            if (selection.length === state.selection.length) {
+                return { state, changedSlices: EMPTY };
+            }
+            return { state: { ...state, selection }, changedSlices: only("selection") };
+        }
+        case "set-sort": {
+            if (sortEqual(state.sort, intent.sort))
+                return { state, changedSlices: EMPTY };
+            return { state: { ...state, sort: [...intent.sort] }, changedSlices: only("sort") };
+        }
+        case "set-page": {
+            if (pageEqual(state.page, intent.page))
+                return { state, changedSlices: EMPTY };
+            return { state: { ...state, page: { ...intent.page } }, changedSlices: only("page") };
+        }
+        case "set-visible-fields": {
+            if (sequenceEqual(state.visibleFields, intent.fields)) {
+                return { state, changedSlices: EMPTY };
+            }
+            return {
+                state: { ...state, visibleFields: [...intent.fields] },
+                changedSlices: only("visibleFields"),
+            };
+        }
+        case "set-grouping": {
+            if (sequenceEqual(state.grouping, intent.grouping)) {
+                return { state, changedSlices: EMPTY };
+            }
+            return {
+                state: { ...state, grouping: [...intent.grouping] },
+                changedSlices: only("grouping"),
+            };
+        }
+        case "set-aggregation": {
+            if (aggregationEqual(state.aggregation, intent.aggregation)) {
+                return { state, changedSlices: EMPTY };
+            }
+            return {
+                state: cloneWithOptional(state, "aggregation", intent.aggregation),
+                changedSlices: only("aggregation"),
+            };
+        }
+        case "apply-preset": {
+            if (state.preset === intent.preset)
+                return { state, changedSlices: EMPTY };
+            return { state: { ...state, preset: intent.preset }, changedSlices: only("preset") };
+        }
+        case "snapshot-restore": {
+            const next = intent.snapshot.state;
+            const changed = diffSlices(state, next);
+            if (changed.size === 0)
+                return { state, changedSlices: EMPTY };
+            return { state: next, changedSlices: changed };
+        }
+    }
+}
+const EMPTY = new Set();
+function only(slice) {
+    return new Set([slice]);
+}
+function filterMapsEqual(a, b) {
+    if (a === b)
+        return true;
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length)
+        return false;
+    for (const key of aKeys) {
+        if (!Object.hasOwn(b, key))
+            return false;
+        if (!filtersEqual(a[key], b[key]))
+            return false;
+    }
+    return true;
+}
+function filtersEqual(a, b) {
+    if (a.field !== b.field || a.operator !== b.operator)
+        return false;
+    if (a.value !== b.value) {
+        if (Array.isArray(a.value) && Array.isArray(b.value)) {
+            if (a.value.length !== b.value.length)
+                return false;
+            for (let i = 0; i < a.value.length; i++) {
+                if (a.value[i] !== b.value[i])
+                    return false;
+            }
+        }
+        else {
+            return false;
+        }
+    }
+    if ((a.appliesTo ?? null) !== (b.appliesTo ?? null)) {
+        if (!a.appliesTo || !b.appliesTo)
+            return false;
+        if (!sequenceEqual(a.appliesTo, b.appliesTo))
+            return false;
+    }
+    return true;
+}
+function spatialFiltersEqual(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b)
+        return false;
+    if (a.geometryType !== b.geometryType)
+        return false;
+    if ((a.spatialRel ?? null) !== (b.spatialRel ?? null))
+        return false;
+    return geometryEqual(a.geometry, b.geometry);
+}
+function geometryEqual(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a !== typeof b)
+        return false;
+    if (Array.isArray(a) || Array.isArray(b)) {
+        if (!Array.isArray(a) || !Array.isArray(b))
+            return false;
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++) {
+            if (!geometryEqual(a[i], b[i]))
+                return false;
+        }
+        return true;
+    }
+    if (a && b && typeof a === "object" && typeof b === "object") {
+        const aKeys = Object.keys(a);
+        const bKeys = Object.keys(b);
+        if (aKeys.length !== bKeys.length)
+            return false;
+        for (const key of aKeys) {
+            if (!Object.hasOwn(b, key))
+                return false;
+            if (!geometryEqual(a[key], b[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+function extentsEqual(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b)
+        return false;
+    return a.xmin === b.xmin && a.ymin === b.ymin && a.xmax === b.xmax && a.ymax === b.ymax;
+}
+function sortEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i].field !== b[i].field || (a[i].direction ?? "asc") !== (b[i].direction ?? "asc")) {
+            return false;
+        }
+    }
+    return true;
+}
+function pageEqual(a, b) {
+    return a.offset === b.offset && a.limit === b.limit;
+}
+function sequenceEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}
+function selectionEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (featureSelectionKey(a[i]) !== featureSelectionKey(b[i]))
+            return false;
+    }
+    return true;
+}
+function dedupeSelection(values) {
+    const seen = new Set();
+    const out = [];
+    for (const v of values) {
+        const key = featureSelectionKey(v);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(v);
+    }
+    return out;
+}
+function cloneWithOptional(state, key, value) {
+    // Spread, then either omit or set — keeps the field optional in shape.
+    const { spatialFilter, extent, aggregation, ...rest } = state;
+    const base = {
+        ...rest,
+        ...(spatialFilter !== undefined && key !== "spatialFilter" ? { spatialFilter } : {}),
+        ...(extent !== undefined && key !== "extent" ? { extent } : {}),
+        ...(aggregation !== undefined && key !== "aggregation" ? { aggregation } : {}),
+    };
+    if (value === undefined)
+        return base;
+    return { ...base, [key]: value };
+}
+function diffSlices(prev, next) {
+    const changed = new Set();
+    if (!filterMapsEqual(prev.filters, next.filters))
+        changed.add("filters");
+    if (!spatialFiltersEqual(prev.spatialFilter, next.spatialFilter))
+        changed.add("spatialFilter");
+    if (!extentsEqual(prev.extent, next.extent))
+        changed.add("extent");
+    if (!selectionEqual(prev.selection, next.selection))
+        changed.add("selection");
+    if (!sortEqual(prev.sort, next.sort))
+        changed.add("sort");
+    if (!pageEqual(prev.page, next.page))
+        changed.add("page");
+    if (!sequenceEqual(prev.visibleFields, next.visibleFields))
+        changed.add("visibleFields");
+    if (!sequenceEqual(prev.grouping, next.grouping))
+        changed.add("grouping");
+    if (!aggregationEqual(prev.aggregation, next.aggregation))
+        changed.add("aggregation");
+    if (prev.preset !== next.preset)
+        changed.add("preset");
+    return changed;
+}
+function aggregationEqual(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b)
+        return false;
+    const aGroup = a.groupBy ?? [];
+    const bGroup = b.groupBy ?? [];
+    if (!sequenceEqual(aGroup, bGroup))
+        return false;
+    if (a.metrics.length !== b.metrics.length)
+        return false;
+    for (let i = 0; i < a.metrics.length; i++) {
+        const am = a.metrics[i];
+        const bm = b.metrics[i];
+        if (am.fn !== bm.fn || am.field !== bm.field || (am.alias ?? null) !== (bm.alias ?? null)) {
+            return false;
+        }
+    }
+    return true;
+}

package/exploration/selection.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Selection target helpers for exploration state.
+ *
+ * Raw feature ids remain valid for single-source apps. Multi-source apps
+ * should use source-qualified targets so the same object id in two sources
+ * does not collide in map/table/detail synchronization.
+ *
+ * @module
+ */
+import type { FeatureId, SourceId } from "../contract/types.js";
+import type { FeatureSelectionTarget, SourceQualifiedFeatureSelectionTarget } from "./types.js";
+/** Build a serializable source-qualified selection target. */
+export declare function sourceFeatureSelectionTarget(sourceId: SourceId, id: FeatureId, options?: {
+    readonly sourceLayer?: string;
+}): SourceQualifiedFeatureSelectionTarget;
+/** True when a selection target carries source identity. */
+export declare function isSourceQualifiedSelectionTarget(target: FeatureSelectionTarget): target is SourceQualifiedFeatureSelectionTarget;
+/**
+ * Stable key for de-duplicating and comparing selection targets.
+ *
+ * The key intentionally includes raw-id type and source layer so `"101"`,
+ * `101`, and vector-tile sublayer features remain distinct.
+ */
+export declare function featureSelectionKey(target: FeatureSelectionTarget): string;
+//# sourceMappingURL=selection.d.ts.map

package/exploration/selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../../src/exploration/selection.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,KAAK,EAAE,sBAAsB,EAAE,qCAAqC,EAAE,MAAM,YAAY,CAAC;AAEhG,8DAA8D;AAC9D,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,QAAQ,EAClB,EAAE,EAAE,SAAS,EACb,OAAO,GAAE;IAAE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAO,GAC9C,qCAAqC,CAMvC;AAED,4DAA4D;AAC5D,wBAAgB,gCAAgC,CAC9C,MAAM,EAAE,sBAAsB,GAC7B,MAAM,IAAI,qCAAqC,CAEjD;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,sBAAsB,GAAG,MAAM,CAM1E"}

package/exploration/selection.js

@@ -0,0 +1,34 @@
+/**
+ * Selection target helpers for exploration state.
+ *
+ * Raw feature ids remain valid for single-source apps. Multi-source apps
+ * should use source-qualified targets so the same object id in two sources
+ * does not collide in map/table/detail synchronization.
+ *
+ * @module
+ */
+/** Build a serializable source-qualified selection target. */
+export function sourceFeatureSelectionTarget(sourceId, id, options = {}) {
+    return {
+        sourceId,
+        id,
+        ...(options.sourceLayer !== undefined ? { sourceLayer: options.sourceLayer } : {}),
+    };
+}
+/** True when a selection target carries source identity. */
+export function isSourceQualifiedSelectionTarget(target) {
+    return typeof target === "object" && target !== null && "sourceId" in target && "id" in target;
+}
+/**
+ * Stable key for de-duplicating and comparing selection targets.
+ *
+ * The key intentionally includes raw-id type and source layer so `"101"`,
+ * `101`, and vector-tile sublayer features remain distinct.
+ */
+export function featureSelectionKey(target) {
+    if (!isSourceQualifiedSelectionTarget(target)) {
+        return `id:${typeof target}:${String(target)}`;
+    }
+    const layer = target.sourceLayer ?? "";
+    return `source:${target.sourceId}\u0000layer:${layer}\u0000id:${typeof target.id}:${String(target.id)}`;
+}

package/exploration/selectors.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Selector helpers for linked exploration views.
+ *
+ * The selectors are framework-neutral: UI adapters subscribe to narrow
+ * exploration slices and render derived models instead of synchronizing peer
+ * components directly.
+ *
+ * @module
+ */
+import type { AggregationSpec, PaginationSpec, SortSpec, SourceId } from "../contract/types.js";
+import { type SpatialFilter } from "../core/spatial-filter.js";
+import type { HonuaExtent } from "../core/types.js";
+import type { ExplorationState, ExplorationViewChangeEvent, ExplorationViewController, ExplorationViewSubscribeOptions, ExplorationViewSubscription, FeatureSelectionTarget, FilterClause, Unsubscribe } from "./types.js";
+export type LinkedViewSpatialMode = "none" | "state" | "extent" | "state-or-extent";
+export interface LinkedViewQueryProjectionOptions {
+    /** Restrict filters whose `appliesTo` list names another source. */
+    readonly sourceId?: SourceId;
+    /** How spatial state should be projected into query inputs. @default "state-or-extent" */
+    readonly spatialMode?: LinkedViewSpatialMode;
+}
+/**
+ * Serializable query-facing view of exploration state.
+ *
+ * Protocol adapters can translate `filters` into SQL, CQL2, OData, or
+ * MapLibre expressions while reusing the same spatial, sorting, paging,
+ * grouping, and selection state.
+ */
+export interface LinkedViewQueryProjection {
+    readonly filters: Readonly<Record<string, FilterClause>>;
+    readonly spatialFilter?: SpatialFilter;
+    readonly extent?: HonuaExtent;
+    readonly orderBy: ReadonlyArray<SortSpec>;
+    readonly pagination: PaginationSpec;
+    readonly outFields?: ReadonlyArray<string>;
+    readonly grouping: ReadonlyArray<string>;
+    readonly aggregation?: AggregationSpec;
+    readonly selection: ReadonlyArray<FeatureSelectionTarget>;
+}
+export type ExplorationSelector<T> = (state: ExplorationState) => T;
+export type ExplorationSelectorListener<T> = (value: T, event: ExplorationViewChangeEvent | undefined) => void;
+export interface ExplorationSelectorSubscribeOptions<T> extends ExplorationViewSubscribeOptions {
+    /** Emit the selector's current value before waiting for changes. @default false */
+    readonly fireImmediately?: boolean;
+    /** Equality check used to suppress unchanged selector output. @default deep value equality */
+    readonly equals?: (a: T, b: T) => boolean;
+}
+/** Convert a viewport extent into the standard Honua envelope spatial filter. */
+export declare function extentToSpatialFilter(extent: HonuaExtent): SpatialFilter;
+/** Derive a query-facing projection from the current linked exploration state. */
+export declare function selectLinkedViewQueryProjection(state: ExplorationState, options?: LinkedViewQueryProjectionOptions): LinkedViewQueryProjection;
+/**
+ * Subscribe to a narrow state subscription and emit only when a derived
+ * selector value changes.
+ */
+export declare function subscribeExplorationSelector<T>(view: ExplorationViewController, subscription: ExplorationViewSubscription, selector: ExplorationSelector<T>, listener: ExplorationSelectorListener<T>, options?: ExplorationSelectorSubscribeOptions<T>): Unsubscribe;
+//# sourceMappingURL=selectors.d.ts.map

package/exploration/selectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.d.ts","sourceRoot":"","sources":["../../../src/exploration/selectors.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChG,OAAO,EAAE,KAAK,aAAa,EAAY,MAAM,2BAA2B,CAAC;AACzE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EACV,gBAAgB,EAChB,0BAA0B,EAC1B,yBAAyB,EACzB,+BAA+B,EAC/B,2BAA2B,EAC3B,sBAAsB,EACtB,YAAY,EACZ,WAAW,EACZ,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,iBAAiB,CAAC;AAEpF,MAAM,WAAW,gCAAgC;IAC/C,oEAAoE;IACpE,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAC7B,0FAA0F;IAC1F,QAAQ,CAAC,WAAW,CAAC,EAAE,qBAAqB,CAAC;CAC9C;AAED;;;;;;GAMG;AACH,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC;IACzD,QAAQ,CAAC,aAAa,CAAC,EAAE,aAAa,CAAC;IACvC,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC;IAC1C,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC,QAAQ,CAAC,SAAS,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC3C,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACzC,QAAQ,CAAC,WAAW,CAAC,EAAE,eAAe,CAAC;IACvC,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC,sBAAsB,CAAC,CAAC;CAC3D;AAED,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,gBAAgB,KAAK,CAAC,CAAC;AACpE,MAAM,MAAM,2BAA2B,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,0BAA0B,GAAG,SAAS,KAAK,IAAI,CAAC;AAE/G,MAAM,WAAW,mCAAmC,CAAC,CAAC,CAAE,SAAQ,+BAA+B;IAC7F,mFAAmF;IACnF,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;IACnC,8FAA8F;IAC9F,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;CAC3C;AAED,iFAAiF;AACjF,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,WAAW,GAAG,aAAa,CAExE;AAED,kFAAkF;AAClF,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,gBAAgB,EACvB,OAAO,GAAE,gCAAqC,GAC7C,yBAAyB,CAa3B;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,CAAC,EAC5C,IAAI,EAAE,yBAAyB,EAC/B,YAAY,EAAE,2BAA2B,EACzC,QAAQ,EAAE,mBAAmB,CAAC,CAAC,CAAC,EAChC,QAAQ,EAAE,2BAA2B,CAAC,CAAC,CAAC,EACxC,OAAO,GAAE,mCAAmC,CAAC,CAAC,CAAM,GACnD,WAAW,CAkBb"}

package/exploration/selectors.js

@@ -0,0 +1,110 @@
+/**
+ * Selector helpers for linked exploration views.
+ *
+ * The selectors are framework-neutral: UI adapters subscribe to narrow
+ * exploration slices and render derived models instead of synchronizing peer
+ * components directly.
+ *
+ * @module
+ */
+import { envelope } from "../core/spatial-filter.js";
+/** Convert a viewport extent into the standard Honua envelope spatial filter. */
+export function extentToSpatialFilter(extent) {
+    return envelope(extent.xmin, extent.ymin, extent.xmax, extent.ymax, extent.spatialReference);
+}
+/** Derive a query-facing projection from the current linked exploration state. */
+export function selectLinkedViewQueryProjection(state, options = {}) {
+    const visibleFields = state.visibleFields.length > 0 ? [...state.visibleFields] : undefined;
+    return {
+        filters: filtersForSource(state.filters, options.sourceId),
+        spatialFilter: spatialFilterForState(state, options.spatialMode ?? "state-or-extent"),
+        extent: state.extent,
+        orderBy: [...state.sort],
+        pagination: { ...state.page },
+        outFields: visibleFields,
+        grouping: [...state.grouping],
+        aggregation: state.aggregation,
+        selection: [...state.selection],
+    };
+}
+/**
+ * Subscribe to a narrow state subscription and emit only when a derived
+ * selector value changes.
+ */
+export function subscribeExplorationSelector(view, subscription, selector, listener, options = {}) {
+    const equals = options.equals ?? valuesEqual;
+    let current = selector(view.state);
+    if (options.fireImmediately) {
+        listener(current, undefined);
+    }
+    return view.subscribe(subscription, (event) => {
+        const next = selector(event.state);
+        if (equals(current, next))
+            return;
+        current = next;
+        listener(next, event);
+    }, options);
+}
+function spatialFilterForState(state, mode) {
+    switch (mode) {
+        case "none":
+            return undefined;
+        case "state":
+            return state.spatialFilter;
+        case "extent":
+            return state.extent ? extentToSpatialFilter(state.extent) : undefined;
+        case "state-or-extent":
+            return state.spatialFilter ?? (state.extent ? extentToSpatialFilter(state.extent) : undefined);
+    }
+}
+function filtersForSource(filters, sourceId) {
+    if (!sourceId)
+        return filters;
+    const out = {};
+    for (const [id, clause] of Object.entries(filters)) {
+        if (!clause.appliesTo || clause.appliesTo.length === 0 || clause.appliesTo.includes(sourceId)) {
+            out[id] = clause;
+        }
+    }
+    return out;
+}
+function valuesEqual(a, b) {
+    if (Object.is(a, b))
+        return true;
+    if (!a || !b || typeof a !== "object" || typeof b !== "object")
+        return false;
+    if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))
+        return false;
+    if (a instanceof Date && b instanceof Date) {
+        return a.getTime() === b.getTime();
+    }
+    if (a instanceof RegExp && b instanceof RegExp) {
+        return a.source === b.source && a.flags === b.flags;
+    }
+    if (Array.isArray(a) || Array.isArray(b)) {
+        if (!Array.isArray(a) || !Array.isArray(b))
+            return false;
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++) {
+            if (!valuesEqual(a[i], b[i]))
+                return false;
+        }
+        return true;
+    }
+    const left = a;
+    const right = b;
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    if (leftKeys.length !== rightKeys.length)
+        return false;
+    if (leftKeys.length === 0)
+        return false;
+    for (const key of leftKeys) {
+        if (!Object.hasOwn(right, key))
+            return false;
+        if (!valuesEqual(left[key], right[key]))
+            return false;
+    }
+    return true;
+}