@sqlrooms/deck 0.29.0-rc.10

package/dist/DeckJsonMapSpec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeckJsonMapSpec.d.ts","sourceRoot":"","sources":["../src/DeckJsonMapSpec.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,eAAO,MAAM,oBAAoB;;;;EAAqC,CAAC;AACvE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAExE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAK9B,CAAC;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;iBAQ7B,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;iBAE5B,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAiBlE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmC/B,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAOxE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAO1B,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/dist/DeckJsonMapSpec.js

@@ -0,0 +1,82 @@
+import { ColorScaleConfig, RGBAColor } from '@sqlrooms/color-scales';
+import { z } from 'zod';
+export const GeometryEncodingHint = z.enum(['geoarrow', 'wkb', 'wkt']);
+export const ColorScaleFunction = z.intersection(z.object({
+    '@@function': z.literal('colorScale'),
+}), ColorScaleConfig);
+export const LayerBindingConfig = z.object({
+    dataset: z.string().min(1).optional(),
+    geometryColumn: z.string().min(1).optional(),
+    geometryEncodingHint: GeometryEncodingHint.optional(),
+    sourceGeometryColumn: z.string().min(1).optional(),
+    targetGeometryColumn: z.string().min(1).optional(),
+    timestampColumn: z.string().min(1).optional(),
+    hexagonColumn: z.string().min(1).optional(),
+});
+export const LayerBindingProps = z.object({
+    _sqlroomsBinding: LayerBindingConfig.optional(),
+});
+const JsonAccessor = z.union([
+    z.string(),
+    z.number(),
+    RGBAColor,
+    z.array(z.number()),
+    ColorScaleFunction,
+    z.record(z.string(), z.unknown()),
+]);
+// Keep the layer spec loose for now because `DeckJsonMap` accepts deck.gl JSON as an
+// external spec format, and that surface is much broader than SQLRooms-owned
+// `_sqlroomsBinding` extensions. We validate the binding config fully and a handful of
+// common deck props we know we rely on, while allowing the rest through.
+// TODO(deck-json-schema): Replace this with fuller schemas when deck.gl/json
+// exposes reusable validators or we decide to maintain a broader local schema.
+export const DeckJsonMapLayerSpec = z.looseObject({
+    '@@type': z.string().optional(),
+    id: z.string().optional(),
+    data: z.unknown().optional(),
+    visible: z.boolean().optional(),
+    pickable: z.boolean().optional(),
+    filled: z.boolean().optional(),
+    stroked: z.boolean().optional(),
+    extruded: z.boolean().optional(),
+    radiusScale: z.number().optional(),
+    radiusUnits: z.string().optional(),
+    radiusMinPixels: z.number().optional(),
+    radiusMaxPixels: z.number().optional(),
+    lineWidthMinPixels: z.number().optional(),
+    lineWidthScale: z.number().optional(),
+    lineWidthUnits: z.string().optional(),
+    getRadius: JsonAccessor.optional(),
+    getFillColor: JsonAccessor.optional(),
+    getLineColor: JsonAccessor.optional(),
+    getColor: JsonAccessor.optional(),
+    getWeight: JsonAccessor.optional(),
+    getWidth: JsonAccessor.optional(),
+    getHeight: JsonAccessor.optional(),
+    getTilt: JsonAccessor.optional(),
+    getElevation: JsonAccessor.optional(),
+    getSourceColor: JsonAccessor.optional(),
+    getTargetColor: JsonAccessor.optional(),
+    getPosition: JsonAccessor.optional(),
+    getSourcePosition: JsonAccessor.optional(),
+    getTargetPosition: JsonAccessor.optional(),
+    getPolygon: JsonAccessor.optional(),
+    getPath: JsonAccessor.optional(),
+    getHexagon: JsonAccessor.optional(),
+    getTimestamps: JsonAccessor.optional(),
+    _sqlroomsBinding: LayerBindingConfig.optional(),
+});
+// Keep the top-level spec loose for the same reason as `DeckJsonMapLayerSpec`: deck.gl
+// JSON supports many runtime-level props, and SQLRooms currently only needs a
+// validated subset plus open-ended compatibility with upstream deck specs.
+// TODO(deck-json-schema): Replace this with fuller schemas when we have a more
+// complete upstream or local model of deck.gl/json top-level props.
+export const DeckJsonMapSpec = z.looseObject({
+    initialViewState: z.record(z.string(), z.unknown()).optional(),
+    viewState: z.record(z.string(), z.unknown()).optional(),
+    controller: z
+        .union([z.boolean(), z.record(z.string(), z.unknown())])
+        .optional(),
+    layers: z.array(DeckJsonMapLayerSpec).optional(),
+});
+//# sourceMappingURL=DeckJsonMapSpec.js.map

package/dist/DeckJsonMapSpec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeckJsonMapSpec.js","sourceRoot":"","sources":["../src/DeckJsonMapSpec.ts"],"names":[],"mappings":"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","sourcesContent":["import {ColorScaleConfig, RGBAColor} from '@sqlrooms/color-scales';\nimport {z} from 'zod';\n\nexport const GeometryEncodingHint = z.enum(['geoarrow', 'wkb', 'wkt']);\nexport type GeometryEncodingHint = z.infer<typeof GeometryEncodingHint>;\n\nexport const ColorScaleFunction = z.intersection(\n  z.object({\n    '@@function': z.literal('colorScale'),\n  }),\n  ColorScaleConfig,\n);\nexport type ColorScaleFunction = z.infer<typeof ColorScaleFunction>;\n\nexport const LayerBindingConfig = z.object({\n  dataset: z.string().min(1).optional(),\n  geometryColumn: z.string().min(1).optional(),\n  geometryEncodingHint: GeometryEncodingHint.optional(),\n  sourceGeometryColumn: z.string().min(1).optional(),\n  targetGeometryColumn: z.string().min(1).optional(),\n  timestampColumn: z.string().min(1).optional(),\n  hexagonColumn: z.string().min(1).optional(),\n});\nexport type LayerBindingConfig = z.infer<typeof LayerBindingConfig>;\n\nexport const LayerBindingProps = z.object({\n  _sqlroomsBinding: LayerBindingConfig.optional(),\n});\nexport type LayerBindingProps = z.infer<typeof LayerBindingProps>;\n\nconst JsonAccessor = z.union([\n  z.string(),\n  z.number(),\n  RGBAColor,\n  z.array(z.number()),\n  ColorScaleFunction,\n  z.record(z.string(), z.unknown()),\n]);\n\n// Keep the layer spec loose for now because `DeckJsonMap` accepts deck.gl JSON as an\n// external spec format, and that surface is much broader than SQLRooms-owned\n// `_sqlroomsBinding` extensions. We validate the binding config fully and a handful of\n// common deck props we know we rely on, while allowing the rest through.\n// TODO(deck-json-schema): Replace this with fuller schemas when deck.gl/json\n// exposes reusable validators or we decide to maintain a broader local schema.\nexport const DeckJsonMapLayerSpec = z.looseObject({\n  '@@type': z.string().optional(),\n  id: z.string().optional(),\n  data: z.unknown().optional(),\n  visible: z.boolean().optional(),\n  pickable: z.boolean().optional(),\n  filled: z.boolean().optional(),\n  stroked: z.boolean().optional(),\n  extruded: z.boolean().optional(),\n  radiusScale: z.number().optional(),\n  radiusUnits: z.string().optional(),\n  radiusMinPixels: z.number().optional(),\n  radiusMaxPixels: z.number().optional(),\n  lineWidthMinPixels: z.number().optional(),\n  lineWidthScale: z.number().optional(),\n  lineWidthUnits: z.string().optional(),\n  getRadius: JsonAccessor.optional(),\n  getFillColor: JsonAccessor.optional(),\n  getLineColor: JsonAccessor.optional(),\n  getColor: JsonAccessor.optional(),\n  getWeight: JsonAccessor.optional(),\n  getWidth: JsonAccessor.optional(),\n  getHeight: JsonAccessor.optional(),\n  getTilt: JsonAccessor.optional(),\n  getElevation: JsonAccessor.optional(),\n  getSourceColor: JsonAccessor.optional(),\n  getTargetColor: JsonAccessor.optional(),\n  getPosition: JsonAccessor.optional(),\n  getSourcePosition: JsonAccessor.optional(),\n  getTargetPosition: JsonAccessor.optional(),\n  getPolygon: JsonAccessor.optional(),\n  getPath: JsonAccessor.optional(),\n  getHexagon: JsonAccessor.optional(),\n  getTimestamps: JsonAccessor.optional(),\n  _sqlroomsBinding: LayerBindingConfig.optional(),\n});\nexport type DeckJsonMapLayerSpec = z.infer<typeof DeckJsonMapLayerSpec>;\n\n// Keep the top-level spec loose for the same reason as `DeckJsonMapLayerSpec`: deck.gl\n// JSON supports many runtime-level props, and SQLRooms currently only needs a\n// validated subset plus open-ended compatibility with upstream deck specs.\n// TODO(deck-json-schema): Replace this with fuller schemas when we have a more\n// complete upstream or local model of deck.gl/json top-level props.\nexport const DeckJsonMapSpec = z.looseObject({\n  initialViewState: z.record(z.string(), z.unknown()).optional(),\n  viewState: z.record(z.string(), z.unknown()).optional(),\n  controller: z\n    .union([z.boolean(), z.record(z.string(), z.unknown())])\n    .optional(),\n  layers: z.array(DeckJsonMapLayerSpec).optional(),\n});\nexport type DeckJsonMapSpec = z.infer<typeof DeckJsonMapSpec>;\n"]}

package/dist/DeckMapDefaultStylesProvider.d.ts

@@ -0,0 +1,28 @@
+import type { ResolvedTheme } from '@sqlrooms/ui';
+import type { MapProps } from 'react-map-gl/maplibre';
+import { type FC, type PropsWithChildren } from 'react';
+/** A MapLibre-compatible style accepted by the Deck map renderer. */
+export type DeckMapStyle = NonNullable<MapProps['mapStyle']>;
+/** Optional host-provided basemap defaults keyed by resolved UI theme. */
+export type DeckMapDefaultStyles = Partial<Record<ResolvedTheme, DeckMapStyle>>;
+/**
+ * Supplies host-owned, theme-aware basemap defaults without persisting them in
+ * individual map resources. Explicit map config styles still take precedence.
+ */
+export declare const DeckMapDefaultStylesProvider: FC<PropsWithChildren<{
+    styles: DeckMapDefaultStyles;
+}>>;
+/** Returns theme-aware host map defaults from the nearest provider, if any. */
+export declare function useDeckMapDefaultStyles(): Partial<Record<ResolvedTheme, DeckMapStyle>> | undefined;
+/**
+ * Resolves the effective map style from explicit config, map props, host
+ * defaults, and finally the package fallback for the active theme.
+ */
+export declare function resolveDeckMapStyle(options: {
+    mapStyle?: string;
+    mapPropsMapStyle?: MapProps['mapStyle'];
+    hostDefaultStyles?: DeckMapDefaultStyles;
+    resolvedTheme: ResolvedTheme;
+    fallbackStyles: Record<ResolvedTheme, string>;
+}): DeckMapStyle;
+//# sourceMappingURL=DeckMapDefaultStylesProvider.d.ts.map

package/dist/DeckMapDefaultStylesProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeckMapDefaultStylesProvider.d.ts","sourceRoot":"","sources":["../src/DeckMapDefaultStylesProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,cAAc,CAAC;AAChD,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAGL,KAAK,EAAE,EACP,KAAK,iBAAiB,EACvB,MAAM,OAAO,CAAC;AAEf,qEAAqE;AACrE,MAAM,MAAM,YAAY,GAAG,WAAW,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC;AAE7D,0EAA0E;AAC1E,MAAM,MAAM,oBAAoB,GAAG,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,YAAY,CAAC,CAAC,CAAC;AAMhF;;;GAGG;AACH,eAAO,MAAM,4BAA4B,EAAE,EAAE,CAC3C,iBAAiB,CAAC;IAAC,MAAM,EAAE,oBAAoB,CAAA;CAAC,CAAC,CAKlD,CAAC;AAEF,+EAA+E;AAC/E,wBAAgB,uBAAuB,6DAEtC;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gBAAgB,CAAC,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC;IACxC,iBAAiB,CAAC,EAAE,oBAAoB,CAAC;IACzC,aAAa,EAAE,aAAa,CAAC;IAC7B,cAAc,EAAE,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;CAC/C,GAAG,YAAY,CAOf"}

package/dist/DeckMapDefaultStylesProvider.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, } from 'react';
+const DeckMapDefaultStylesContext = createContext(undefined);
+/**
+ * Supplies host-owned, theme-aware basemap defaults without persisting them in
+ * individual map resources. Explicit map config styles still take precedence.
+ */
+export const DeckMapDefaultStylesProvider = ({ styles, children }) => (_jsx(DeckMapDefaultStylesContext.Provider, { value: styles, children: children }));
+/** Returns theme-aware host map defaults from the nearest provider, if any. */
+export function useDeckMapDefaultStyles() {
+    return useContext(DeckMapDefaultStylesContext);
+}
+/**
+ * Resolves the effective map style from explicit config, map props, host
+ * defaults, and finally the package fallback for the active theme.
+ */
+export function resolveDeckMapStyle(options) {
+    return (options.mapStyle ??
+        options.mapPropsMapStyle ??
+        options.hostDefaultStyles?.[options.resolvedTheme] ??
+        options.fallbackStyles[options.resolvedTheme]);
+}
+//# sourceMappingURL=DeckMapDefaultStylesProvider.js.map

package/dist/DeckMapDefaultStylesProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeckMapDefaultStylesProvider.js","sourceRoot":"","sources":["../src/DeckMapDefaultStylesProvider.tsx"],"names":[],"mappings":";AAEA,OAAO,EACL,aAAa,EACb,UAAU,GAGX,MAAM,OAAO,CAAC;AAQf,MAAM,2BAA2B,GAAG,aAAa,CAE/C,SAAS,CAAC,CAAC;AAEb;;;GAGG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAErC,CAAC,EAAC,MAAM,EAAE,QAAQ,EAAC,EAAE,EAAE,CAAC,CAC1B,KAAC,2BAA2B,CAAC,QAAQ,IAAC,KAAK,EAAE,MAAM,YAChD,QAAQ,GAC4B,CACxC,CAAC;AAEF,+EAA+E;AAC/E,MAAM,UAAU,uBAAuB;IACrC,OAAO,UAAU,CAAC,2BAA2B,CAAC,CAAC;AACjD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,mBAAmB,CAAC,OAMnC;IACC,OAAO,CACL,OAAO,CAAC,QAAQ;QAChB,OAAO,CAAC,gBAAgB;QACxB,OAAO,CAAC,iBAAiB,EAAE,CAAC,OAAO,CAAC,aAAa,CAAC;QAClD,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC,aAAa,CAAC,CAC9C,CAAC;AACJ,CAAC","sourcesContent":["import type {ResolvedTheme} from '@sqlrooms/ui';\nimport type {MapProps} from 'react-map-gl/maplibre';\nimport {\n  createContext,\n  useContext,\n  type FC,\n  type PropsWithChildren,\n} from 'react';\n\n/** A MapLibre-compatible style accepted by the Deck map renderer. */\nexport type DeckMapStyle = NonNullable<MapProps['mapStyle']>;\n\n/** Optional host-provided basemap defaults keyed by resolved UI theme. */\nexport type DeckMapDefaultStyles = Partial<Record<ResolvedTheme, DeckMapStyle>>;\n\nconst DeckMapDefaultStylesContext = createContext<\n  DeckMapDefaultStyles | undefined\n>(undefined);\n\n/**\n * Supplies host-owned, theme-aware basemap defaults without persisting them in\n * individual map resources. Explicit map config styles still take precedence.\n */\nexport const DeckMapDefaultStylesProvider: FC<\n  PropsWithChildren<{styles: DeckMapDefaultStyles}>\n> = ({styles, children}) => (\n  <DeckMapDefaultStylesContext.Provider value={styles}>\n    {children}\n  </DeckMapDefaultStylesContext.Provider>\n);\n\n/** Returns theme-aware host map defaults from the nearest provider, if any. */\nexport function useDeckMapDefaultStyles() {\n  return useContext(DeckMapDefaultStylesContext);\n}\n\n/**\n * Resolves the effective map style from explicit config, map props, host\n * defaults, and finally the package fallback for the active theme.\n */\nexport function resolveDeckMapStyle(options: {\n  mapStyle?: string;\n  mapPropsMapStyle?: MapProps['mapStyle'];\n  hostDefaultStyles?: DeckMapDefaultStyles;\n  resolvedTheme: ResolvedTheme;\n  fallbackStyles: Record<ResolvedTheme, string>;\n}): DeckMapStyle {\n  return (\n    options.mapStyle ??\n    options.mapPropsMapStyle ??\n    options.hostDefaultStyles?.[options.resolvedTheme] ??\n    options.fallbackStyles[options.resolvedTheme]\n  );\n}\n"]}

package/dist/DeckMapSurface.d.ts

@@ -0,0 +1,39 @@
+import type { DataTable } from '@sqlrooms/duckdb';
+import { type ReactNode } from 'react';
+import type { DeckMapResource, DeckMapRuntimeIssue } from './DeckMapsSlice';
+import type { DeckDatasetInput } from './types';
+/**
+ * Host-neutral data boundary for Deck map resources. Worksheet maps use the
+ * direct adapter below and are intentionally independent: no Mosaic selection
+ * or cross-filter state is read or published.
+ */
+export type DeckMapDataAdapter = {
+    resolveDatasets: (options: {
+        mapId: string;
+        map: DeckMapResource;
+    }) => Record<string, DeckDatasetInput>;
+    /** Resolves an unsampled dataset input for fit-to-data bounds queries. */
+    resolveFitDataset?: (options: {
+        mapId: string;
+        map: DeckMapResource;
+        datasetId: string;
+    }) => DeckDatasetInput | undefined;
+    getTableColumns?: (tableName: string) => DataTable['columns'] | undefined;
+};
+export declare const directDeckMapDataAdapter: DeckMapDataAdapter;
+export type DeckMapSurfaceProps = {
+    mapId: string;
+    map: DeckMapResource;
+    readOnly?: boolean;
+    selected?: boolean;
+    caption?: string;
+    headerActions?: ReactNode;
+    fitRequestVersion?: number;
+    onUpdateMap: (patch: Partial<DeckMapResource>) => void;
+    onReportIssue: (issue: Omit<DeckMapRuntimeIssue, 'mapId'>) => void;
+    /** Clears the current issue when its kind matches, or all issues when omitted. */
+    onClearIssue: (kind?: DeckMapRuntimeIssue['kind']) => void;
+    dataAdapter?: DeckMapDataAdapter;
+};
+export declare function DeckMapSurface({ mapId, map, onReportIssue, onClearIssue, fitRequestVersion, dataAdapter, }: DeckMapSurfaceProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=DeckMapSurface.d.ts.map

package/dist/DeckMapSurface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeckMapSurface.d.ts","sourceRoot":"","sources":["../src/DeckMapSurface.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAML,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AAEf,OAAO,KAAK,EAAC,eAAe,EAAE,mBAAmB,EAAC,MAAM,iBAAiB,CAAC;AAa1E,OAAO,KAAK,EACV,gBAAgB,EAGjB,MAAM,SAAS,CAAC;AA6BjB;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,eAAe,EAAE,CAAC,OAAO,EAAE;QACzB,KAAK,EAAE,MAAM,CAAC;QACd,GAAG,EAAE,eAAe,CAAC;KACtB,KAAK,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IACvC,0EAA0E;IAC1E,iBAAiB,CAAC,EAAE,CAAC,OAAO,EAAE;QAC5B,KAAK,EAAE,MAAM,CAAC;QACd,GAAG,EAAE,eAAe,CAAC;QACrB,SAAS,EAAE,MAAM,CAAC;KACnB,KAAK,gBAAgB,GAAG,SAAS,CAAC;IACnC,eAAe,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,SAAS,CAAC,SAAS,CAAC,GAAG,SAAS,CAAC;CAC3E,CAAC;AAoCF,eAAO,MAAM,wBAAwB,EAAE,kBAKtC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,eAAe,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,SAAS,CAAC;IAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,WAAW,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,eAAe,CAAC,KAAK,IAAI,CAAC;IACvD,aAAa,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,mBAAmB,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IACnE,kFAAkF;IAClF,YAAY,EAAE,CAAC,IAAI,CAAC,EAAE,mBAAmB,CAAC,MAAM,CAAC,KAAK,IAAI,CAAC;IAC3D,WAAW,CAAC,EAAE,kBAAkB,CAAC;CAClC,CAAC;AAEF,wBAAgB,cAAc,CAAC,EAC7B,KAAK,EACL,GAAG,EACH,aAAa,EACb,YAAY,EACZ,iBAAqB,EACrB,WAAsC,GACvC,EAAE,mBAAmB,2CA4HrB"}

package/dist/DeckMapSurface.js

@@ -0,0 +1,137 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useRef, useState, } from 'react';
+import { DeckJsonMap } from './DeckJsonMap';
+import { DECK_TABLE_DATASET_SOURCE_RELATION } from './datasets/tableDatasetSql';
+import { isDeckMapSqlDatasetSource, isDeckMapTableDatasetSource, } from './mapConfig';
+import { getDeckMapDataPolicy } from './mapDataPolicy';
+import { getDeckMapResourceConfigIssues } from './mapResourceAuthoring';
+import { getDeckMapDatasetSource, resolveDeckMapFitToData, useDeckMapFitController, } from './mapFit';
+function sampleDatasetSql(sql, maxRows) {
+    const sourceSql = sql.trim().replace(/(?:\s*;+\s*)+$/, '');
+    return `SELECT * FROM (${sourceSql}) USING SAMPLE ${maxRows} ROWS`;
+}
+function applyDataPolicy(input, policy) {
+    if (policy.disabled)
+        return input;
+    const maxRows = Math.max(1, Math.floor(policy.maxRows));
+    if ('sqlQuery' in input) {
+        return { ...input, sqlQuery: sampleDatasetSql(input.sqlQuery, maxRows) };
+    }
+    if ('tableName' in input) {
+        return {
+            ...input,
+            transformSql: sampleDatasetSql(input.transformSql ??
+                `SELECT * FROM ${DECK_TABLE_DATASET_SOURCE_RELATION}`, maxRows),
+        };
+    }
+    return input;
+}
+function resolveDirectDeckMapDatasets(map, dataPolicy) {
+    const resolved = {};
+    // A top-level selected table is only an unambiguous override when the map
+    // has one table-backed dataset. Multi-source maps retain authored tables.
+    const tableDatasetCount = Object.values(map.config.datasets).filter((dataset) => isDeckMapTableDatasetSource(dataset.source)).length;
+    for (const [datasetId, dataset] of Object.entries(map.config.datasets)) {
+        const { source, ...datasetConfig } = dataset;
+        let input;
+        if (isDeckMapSqlDatasetSource(source)) {
+            input = { ...datasetConfig, sqlQuery: source.sqlQuery };
+        }
+        else if (isDeckMapTableDatasetSource(source)) {
+            input = {
+                ...datasetConfig,
+                tableName: tableDatasetCount === 1
+                    ? (map.selectedTable ?? source.tableName)
+                    : source.tableName,
+                transformSql: source.transformSql,
+            };
+        }
+        if (input) {
+            resolved[datasetId] = dataPolicy
+                ? applyDataPolicy(input, dataPolicy)
+                : input;
+        }
+    }
+    return resolved;
+}
+export const directDeckMapDataAdapter = {
+    resolveDatasets: ({ map }) => resolveDirectDeckMapDatasets(map, getDeckMapDataPolicy(map.config)),
+    resolveFitDataset: ({ map, datasetId }) => resolveDirectDeckMapDatasets(map)[datasetId],
+};
+export function DeckMapSurface({ mapId, map, onReportIssue, onClearIssue, fitRequestVersion = 0, dataAdapter = directDeckMapDataAdapter, }) {
+    const [container, setContainer] = useState(null);
+    const deckMapRef = useRef(null);
+    const datasets = useMemo(() => dataAdapter.resolveDatasets({ mapId, map }), [dataAdapter, map, mapId]);
+    const configIssues = useMemo(() => getDeckMapResourceConfigIssues(map.config, { allowEmpty: true }), [map.config]);
+    useEffect(() => {
+        if (configIssues.length > 0) {
+            onReportIssue({
+                kind: 'config-error',
+                message: `${configIssues[0].path}: ${configIssues[0].message}`,
+                recoverable: true,
+                details: { issues: configIssues },
+            });
+        }
+        else {
+            onClearIssue('config-error');
+        }
+    }, [configIssues, onClearIssue, onReportIssue]);
+    const handleDatasetStates = useCallback((states) => {
+        const failure = Object.values(states).find((state) => state.status === 'error');
+        if (failure) {
+            onReportIssue({
+                kind: 'sql-error',
+                message: failure.error.message,
+                recoverable: true,
+            });
+        }
+        else if (Object.values(states).every((state) => state.status === 'ready')) {
+            onClearIssue('sql-error');
+        }
+    }, [onClearIssue, onReportIssue]);
+    useEffect(() => {
+        if (configIssues.length === 0 && Object.keys(datasets).length === 0) {
+            onClearIssue();
+        }
+    }, [configIssues, datasets, onClearIssue]);
+    const fitToData = useMemo(() => resolveDeckMapFitToData(map.config), [map.config]);
+    const fitSource = useMemo(() => {
+        if (!fitToData)
+            return null;
+        const fitDataset = dataAdapter.resolveFitDataset?.({
+            mapId,
+            map,
+            datasetId: fitToData.dataset,
+        }) ?? datasets[fitToData.dataset];
+        return getDeckMapDatasetSource(fitDataset);
+    }, [dataAdapter, datasets, fitToData, map, mapId]);
+    const handleFitError = useCallback((error) => onReportIssue({
+        kind: 'fit-error',
+        message: error.message,
+        recoverable: true,
+    }), [onReportIssue]);
+    const handleFitSuccess = useCallback(() => onClearIssue('fit-error'), [onClearIssue]);
+    useDeckMapFitController({
+        scopeId: mapId,
+        fitToData,
+        source: fitSource,
+        container,
+        deckMapRef,
+        requestVersion: fitRequestVersion,
+        autoFit: true,
+        onSuccess: handleFitSuccess,
+        onError: handleFitError,
+    });
+    if (configIssues.length > 0) {
+        return (_jsx("div", { className: "text-destructive flex h-full min-h-[320px] items-center justify-center p-4 text-center text-sm", children: `Invalid map configuration: ${configIssues[0].path}: ${configIssues[0].message}` }));
+    }
+    if (Object.keys(datasets).length === 0) {
+        return (_jsx("div", { className: "text-muted-foreground flex h-full min-h-[320px] items-center justify-center p-4 text-center text-sm", children: "Select a geospatial table to configure this map." }));
+    }
+    return (_jsx("div", { ref: setContainer, className: "h-full min-h-[320px]", children: _jsx(DeckJsonMap, { ref: deckMapRef, spec: map.config.spec, datasets: datasets, mapStyle: map.config.mapStyle, mapProps: map.config.mapProps, showLegends: map.config.showLegends, className: "h-full min-h-[320px]", onDatasetStatesChange: handleDatasetStates, onRenderingError: (error) => onReportIssue({
+                kind: 'render-error',
+                message: error.message,
+                recoverable: true,
+            }) }) }));
+}
+//# sourceMappingURL=DeckMapSurface.js.map

package/dist/DeckMapSurface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeckMapSurface.js","sourceRoot":"","sources":["../src/DeckMapSurface.tsx"],"names":[],"mappings":";AACA,OAAO,EACL,WAAW,EACX,SAAS,EACT,OAAO,EACP,MAAM,EACN,QAAQ,GAET,MAAM,OAAO,CAAC;AACf,OAAO,EAAC,WAAW,EAAC,MAAM,eAAe,CAAC;AAE1C,OAAO,EAAC,kCAAkC,EAAC,MAAM,4BAA4B,CAAC;AAC9E,OAAO,EACL,yBAAyB,EACzB,2BAA2B,GAC5B,MAAM,aAAa,CAAC;AACrB,OAAO,EAAC,oBAAoB,EAAyB,MAAM,iBAAiB,CAAC;AAC7E,OAAO,EAAC,8BAA8B,EAAC,MAAM,wBAAwB,CAAC;AACtE,OAAO,EACL,uBAAuB,EACvB,uBAAuB,EACvB,uBAAuB,GACxB,MAAM,UAAU,CAAC;AAOlB,SAAS,gBAAgB,CAAC,GAAW,EAAE,OAAe;IACpD,MAAM,SAAS,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,gBAAgB,EAAE,EAAE,CAAC,CAAC;IAC3D,OAAO,kBAAkB,SAAS,kBAAkB,OAAO,OAAO,CAAC;AACrE,CAAC;AAED,SAAS,eAAe,CACtB,KAAuB,EACvB,MAAyB;IAEzB,IAAI,MAAM,CAAC,QAAQ;QAAE,OAAO,KAAK,CAAC;IAClC,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;IACxD,IAAI,UAAU,IAAI,KAAK,EAAE,CAAC;QACxB,OAAO,EAAC,GAAG,KAAK,EAAE,QAAQ,EAAE,gBAAgB,CAAC,KAAK,CAAC,QAAQ,EAAE,OAAO,CAAC,EAAC,CAAC;IACzE,CAAC;IACD,IAAI,WAAW,IAAI,KAAK,EAAE,CAAC;QACzB,OAAO;YACL,GAAG,KAAK;YACR,YAAY,EAAE,gBAAgB,CAC5B,KAAK,CAAC,YAAY;gBAChB,iBAAiB,kCAAkC,EAAE,EACvD,OAAO,CACR;SACF,CAAC;IACJ,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAqBD,SAAS,4BAA4B,CACnC,GAAoB,EACpB,UAA8B;IAE9B,MAAM,QAAQ,GAAqC,EAAE,CAAC;IACtD,0EAA0E;IAC1E,0EAA0E;IAC1E,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,MAAM,CACjE,CAAC,OAAO,EAAE,EAAE,CAAC,2BAA2B,CAAC,OAAO,CAAC,MAAM,CAAC,CACzD,CAAC,MAAM,CAAC;IACT,KAAK,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;QACvE,MAAM,EAAC,MAAM,EAAE,GAAG,aAAa,EAAC,GAAG,OAAO,CAAC;QAC3C,IAAI,KAAmC,CAAC;QACxC,IAAI,yBAAyB,CAAC,MAAM,CAAC,EAAE,CAAC;YACtC,KAAK,GAAG,EAAC,GAAG,aAAa,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAC,CAAC;QACxD,CAAC;aAAM,IAAI,2BAA2B,CAAC,MAAM,CAAC,EAAE,CAAC;YAC/C,KAAK,GAAG;gBACN,GAAG,aAAa;gBAChB,SAAS,EACP,iBAAiB,KAAK,CAAC;oBACrB,CAAC,CAAC,CAAC,GAAG,CAAC,aAAa,IAAI,MAAM,CAAC,SAAS,CAAC;oBACzC,CAAC,CAAC,MAAM,CAAC,SAAS;gBACtB,YAAY,EAAE,MAAM,CAAC,YAAY;aAClC,CAAC;QACJ,CAAC;QACD,IAAI,KAAK,EAAE,CAAC;YACV,QAAQ,CAAC,SAAS,CAAC,GAAG,UAAU;gBAC9B,CAAC,CAAC,eAAe,CAAC,KAAK,EAAE,UAAU,CAAC;gBACpC,CAAC,CAAC,KAAK,CAAC;QACZ,CAAC;IACH,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,MAAM,CAAC,MAAM,wBAAwB,GAAuB;IAC1D,eAAe,EAAE,CAAC,EAAC,GAAG,EAAC,EAAE,EAAE,CACzB,4BAA4B,CAAC,GAAG,EAAE,oBAAoB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACrE,iBAAiB,EAAE,CAAC,EAAC,GAAG,EAAE,SAAS,EAAC,EAAE,EAAE,CACtC,4BAA4B,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC;CAC/C,CAAC;AAiBF,MAAM,UAAU,cAAc,CAAC,EAC7B,KAAK,EACL,GAAG,EACH,aAAa,EACb,YAAY,EACZ,iBAAiB,GAAG,CAAC,EACrB,WAAW,GAAG,wBAAwB,GAClB;IACpB,MAAM,CAAC,SAAS,EAAE,YAAY,CAAC,GAAG,QAAQ,CAAwB,IAAI,CAAC,CAAC;IACxE,MAAM,UAAU,GAAG,MAAM,CAAoB,IAAI,CAAC,CAAC;IACnD,MAAM,QAAQ,GAAG,OAAO,CACtB,GAAG,EAAE,CAAC,WAAW,CAAC,eAAe,CAAC,EAAC,KAAK,EAAE,GAAG,EAAC,CAAC,EAC/C,CAAC,WAAW,EAAE,GAAG,EAAE,KAAK,CAAC,CAC1B,CAAC;IACF,MAAM,YAAY,GAAG,OAAO,CAC1B,GAAG,EAAE,CAAC,8BAA8B,CAAC,GAAG,CAAC,MAAM,EAAE,EAAC,UAAU,EAAE,IAAI,EAAC,CAAC,EACpE,CAAC,GAAG,CAAC,MAAM,CAAC,CACb,CAAC;IACF,SAAS,CAAC,GAAG,EAAE;QACb,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC5B,aAAa,CAAC;gBACZ,IAAI,EAAE,cAAc;gBACpB,OAAO,EAAE,GAAG,YAAY,CAAC,CAAC,CAAE,CAAC,IAAI,KAAK,YAAY,CAAC,CAAC,CAAE,CAAC,OAAO,EAAE;gBAChE,WAAW,EAAE,IAAI;gBACjB,OAAO,EAAE,EAAC,MAAM,EAAE,YAAY,EAAC;aAChC,CAAC,CAAC;QACL,CAAC;aAAM,CAAC;YACN,YAAY,CAAC,cAAc,CAAC,CAAC;QAC/B,CAAC;IACH,CAAC,EAAE,CAAC,YAAY,EAAE,YAAY,EAAE,aAAa,CAAC,CAAC,CAAC;IAChD,MAAM,mBAAmB,GAAG,WAAW,CACrC,CAAC,MAAgD,EAAE,EAAE;QACnD,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CACxC,CACE,KAAK,EAC0D,EAAE,CACjE,KAAK,CAAC,MAAM,KAAK,OAAO,CAC3B,CAAC;QACF,IAAI,OAAO,EAAE,CAAC;YACZ,aAAa,CAAC;gBACZ,IAAI,EAAE,WAAW;gBACjB,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,OAAO;gBAC9B,WAAW,EAAE,IAAI;aAClB,CAAC,CAAC;QACL,CAAC;aAAM,IACL,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,KAAK,OAAO,CAAC,EAChE,CAAC;YACD,YAAY,CAAC,WAAW,CAAC,CAAC;QAC5B,CAAC;IACH,CAAC,EACD,CAAC,YAAY,EAAE,aAAa,CAAC,CAC9B,CAAC;IACF,SAAS,CAAC,GAAG,EAAE;QACb,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACpE,YAAY,EAAE,CAAC;QACjB,CAAC;IACH,CAAC,EAAE,CAAC,YAAY,EAAE,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC;IAC3C,MAAM,SAAS,GAAG,OAAO,CACvB,GAAG,EAAE,CAAC,uBAAuB,CAAC,GAAG,CAAC,MAAM,CAAC,EACzC,CAAC,GAAG,CAAC,MAAM,CAAC,CACb,CAAC;IACF,MAAM,SAAS,GAAG,OAAO,CAAC,GAAG,EAAE;QAC7B,IAAI,CAAC,SAAS;YAAE,OAAO,IAAI,CAAC;QAC5B,MAAM,UAAU,GACd,WAAW,CAAC,iBAAiB,EAAE,CAAC;YAC9B,KAAK;YACL,GAAG;YACH,SAAS,EAAE,SAAS,CAAC,OAAO;SAC7B,CAAC,IAAI,QAAQ,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;QACpC,OAAO,uBAAuB,CAAC,UAAU,CAAC,CAAC;IAC7C,CAAC,EAAE,CAAC,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;IACnD,MAAM,cAAc,GAAG,WAAW,CAChC,CAAC,KAAY,EAAE,EAAE,CACf,aAAa,CAAC;QACZ,IAAI,EAAE,WAAW;QACjB,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,WAAW,EAAE,IAAI;KAClB,CAAC,EACJ,CAAC,aAAa,CAAC,CAChB,CAAC;IACF,MAAM,gBAAgB,GAAG,WAAW,CAClC,GAAG,EAAE,CAAC,YAAY,CAAC,WAAW,CAAC,EAC/B,CAAC,YAAY,CAAC,CACf,CAAC;IACF,uBAAuB,CAAC;QACtB,OAAO,EAAE,KAAK;QACd,SAAS;QACT,MAAM,EAAE,SAAS;QACjB,SAAS;QACT,UAAU;QACV,cAAc,EAAE,iBAAiB;QACjC,OAAO,EAAE,IAAI;QACb,SAAS,EAAE,gBAAgB;QAC3B,OAAO,EAAE,cAAc;KACxB,CAAC,CAAC;IAEH,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC5B,OAAO,CACL,cAAK,SAAS,EAAC,gGAAgG,YAC5G,8BAA8B,YAAY,CAAC,CAAC,CAAE,CAAC,IAAI,KAAK,YAAY,CAAC,CAAC,CAAE,CAAC,OAAO,EAAE,GAC/E,CACP,CAAC;IACJ,CAAC;IACD,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvC,OAAO,CACL,cAAK,SAAS,EAAC,qGAAqG,iEAE9G,CACP,CAAC;IACJ,CAAC;IACD,OAAO,CACL,cAAK,GAAG,EAAE,YAAY,EAAE,SAAS,EAAC,sBAAsB,YACtD,KAAC,WAAW,IACV,GAAG,EAAE,UAAU,EACf,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,IAAI,EACrB,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,QAAQ,EAC7B,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,QAAQ,EAC7B,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,WAAW,EACnC,SAAS,EAAC,sBAAsB,EAChC,qBAAqB,EAAE,mBAAmB,EAC1C,gBAAgB,EAAE,CAAC,KAAK,EAAE,EAAE,CAC1B,aAAa,CAAC;gBACZ,IAAI,EAAE,cAAc;gBACpB,OAAO,EAAE,KAAK,CAAC,OAAO;gBACtB,WAAW,EAAE,IAAI;aAClB,CAAC,GAEJ,GACE,CACP,CAAC;AACJ,CAAC","sourcesContent":["import type {DataTable} from '@sqlrooms/duckdb';\nimport {\n  useCallback,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n  type ReactNode,\n} from 'react';\nimport {DeckJsonMap} from './DeckJsonMap';\nimport type {DeckMapResource, DeckMapRuntimeIssue} from './DeckMapsSlice';\nimport {DECK_TABLE_DATASET_SOURCE_RELATION} from './datasets/tableDatasetSql';\nimport {\n  isDeckMapSqlDatasetSource,\n  isDeckMapTableDatasetSource,\n} from './mapConfig';\nimport {getDeckMapDataPolicy, type DeckMapDataPolicy} from './mapDataPolicy';\nimport {getDeckMapResourceConfigIssues} from './mapResourceAuthoring';\nimport {\n  getDeckMapDatasetSource,\n  resolveDeckMapFitToData,\n  useDeckMapFitController,\n} from './mapFit';\nimport type {\n  DeckDatasetInput,\n  DeckJsonMapHandle,\n  PreparedDeckDatasetState,\n} from './types';\n\nfunction sampleDatasetSql(sql: string, maxRows: number) {\n  const sourceSql = sql.trim().replace(/(?:\\s*;+\\s*)+$/, '');\n  return `SELECT * FROM (${sourceSql}) USING SAMPLE ${maxRows} ROWS`;\n}\n\nfunction applyDataPolicy(\n  input: DeckDatasetInput,\n  policy: DeckMapDataPolicy,\n): DeckDatasetInput {\n  if (policy.disabled) return input;\n  const maxRows = Math.max(1, Math.floor(policy.maxRows));\n  if ('sqlQuery' in input) {\n    return {...input, sqlQuery: sampleDatasetSql(input.sqlQuery, maxRows)};\n  }\n  if ('tableName' in input) {\n    return {\n      ...input,\n      transformSql: sampleDatasetSql(\n        input.transformSql ??\n          `SELECT * FROM ${DECK_TABLE_DATASET_SOURCE_RELATION}`,\n        maxRows,\n      ),\n    };\n  }\n  return input;\n}\n\n/**\n * Host-neutral data boundary for Deck map resources. Worksheet maps use the\n * direct adapter below and are intentionally independent: no Mosaic selection\n * or cross-filter state is read or published.\n */\nexport type DeckMapDataAdapter = {\n  resolveDatasets: (options: {\n    mapId: string;\n    map: DeckMapResource;\n  }) => Record<string, DeckDatasetInput>;\n  /** Resolves an unsampled dataset input for fit-to-data bounds queries. */\n  resolveFitDataset?: (options: {\n    mapId: string;\n    map: DeckMapResource;\n    datasetId: string;\n  }) => DeckDatasetInput | undefined;\n  getTableColumns?: (tableName: string) => DataTable['columns'] | undefined;\n};\n\nfunction resolveDirectDeckMapDatasets(\n  map: DeckMapResource,\n  dataPolicy?: DeckMapDataPolicy,\n) {\n  const resolved: Record<string, DeckDatasetInput> = {};\n  // A top-level selected table is only an unambiguous override when the map\n  // has one table-backed dataset. Multi-source maps retain authored tables.\n  const tableDatasetCount = Object.values(map.config.datasets).filter(\n    (dataset) => isDeckMapTableDatasetSource(dataset.source),\n  ).length;\n  for (const [datasetId, dataset] of Object.entries(map.config.datasets)) {\n    const {source, ...datasetConfig} = dataset;\n    let input: DeckDatasetInput | undefined;\n    if (isDeckMapSqlDatasetSource(source)) {\n      input = {...datasetConfig, sqlQuery: source.sqlQuery};\n    } else if (isDeckMapTableDatasetSource(source)) {\n      input = {\n        ...datasetConfig,\n        tableName:\n          tableDatasetCount === 1\n            ? (map.selectedTable ?? source.tableName)\n            : source.tableName,\n        transformSql: source.transformSql,\n      };\n    }\n    if (input) {\n      resolved[datasetId] = dataPolicy\n        ? applyDataPolicy(input, dataPolicy)\n        : input;\n    }\n  }\n  return resolved;\n}\n\nexport const directDeckMapDataAdapter: DeckMapDataAdapter = {\n  resolveDatasets: ({map}) =>\n    resolveDirectDeckMapDatasets(map, getDeckMapDataPolicy(map.config)),\n  resolveFitDataset: ({map, datasetId}) =>\n    resolveDirectDeckMapDatasets(map)[datasetId],\n};\n\nexport type DeckMapSurfaceProps = {\n  mapId: string;\n  map: DeckMapResource;\n  readOnly?: boolean;\n  selected?: boolean;\n  caption?: string;\n  headerActions?: ReactNode;\n  fitRequestVersion?: number;\n  onUpdateMap: (patch: Partial<DeckMapResource>) => void;\n  onReportIssue: (issue: Omit<DeckMapRuntimeIssue, 'mapId'>) => void;\n  /** Clears the current issue when its kind matches, or all issues when omitted. */\n  onClearIssue: (kind?: DeckMapRuntimeIssue['kind']) => void;\n  dataAdapter?: DeckMapDataAdapter;\n};\n\nexport function DeckMapSurface({\n  mapId,\n  map,\n  onReportIssue,\n  onClearIssue,\n  fitRequestVersion = 0,\n  dataAdapter = directDeckMapDataAdapter,\n}: DeckMapSurfaceProps) {\n  const [container, setContainer] = useState<HTMLDivElement | null>(null);\n  const deckMapRef = useRef<DeckJsonMapHandle>(null);\n  const datasets = useMemo(\n    () => dataAdapter.resolveDatasets({mapId, map}),\n    [dataAdapter, map, mapId],\n  );\n  const configIssues = useMemo(\n    () => getDeckMapResourceConfigIssues(map.config, {allowEmpty: true}),\n    [map.config],\n  );\n  useEffect(() => {\n    if (configIssues.length > 0) {\n      onReportIssue({\n        kind: 'config-error',\n        message: `${configIssues[0]!.path}: ${configIssues[0]!.message}`,\n        recoverable: true,\n        details: {issues: configIssues},\n      });\n    } else {\n      onClearIssue('config-error');\n    }\n  }, [configIssues, onClearIssue, onReportIssue]);\n  const handleDatasetStates = useCallback(\n    (states: Record<string, PreparedDeckDatasetState>) => {\n      const failure = Object.values(states).find(\n        (\n          state,\n        ): state is Extract<PreparedDeckDatasetState, {status: 'error'}> =>\n          state.status === 'error',\n      );\n      if (failure) {\n        onReportIssue({\n          kind: 'sql-error',\n          message: failure.error.message,\n          recoverable: true,\n        });\n      } else if (\n        Object.values(states).every((state) => state.status === 'ready')\n      ) {\n        onClearIssue('sql-error');\n      }\n    },\n    [onClearIssue, onReportIssue],\n  );\n  useEffect(() => {\n    if (configIssues.length === 0 && Object.keys(datasets).length === 0) {\n      onClearIssue();\n    }\n  }, [configIssues, datasets, onClearIssue]);\n  const fitToData = useMemo(\n    () => resolveDeckMapFitToData(map.config),\n    [map.config],\n  );\n  const fitSource = useMemo(() => {\n    if (!fitToData) return null;\n    const fitDataset =\n      dataAdapter.resolveFitDataset?.({\n        mapId,\n        map,\n        datasetId: fitToData.dataset,\n      }) ?? datasets[fitToData.dataset];\n    return getDeckMapDatasetSource(fitDataset);\n  }, [dataAdapter, datasets, fitToData, map, mapId]);\n  const handleFitError = useCallback(\n    (error: Error) =>\n      onReportIssue({\n        kind: 'fit-error',\n        message: error.message,\n        recoverable: true,\n      }),\n    [onReportIssue],\n  );\n  const handleFitSuccess = useCallback(\n    () => onClearIssue('fit-error'),\n    [onClearIssue],\n  );\n  useDeckMapFitController({\n    scopeId: mapId,\n    fitToData,\n    source: fitSource,\n    container,\n    deckMapRef,\n    requestVersion: fitRequestVersion,\n    autoFit: true,\n    onSuccess: handleFitSuccess,\n    onError: handleFitError,\n  });\n\n  if (configIssues.length > 0) {\n    return (\n      <div className=\"text-destructive flex h-full min-h-[320px] items-center justify-center p-4 text-center text-sm\">\n        {`Invalid map configuration: ${configIssues[0]!.path}: ${configIssues[0]!.message}`}\n      </div>\n    );\n  }\n  if (Object.keys(datasets).length === 0) {\n    return (\n      <div className=\"text-muted-foreground flex h-full min-h-[320px] items-center justify-center p-4 text-center text-sm\">\n        Select a geospatial table to configure this map.\n      </div>\n    );\n  }\n  return (\n    <div ref={setContainer} className=\"h-full min-h-[320px]\">\n      <DeckJsonMap\n        ref={deckMapRef}\n        spec={map.config.spec}\n        datasets={datasets}\n        mapStyle={map.config.mapStyle}\n        mapProps={map.config.mapProps}\n        showLegends={map.config.showLegends}\n        className=\"h-full min-h-[320px]\"\n        onDatasetStatesChange={handleDatasetStates}\n        onRenderingError={(error) =>\n          onReportIssue({\n            kind: 'render-error',\n            message: error.message,\n            recoverable: true,\n          })\n        }\n      />\n    </div>\n  );\n}\n"]}

package/dist/DeckMapsSlice.d.ts

@@ -0,0 +1,99 @@
+import { type DuckDbSliceState } from '@sqlrooms/duckdb';
+import { z } from 'zod';
+import { type DeckMapConfig } from './mapConfig';
+/** Runtime schema for a durable Deck map resource entry. */
+export declare const DeckMapResourceSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    selectedTable: z.ZodOptional<z.ZodString>;
+    config: z.ZodObject<{
+        spec: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+        datasets: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        configMode: z.ZodOptional<z.ZodEnum<{
+            custom: "custom";
+            basic: "basic";
+        }>>;
+        mapStyle: z.ZodOptional<z.ZodString>;
+        mapProps: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        showLegends: z.ZodOptional<z.ZodBoolean>;
+        interaction: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        fitToData: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        dataPolicy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        settingsOpen: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/** A durable Deck map resource stored in the room configuration. */
+export type DeckMapResource = Omit<z.infer<typeof DeckMapResourceSchema>, 'config'> & {
+    config: DeckMapConfig;
+};
+/** Persistence schema for the Deck maps slice configuration. */
+export declare const DeckMapsSliceConfig: z.ZodObject<{
+    mapsById: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        selectedTable: z.ZodOptional<z.ZodString>;
+        config: z.ZodObject<{
+            spec: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+            datasets: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            configMode: z.ZodOptional<z.ZodEnum<{
+                custom: "custom";
+                basic: "basic";
+            }>>;
+            mapStyle: z.ZodOptional<z.ZodString>;
+            mapProps: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            showLegends: z.ZodOptional<z.ZodBoolean>;
+            interaction: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            fitToData: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            dataPolicy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            settingsOpen: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/** Persisted Deck map resources indexed by their stable resource ids. */
+export type DeckMapsSliceConfig = {
+    mapsById: Record<string, DeckMapResource>;
+};
+/** Ephemeral rendering or data issue associated with one Deck map resource. */
+export type DeckMapRuntimeIssue = {
+    kind: 'sql-error' | 'fit-error' | 'render-error' | 'data-policy-error' | 'config-error';
+    mapId: string;
+    message: string;
+    recoverable: boolean;
+    details?: Record<string, unknown>;
+};
+/** Callback pair for reporting and clearing ephemeral Deck map issues. */
+export type DeckMapRuntimeIssueReporter = {
+    reportIssue: (issue: DeckMapRuntimeIssue) => void;
+    clearIssue: () => void;
+};
+/** Room-store state and actions for durable maps and ephemeral runtime issues. */
+export type DeckMapsSliceState = {
+    deckMaps: {
+        config: DeckMapsSliceConfig;
+        runtime: {
+            issuesByMapId: Record<string, DeckMapRuntimeIssue>;
+        };
+        setConfig: (config: DeckMapsSliceConfig) => void;
+        ensureMap: (id: string, options?: {
+            title?: string;
+            config?: DeckMapConfig;
+        }) => void;
+        removeMap: (id: string) => void;
+        getMap: (id: string) => DeckMapResource | undefined;
+        updateMap: (id: string, patch: Partial<DeckMapResource>) => void;
+        setSelectedTable: (id: string, tableName?: string) => void;
+        reportMapIssue: (id: string, issue: Omit<DeckMapRuntimeIssue, 'mapId'>) => void;
+        /** Clears the current issue when its kind matches, or unconditionally when omitted. */
+        clearMapIssue: (id: string, kind?: DeckMapRuntimeIssue['kind']) => void;
+    };
+};
+/**
+ * Creates the room-store slice that owns durable Deck map resources and their
+ * instance-scoped runtime issues.
+ */
+export declare function createDeckMapsSlice(props?: {
+    config?: Partial<DeckMapsSliceConfig>;
+}): import("zustand").StateCreator<DeckMapsSliceState>;
+/** Selects Deck map and DuckDB state from the current room store. */
+export declare function useStoreWithDeckMaps<T>(selector: (state: DeckMapsSliceState & DuckDbSliceState) => T): T;
+//# sourceMappingURL=DeckMapsSlice.d.ts.map

package/dist/DeckMapsSlice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeckMapsSlice.d.ts","sourceRoot":"","sources":["../src/DeckMapsSlice.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,gBAAgB,EAAC,MAAM,kBAAkB,CAAC;AAOvD,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AACtB,OAAO,EAA2B,KAAK,aAAa,EAAC,MAAM,aAAa,CAAC;AAezE,4DAA4D;AAC5D,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;iBAKhC,CAAC;AAEH,oEAAoE;AACpE,MAAM,MAAM,eAAe,GAAG,IAAI,CAChC,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,EACrC,QAAQ,CACT,GAAG;IACF,MAAM,EAAE,aAAa,CAAC;CACvB,CAAC;AAEF,gEAAgE;AAChE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;iBAE9B,CAAC;AAEH,yEAAyE;AACzE,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;CAC3C,CAAC;AAEF,+EAA+E;AAC/E,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EACA,WAAW,GACX,WAAW,GACX,cAAc,GACd,mBAAmB,GACnB,cAAc,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,OAAO,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC,CAAC;AAEF,0EAA0E;AAC1E,MAAM,MAAM,2BAA2B,GAAG;IACxC,WAAW,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI,CAAC;IAClD,UAAU,EAAE,MAAM,IAAI,CAAC;CACxB,CAAC;AAEF,kFAAkF;AAClF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE;QACR,MAAM,EAAE,mBAAmB,CAAC;QAC5B,OAAO,EAAE;YAAC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAA;SAAC,CAAC;QAC9D,SAAS,EAAE,CAAC,MAAM,EAAE,mBAAmB,KAAK,IAAI,CAAC;QACjD,SAAS,EAAE,CACT,EAAE,EAAE,MAAM,EACV,OAAO,CAAC,EAAE;YAAC,KAAK,CAAC,EAAE,MAAM,CAAC;YAAC,MAAM,CAAC,EAAE,aAAa,CAAA;SAAC,KAC/C,IAAI,CAAC;QACV,SAAS,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;QAChC,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,eAAe,GAAG,SAAS,CAAC;QACpD,SAAS,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,eAAe,CAAC,KAAK,IAAI,CAAC;QACjE,gBAAgB,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;QAC3D,cAAc,EAAE,CACd,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,IAAI,CAAC,mBAAmB,EAAE,OAAO,CAAC,KACtC,IAAI,CAAC;QACV,uFAAuF;QACvF,aAAa,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,mBAAmB,CAAC,MAAM,CAAC,KAAK,IAAI,CAAC;KACzE,CAAC;CACH,CAAC;AAEF;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,CAAC,EAAE;IAC1C,MAAM,CAAC,EAAE,OAAO,CAAC,mBAAmB,CAAC,CAAC;CACvC,sDA0EA;AAED,qEAAqE;AACrE,wBAAgB,oBAAoB,CAAC,CAAC,EACpC,QAAQ,EAAE,CAAC,KAAK,EAAE,kBAAkB,GAAG,gBAAgB,KAAK,CAAC,GAC5D,CAAC,CAEH"}

package/dist/DeckMapsSlice.js

@@ -0,0 +1,89 @@
+import { createSlice, useBaseRoomStore, } from '@sqlrooms/room-store';
+import { produce } from 'immer';
+import { z } from 'zod';
+import { createEmptyDeckMapConfig } from './mapConfig';
+const DeckMapConfigSchema = z.object({
+    spec: z.union([z.string(), z.record(z.string(), z.unknown())]),
+    datasets: z.record(z.string(), z.unknown()),
+    configMode: z.enum(['basic', 'custom']).optional(),
+    mapStyle: z.string().optional(),
+    mapProps: z.record(z.string(), z.unknown()).optional(),
+    showLegends: z.boolean().optional(),
+    interaction: z.record(z.string(), z.unknown()).optional(),
+    fitToData: z.record(z.string(), z.unknown()).optional(),
+    dataPolicy: z.record(z.string(), z.unknown()).optional(),
+    settingsOpen: z.boolean().optional(),
+});
+/** Runtime schema for a durable Deck map resource entry. */
+export const DeckMapResourceSchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    selectedTable: z.string().optional(),
+    config: DeckMapConfigSchema,
+});
+/** Persistence schema for the Deck maps slice configuration. */
+export const DeckMapsSliceConfig = z.object({
+    mapsById: z.record(z.string(), DeckMapResourceSchema).default({}),
+});
+/**
+ * Creates the room-store slice that owns durable Deck map resources and their
+ * instance-scoped runtime issues.
+ */
+export function createDeckMapsSlice(props) {
+    return createSlice((set, get) => ({
+        deckMaps: {
+            config: { mapsById: props?.config?.mapsById ?? {} },
+            runtime: { issuesByMapId: {} },
+            setConfig: (config) => set((state) => produce(state, (draft) => {
+                draft.deckMaps.config = config;
+            })),
+            ensureMap: (id, options) => set((state) => produce(state, (draft) => {
+                if (!draft.deckMaps.config.mapsById[id]) {
+                    draft.deckMaps.config.mapsById[id] = {
+                        id,
+                        title: options?.title ?? 'Map',
+                        config: options?.config ?? createEmptyDeckMapConfig(),
+                    };
+                }
+            })),
+            removeMap: (id) => set((state) => produce(state, (draft) => {
+                delete draft.deckMaps.config.mapsById[id];
+                delete draft.deckMaps.runtime.issuesByMapId[id];
+            })),
+            getMap: (id) => get().deckMaps.config.mapsById[id],
+            updateMap: (id, patch) => set((state) => produce(state, (draft) => {
+                const map = draft.deckMaps.config.mapsById[id];
+                if (!map)
+                    throw new Error(`Deck map ${id} was not found`);
+                Object.assign(map, patch, { id });
+                if (patch.config) {
+                    const issue = draft.deckMaps.runtime.issuesByMapId[id];
+                    if (Object.keys(patch.config.datasets).length === 0 ||
+                        issue?.kind === 'render-error') {
+                        delete draft.deckMaps.runtime.issuesByMapId[id];
+                    }
+                }
+            })),
+            setSelectedTable: (id, tableName) => set((state) => produce(state, (draft) => {
+                const map = draft.deckMaps.config.mapsById[id];
+                if (!map)
+                    throw new Error(`Deck map ${id} was not found`);
+                map.selectedTable = tableName;
+            })),
+            reportMapIssue: (id, issue) => set((state) => produce(state, (draft) => {
+                draft.deckMaps.runtime.issuesByMapId[id] = { ...issue, mapId: id };
+            })),
+            clearMapIssue: (id, kind) => set((state) => produce(state, (draft) => {
+                const issue = draft.deckMaps.runtime.issuesByMapId[id];
+                if (!kind || issue?.kind === kind) {
+                    delete draft.deckMaps.runtime.issuesByMapId[id];
+                }
+            })),
+        },
+    }));
+}
+/** Selects Deck map and DuckDB state from the current room store. */
+export function useStoreWithDeckMaps(selector) {
+    return useBaseRoomStore(selector);
+}
+//# sourceMappingURL=DeckMapsSlice.js.map

package/dist/DeckMapsSlice.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeckMapsSlice.js","sourceRoot":"","sources":["../src/DeckMapsSlice.ts"],"names":[],"mappings":"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","sourcesContent":["import {type DuckDbSliceState} from '@sqlrooms/duckdb';\nimport {\n  type BaseRoomStoreState,\n  createSlice,\n  useBaseRoomStore,\n} from '@sqlrooms/room-store';\nimport {produce} from 'immer';\nimport {z} from 'zod';\nimport {createEmptyDeckMapConfig, type DeckMapConfig} from './mapConfig';\n\nconst DeckMapConfigSchema = z.object({\n  spec: z.union([z.string(), z.record(z.string(), z.unknown())]),\n  datasets: z.record(z.string(), z.unknown()),\n  configMode: z.enum(['basic', 'custom']).optional(),\n  mapStyle: z.string().optional(),\n  mapProps: z.record(z.string(), z.unknown()).optional(),\n  showLegends: z.boolean().optional(),\n  interaction: z.record(z.string(), z.unknown()).optional(),\n  fitToData: z.record(z.string(), z.unknown()).optional(),\n  dataPolicy: z.record(z.string(), z.unknown()).optional(),\n  settingsOpen: z.boolean().optional(),\n});\n\n/** Runtime schema for a durable Deck map resource entry. */\nexport const DeckMapResourceSchema = z.object({\n  id: z.string(),\n  title: z.string(),\n  selectedTable: z.string().optional(),\n  config: DeckMapConfigSchema,\n});\n\n/** A durable Deck map resource stored in the room configuration. */\nexport type DeckMapResource = Omit<\n  z.infer<typeof DeckMapResourceSchema>,\n  'config'\n> & {\n  config: DeckMapConfig;\n};\n\n/** Persistence schema for the Deck maps slice configuration. */\nexport const DeckMapsSliceConfig = z.object({\n  mapsById: z.record(z.string(), DeckMapResourceSchema).default({}),\n});\n\n/** Persisted Deck map resources indexed by their stable resource ids. */\nexport type DeckMapsSliceConfig = {\n  mapsById: Record<string, DeckMapResource>;\n};\n\n/** Ephemeral rendering or data issue associated with one Deck map resource. */\nexport type DeckMapRuntimeIssue = {\n  kind:\n    | 'sql-error'\n    | 'fit-error'\n    | 'render-error'\n    | 'data-policy-error'\n    | 'config-error';\n  mapId: string;\n  message: string;\n  recoverable: boolean;\n  details?: Record<string, unknown>;\n};\n\n/** Callback pair for reporting and clearing ephemeral Deck map issues. */\nexport type DeckMapRuntimeIssueReporter = {\n  reportIssue: (issue: DeckMapRuntimeIssue) => void;\n  clearIssue: () => void;\n};\n\n/** Room-store state and actions for durable maps and ephemeral runtime issues. */\nexport type DeckMapsSliceState = {\n  deckMaps: {\n    config: DeckMapsSliceConfig;\n    runtime: {issuesByMapId: Record<string, DeckMapRuntimeIssue>};\n    setConfig: (config: DeckMapsSliceConfig) => void;\n    ensureMap: (\n      id: string,\n      options?: {title?: string; config?: DeckMapConfig},\n    ) => void;\n    removeMap: (id: string) => void;\n    getMap: (id: string) => DeckMapResource | undefined;\n    updateMap: (id: string, patch: Partial<DeckMapResource>) => void;\n    setSelectedTable: (id: string, tableName?: string) => void;\n    reportMapIssue: (\n      id: string,\n      issue: Omit<DeckMapRuntimeIssue, 'mapId'>,\n    ) => void;\n    /** Clears the current issue when its kind matches, or unconditionally when omitted. */\n    clearMapIssue: (id: string, kind?: DeckMapRuntimeIssue['kind']) => void;\n  };\n};\n\n/**\n * Creates the room-store slice that owns durable Deck map resources and their\n * instance-scoped runtime issues.\n */\nexport function createDeckMapsSlice(props?: {\n  config?: Partial<DeckMapsSliceConfig>;\n}) {\n  type RootState = BaseRoomStoreState & DuckDbSliceState & DeckMapsSliceState;\n  return createSlice<DeckMapsSliceState, RootState>((set, get) => ({\n    deckMaps: {\n      config: {mapsById: props?.config?.mapsById ?? {}},\n      runtime: {issuesByMapId: {}},\n      setConfig: (config) =>\n        set((state) =>\n          produce(state, (draft) => {\n            draft.deckMaps.config = config;\n          }),\n        ),\n      ensureMap: (id, options) =>\n        set((state) =>\n          produce(state, (draft) => {\n            if (!draft.deckMaps.config.mapsById[id]) {\n              draft.deckMaps.config.mapsById[id] = {\n                id,\n                title: options?.title ?? 'Map',\n                config: options?.config ?? createEmptyDeckMapConfig(),\n              };\n            }\n          }),\n        ),\n      removeMap: (id) =>\n        set((state) =>\n          produce(state, (draft) => {\n            delete draft.deckMaps.config.mapsById[id];\n            delete draft.deckMaps.runtime.issuesByMapId[id];\n          }),\n        ),\n      getMap: (id) => get().deckMaps.config.mapsById[id],\n      updateMap: (id, patch) =>\n        set((state) =>\n          produce(state, (draft) => {\n            const map = draft.deckMaps.config.mapsById[id];\n            if (!map) throw new Error(`Deck map ${id} was not found`);\n            Object.assign(map, patch, {id});\n            if (patch.config) {\n              const issue = draft.deckMaps.runtime.issuesByMapId[id];\n              if (\n                Object.keys(patch.config.datasets).length === 0 ||\n                issue?.kind === 'render-error'\n              ) {\n                delete draft.deckMaps.runtime.issuesByMapId[id];\n              }\n            }\n          }),\n        ),\n      setSelectedTable: (id, tableName) =>\n        set((state) =>\n          produce(state, (draft) => {\n            const map = draft.deckMaps.config.mapsById[id];\n            if (!map) throw new Error(`Deck map ${id} was not found`);\n            map.selectedTable = tableName;\n          }),\n        ),\n      reportMapIssue: (id, issue) =>\n        set((state) =>\n          produce(state, (draft) => {\n            draft.deckMaps.runtime.issuesByMapId[id] = {...issue, mapId: id};\n          }),\n        ),\n      clearMapIssue: (id, kind) =>\n        set((state) =>\n          produce(state, (draft) => {\n            const issue = draft.deckMaps.runtime.issuesByMapId[id];\n            if (!kind || issue?.kind === kind) {\n              delete draft.deckMaps.runtime.issuesByMapId[id];\n            }\n          }),\n        ),\n    },\n  }));\n}\n\n/** Selects Deck map and DuckDB state from the current room store. */\nexport function useStoreWithDeckMaps<T>(\n  selector: (state: DeckMapsSliceState & DuckDbSliceState) => T,\n): T {\n  return useBaseRoomStore<DeckMapsSliceState & DuckDbSliceState, T>(selector);\n}\n"]}