@sqlrooms/deck 0.29.0-rc.10 → 0.29.0-rc.12

package/dist/json/createDeckJsonConfiguration.js

@@ -1,17 +1,28 @@
 import { JSONConfiguration } from '@deck.gl/json';
-import { wkbGeometryDecoder } from '../prepare/wkbDecoder';
+import { isPointPositionLayer, promoteToPointPositions, wkbGeometryDecoder, describeGeoArrowPromotionFailure, } from '../prepare/wkbDecoder';
 import { tryAggregateWaypointsToLineStrings } from './aggregateWaypoints';
 import { createColorScaleMarker, getAllColorScales, COLOR_SCALE_PROP_NAMES, } from './colorScaleFunction';
 import { compileColorScale } from './compileColorScale';
 import { DEFAULT_DECK_JSON_CLASSES, DEFAULT_DECK_JSON_CONSTANTS, DEFAULT_DECK_JSON_ENUMERATIONS, } from './defaultClasses';
-import { DEFAULT_HEATMAP_COLOR_RANGE } from './heatmapDefaults';
+import { DEFAULT_HEATMAP_COLOR_RANGE, DEFAULT_HEATMAP_WEIGHTS_TEXTURE_SIZE, } from './heatmapDefaults';
 import { getLayerCompatibility } from './layerCompatibility';
 import { isManagedLayer, resolveConfiguredColumn, resolveDatasetId, resolveGeometryColumn, stripLayerExtensionProps, } from './layerConfig';
 import { rewriteGeoArrowAccessors } from './rewriteGeoArrowAccessors';
+import { isBindableGeoArrowFieldIdentifier } from './compileGeoArrowAccessor';
+import { compileLinearScaleAccessor, compileLinearScaleExpression, createScaleMarker, isScaleMarker, } from './scaleFunction';
 function getLayerName(Class) {
     const maybeClass = Class;
     return maybeClass.layerName ?? maybeClass.name ?? 'UnknownLayer';
 }
+/**
+ * Deck.gl matches layers by id. Each JSON convert would otherwise create a new
+ * GPU layer. Dataset id alone collides when two layers share a dataset.
+ */
+function assignStableLayerId(props, datasetId, layerName, index) {
+    if (typeof props.id === 'string' && props.id !== '')
+        return;
+    props.id = `${datasetId}:${layerName}:${index}`;
+}
 function applyColorScale(options) {
     const { props, table } = options;
     const allScales = getAllColorScales(props);
@@ -44,16 +55,110 @@ function applyColorScale(options) {
     }
     return result;
 }
+function getElevationTrigger(rawElev) {
+    if (rawElev === undefined)
+        return 'none';
+    if (typeof rawElev === 'string' || typeof rawElev === 'number') {
+        return String(rawElev);
+    }
+    try {
+        return JSON.stringify(rawElev);
+    }
+    catch {
+        return String(rawElev);
+    }
+}
+function mergeGetElevationTrigger(props, rawElev) {
+    const existing = props.updateTriggers &&
+        typeof props.updateTriggers === 'object' &&
+        !Array.isArray(props.updateTriggers)
+        ? props.updateTriggers
+        : {};
+    return {
+        ...props,
+        updateTriggers: {
+            ...existing,
+            getElevation: getElevationTrigger(rawElev),
+        },
+    };
+}
+/** Compile `getElevation` scale / `@@=` column accessors against the Arrow table. */
+function compileGetElevation(options) {
+    const { table, layerName, datasetId, requireFunctionAccessor } = options;
+    const nextProps = { ...options.props };
+    const rawElev = nextProps.getElevation;
+    if (isScaleMarker(rawElev)) {
+        const expression = requireFunctionAccessor
+            ? undefined
+            : compileLinearScaleExpression(table, rawElev);
+        if (expression) {
+            nextProps.getElevation = expression;
+        }
+        else {
+            const accessor = compileLinearScaleAccessor(table, rawElev);
+            if (accessor) {
+                nextProps.getElevation = accessor;
+            }
+            else {
+                const field = typeof rawElev.field === 'string' ? rawElev.field : '';
+                throw new Error(`Layer "${layerName}" getElevation scale field "${field || '(missing)'}" was not found in dataset "${datasetId}".`);
+            }
+        }
+    }
+    else if (typeof rawElev === 'string' && rawElev.startsWith('@@=')) {
+        const elevField = rawElev.slice(3).trim();
+        const elevVector = table.getChild(elevField);
+        if (elevVector) {
+            let min = Infinity;
+            for (let i = 0; i < elevVector.length; i++) {
+                if (typeof elevVector.isValid === 'function' &&
+                    !elevVector.isValid(i)) {
+                    continue;
+                }
+                const raw = elevVector.get(i);
+                if (raw == null)
+                    continue;
+                const v = Number(raw);
+                if (Number.isFinite(v) && v < min)
+                    min = v;
+            }
+            if (Number.isFinite(min)) {
+                if (!requireFunctionAccessor &&
+                    isBindableGeoArrowFieldIdentifier(elevField)) {
+                    if (min !== 0) {
+                        nextProps.getElevation = `@@=Math.max(0, ${elevField} - ${min})`;
+                    }
+                }
+                else {
+                    const accessor = compileLinearScaleAccessor(table, {
+                        field: elevField,
+                        domain: [min, min],
+                    });
+                    if (accessor)
+                        nextProps.getElevation = accessor;
+                }
+            }
+        }
+    }
+    return nextProps;
+}
 function resolveGeoArrowBindings(options) {
     const { layerName, compatibility, layerProps, prepared, props } = options;
     let table = prepared.table;
     const boundProps = {};
     for (const binding of compatibility.bindings) {
-        if (props[binding.prop] !== undefined) {
+        const existing = props[binding.prop];
+        // Prefer Arrow Vector over `@@=column` (avoids empty H3 / missing-column silence).
+        const existingIsSimpleAccessor = typeof existing === 'string' &&
+            /^@@=[A-Za-z_$][\w$]*$/.test(existing.trim());
+        if (existing !== undefined && !existingIsSimpleAccessor) {
             continue;
         }
         if (binding.kind === 'geometry') {
-            const columnName = resolveConfiguredColumn(layerProps, binding.configKey);
+            const columnName = resolveConfiguredColumn(layerProps, binding.configKey) ??
+                (existingIsSimpleAccessor
+                    ? existing.trim().slice(3)
+                    : undefined);
             if (binding.required && !columnName) {
                 throw new Error(`Layer "${layerName}" requires _sqlroomsBinding.${binding.configKey}.`);
             }
@@ -91,10 +196,33 @@ function resolveGeoArrowBindings(options) {
                     `but only point coordinates were found. Available columns: ${available}.`);
             }
             if (!resolvedGeometry.nativeGeoArrow) {
-                if (!compatibility.allowGeoArrowPromotion ||
-                    !wkbGeometryDecoder.supportsGeoArrowPromotion(layerName, resolvedGeometry.encoding, prepared.table, resolvedGeometry.columnName)) {
+                if (!compatibility.allowGeoArrowPromotion) {
                     throw new Error(`Layer "${layerName}" cannot render geometry encoding "${resolvedGeometry.encoding}" for dataset "${prepared.datasetId}".`);
                 }
+                // Point layers: promote Points only — no silent polygon centroid.
+                if (isPointPositionLayer(layerName)) {
+                    const promoted = promoteToPointPositions(prepared.table, resolvedGeometry.columnName, resolvedGeometry.encoding);
+                    if (!promoted) {
+                        throw new Error(`Layer "${layerName}" needs Point positions for dataset "${prepared.datasetId}" ` +
+                            `(geometry encoding "${resolvedGeometry.encoding}"). ` +
+                            `Use a point geometry column, or transformSql with ` +
+                            `ST_AsWKB(ST_Centroid(geom)) / ST_PointOnSurface(geom). ` +
+                            `For building footprints prefer GeoArrowPolygonLayer or GeoJsonLayer.`);
+                    }
+                    boundProps[binding.prop] = promoted.geometryColumn;
+                    if (table === prepared.table) {
+                        table = promoted.table;
+                    }
+                    continue;
+                }
+                if (!wkbGeometryDecoder.supportsGeoArrowPromotion(layerName, resolvedGeometry.encoding, prepared.table, resolvedGeometry.columnName)) {
+                    const pathHint = layerName === 'GeoArrowPathLayer' ||
+                        layerName === 'GeoArrowTripsLayer'
+                        ? ` GeoArrowPathLayer needs LineString WKB (or a single-part MultiLineString). Multi-part MultiLineString cannot be stitched into one path — explode/merge with ST_Dump / ST_LineMerge first, then ST_AsWKB.`
+                        : '';
+                    const mixedHint = describeGeoArrowPromotionFailure(layerName, resolvedGeometry.encoding, prepared.table, resolvedGeometry.columnName);
+                    throw new Error(`Layer "${layerName}" cannot render geometry encoding "${resolvedGeometry.encoding}" for dataset "${prepared.datasetId}".${pathHint}${mixedHint}`);
+                }
             }
             const layerData = prepared.getGeoArrowLayerData(columnName);
             if (layerData.source === 'promoted') {
@@ -112,7 +240,10 @@ function resolveGeoArrowBindings(options) {
             }
             continue;
         }
-        const columnName = resolveConfiguredColumn(layerProps, binding.configKey);
+        const columnName = resolveConfiguredColumn(layerProps, binding.configKey) ??
+            (existingIsSimpleAccessor
+                ? existing.trim().slice(3)
+                : undefined);
         if (!columnName) {
             if (binding.required) {
                 throw new Error(`Layer "${layerName}" requires _sqlroomsBinding.${binding.configKey}.`);
@@ -129,179 +260,175 @@ function resolveGeoArrowBindings(options) {
 }
 export function createDeckJsonConfiguration(options) {
     const { datasetStates, datasetIds } = options;
+    let nextManagedLayerIndex = 0;
     return new JSONConfiguration({
         classes: DEFAULT_DECK_JSON_CLASSES,
         enumerations: DEFAULT_DECK_JSON_ENUMERATIONS,
         constants: DEFAULT_DECK_JSON_CONSTANTS,
         functions: {
             colorScale: (props) => createColorScaleMarker(props),
-            scale: (props) => {
-                const field = typeof props.field === 'string' ? props.field : undefined;
-                if (!field)
-                    return undefined;
-                return `@@=${field}`;
-            },
+            scale: (props) => createScaleMarker(props),
         },
         // We preserve raw `@@=` strings here because `@deck.gl/json` would otherwise
         // eagerly compile them into row-based accessors before `preProcessClassProps`
         // can rewrite them for GeoArrow's batch-oriented callback contract.
         convertFunction: ((expression) => `@@=${expression}`),
         preProcessClassProps: (Class, props) => {
-            const layerName = getLayerName(Class);
-            const compatibility = getLayerCompatibility(layerName);
-            if (!compatibility) {
-                return props;
-            }
-            const layerProps = props;
-            const extensionProps = layerProps;
-            const datasetId = resolveDatasetId(extensionProps, datasetIds);
-            const managed = isManagedLayer(extensionProps, datasetIds) ||
-                (datasetIds.length > 1 && layerProps.data === undefined);
-            if (!managed) {
-                return props;
-            }
-            if (!datasetId) {
-                throw new Error(`Layer "${layerName}" must declare _sqlroomsBinding.dataset when multiple datasets are available.`);
-            }
-            const datasetState = datasetStates[datasetId];
-            if (!datasetState) {
-                throw new Error(`Layer "${layerName}" references unknown dataset "${datasetId}".`);
+            try {
+                return preprocessManagedLayer();
             }
-            if (datasetState.status !== 'ready') {
-                return { ...stripLayerExtensionProps(layerProps), data: [] };
+            catch (error) {
+                // JSONConverter skips postProcessConvertedJson when convert throws.
+                nextManagedLayerIndex = 0;
+                throw error;
             }
-            const prepared = datasetState.prepared;
-            const geometryColumn = resolveGeometryColumn(extensionProps);
-            const strippedProps = stripLayerExtensionProps(layerProps);
-            if (compatibility.representation === 'geojson') {
+            function preprocessManagedLayer() {
+                const layerName = getLayerName(Class);
+                const compatibility = getLayerCompatibility(layerName);
+                if (!compatibility) {
+                    return props;
+                }
+                const layerProps = props;
+                const extensionProps = layerProps;
+                const datasetId = resolveDatasetId(extensionProps, datasetIds);
+                const managed = isManagedLayer(extensionProps, datasetIds) ||
+                    (datasetIds.length > 1 && layerProps.data === undefined);
+                if (!managed) {
+                    return props;
+                }
+                if (!datasetId) {
+                    throw new Error(`Layer "${layerName}" must declare _sqlroomsBinding.dataset when multiple datasets are available.`);
+                }
+                const datasetState = datasetStates[datasetId];
+                if (!datasetState) {
+                    throw new Error(`Layer "${layerName}" references unknown dataset "${datasetId}".`);
+                }
+                if (datasetState.status !== 'ready') {
+                    const pendingProps = stripLayerExtensionProps(layerProps);
+                    assignStableLayerId(pendingProps, datasetId, layerName, nextManagedLayerIndex++);
+                    return { ...pendingProps, data: [] };
+                }
+                const prepared = datasetState.prepared;
+                const geometryColumn = resolveGeometryColumn(extensionProps);
+                const strippedProps = stripLayerExtensionProps(layerProps);
+                assignStableLayerId(strippedProps, datasetId, layerName, nextManagedLayerIndex++);
+                if (compatibility.representation === 'geojson') {
+                    const baseProps = applyColorScale({
+                        props: strippedProps,
+                        table: prepared.table,
+                    });
+                    const withElevation = compileGetElevation({
+                        props: baseProps,
+                        table: prepared.table,
+                        layerName,
+                        datasetId: prepared.datasetId,
+                        requireFunctionAccessor: true,
+                    });
+                    return {
+                        ...mergeGetElevationTrigger(withElevation, baseProps.getElevation),
+                        data: prepared.getGeoJsonBinaryData(geometryColumn),
+                    };
+                }
+                const { table, boundProps } = resolveGeoArrowBindings({
+                    layerName,
+                    compatibility: compatibility,
+                    layerProps: extensionProps,
+                    prepared,
+                    props: strippedProps,
+                });
                 const baseProps = applyColorScale({
                     props: strippedProps,
-                    table: prepared.table,
+                    table,
                 });
-                return {
-                    ...baseProps,
-                    data: prepared.getGeoJsonBinaryData(geometryColumn),
-                };
-            }
-            const { table, boundProps } = resolveGeoArrowBindings({
-                layerName,
-                compatibility: compatibility,
-                layerProps: extensionProps,
-                prepared,
-                props: strippedProps,
-            });
-            const baseProps = applyColorScale({
-                props: strippedProps,
-                table,
-            });
-            const nextProps = {
-                ...baseProps,
-                data: table,
-                ...boundProps,
-            };
-            // Normalize getElevation: subtract column minimum so the lowest
-            // feature sits at ground level and differences are clearly visible.
-            const rawElev = nextProps.getElevation;
-            if (typeof rawElev === 'string' && rawElev.startsWith('@@=')) {
-                const elevField = rawElev.slice(3).trim();
-                const elevVector = table.getChild(elevField);
-                if (elevVector) {
-                    let min = Infinity;
-                    for (let i = 0; i < elevVector.length; i++) {
-                        const v = Number(elevVector.get(i));
-                        if (Number.isFinite(v) && v < min)
-                            min = v;
-                    }
-                    if (Number.isFinite(min) && min !== 0) {
-                        nextProps.getElevation = `@@=Math.max(0, ${elevField} - ${min})`;
+                const nextProps = compileGetElevation({
+                    props: {
+                        ...baseProps,
+                        data: table,
+                        ...boundProps,
+                    },
+                    table,
+                    layerName,
+                    datasetId: prepared.datasetId,
+                });
+                const rewritten = rewriteGeoArrowAccessors({
+                    props: nextProps,
+                    table,
+                    layerName,
+                });
+                // Set updateTriggers for @@= accessor props and getElevation
+                // so deck.gl re-evaluates them when references change or are cleared.
+                {
+                    const accessorTriggers = {};
+                    for (const [propName, propValue] of Object.entries(nextProps)) {
+                        if (typeof propValue === 'string' &&
+                            propValue.startsWith('@@=') &&
+                            propName.startsWith('get')) {
+                            accessorTriggers[propName] = propValue;
+                        }
                     }
-                }
-            }
-            const rewritten = rewriteGeoArrowAccessors({
-                props: nextProps,
-                table,
-                layerName,
-            });
-            // Set updateTriggers for @@= accessor props and getElevation
-            // so deck.gl re-evaluates them when references change or are cleared.
-            {
-                const accessorTriggers = {};
-                for (const [propName, propValue] of Object.entries(nextProps)) {
-                    if (typeof propValue === 'string' &&
-                        propValue.startsWith('@@=') &&
-                        propName.startsWith('get')) {
-                        accessorTriggers[propName] = propValue;
+                    // Always emit getElevation trigger so clearing the column invalidates
+                    // stale heights from a previous column-based accessor.
+                    if (!('getElevation' in accessorTriggers)) {
+                        const elev = nextProps.getElevation;
+                        accessorTriggers.getElevation =
+                            elev !== undefined ? String(elev) : 'none';
                     }
+                    const existingTriggers = rewritten.updateTriggers &&
+                        typeof rewritten.updateTriggers === 'object' &&
+                        !Array.isArray(rewritten.updateTriggers)
+                        ? rewritten.updateTriggers
+                        : {};
+                    rewritten.updateTriggers = {
+                        ...existingTriggers,
+                        ...accessorTriggers,
+                    };
                 }
-                // Always emit getElevation trigger so clearing the column invalidates
-                // stale heights from a previous column-based accessor.
-                if (!('getElevation' in accessorTriggers)) {
-                    const elev = nextProps.getElevation;
-                    accessorTriggers.getElevation =
-                        elev !== undefined ? String(elev) : 'none';
-                }
-                const existingTriggers = rewritten.updateTriggers &&
-                    typeof rewritten.updateTriggers === 'object' &&
-                    !Array.isArray(rewritten.updateTriggers)
-                    ? rewritten.updateTriggers
-                    : {};
-                rewritten.updateTriggers = {
-                    ...existingTriggers,
-                    ...accessorTriggers,
-                };
-            }
-            // For TripsLayer: compute max timestamp for animation and set defaults
-            if (layerName === 'GeoArrowTripsLayer' || layerName === 'TripsLayer') {
-                const tsVector = boundProps.getTimestamps;
-                if (tsVector) {
-                    let maxTs = 0;
-                    for (let i = 0; i < tsVector.length; i++) {
-                        const listItem = tsVector.get(i);
-                        if (listItem &&
-                            typeof listItem === 'object' &&
-                            'length' in listItem) {
-                            const list = listItem;
-                            for (let j = 0; j < list.length; j++) {
-                                const v = Number(list.get(j)) || 0;
-                                if (v > maxTs)
-                                    maxTs = v;
+                // For TripsLayer: compute max timestamp for animation and set defaults
+                if (layerName === 'GeoArrowTripsLayer' || layerName === 'TripsLayer') {
+                    const tsVector = boundProps.getTimestamps;
+                    if (tsVector) {
+                        let maxTs = 0;
+                        for (let i = 0; i < tsVector.length; i++) {
+                            const listItem = tsVector.get(i);
+                            if (listItem &&
+                                typeof listItem === 'object' &&
+                                'length' in listItem) {
+                                const list = listItem;
+                                for (let j = 0; j < list.length; j++) {
+                                    const v = Number(list.get(j)) || 0;
+                                    if (v > maxTs)
+                                        maxTs = v;
+                                }
                             }
                         }
-                    }
-                    if (maxTs > 0) {
-                        rewritten._tripsMaxTimestamp = maxTs;
-                        if (!rewritten.trailLength) {
-                            rewritten.trailLength = maxTs;
-                        }
-                        if (rewritten.currentTime === undefined ||
-                            rewritten.currentTime === 0) {
-                            rewritten.currentTime = maxTs;
+                        if (maxTs > 0) {
+                            rewritten._tripsMaxTimestamp = maxTs;
+                            if (!rewritten.trailLength) {
+                                rewritten.trailLength = maxTs;
+                            }
+                            if (rewritten.currentTime === undefined ||
+                                rewritten.currentTime === 0) {
+                                rewritten.currentTime = maxTs;
+                            }
                         }
                     }
                 }
-            }
-            // For HeatmapLayer: apply default colorRange (YlOrRd) when not explicitly set.
-            // Also set updateTriggers to force re-aggregation when colorRange changes.
-            if (layerName === 'GeoArrowHeatmapLayer') {
-                if (!rewritten.colorRange) {
-                    rewritten.colorRange = DEFAULT_HEATMAP_COLOR_RANGE;
+                // HeatmapLayer remaps colorRange in _updateColorTexture. Putting it in
+                // getWeight updateTriggers would mark aggregation dirty and rebuild the
+                // GPU weight texture when only the colormap changed.
+                if (layerName === 'GeoArrowHeatmapLayer') {
+                    if (!rewritten.colorRange) {
+                        rewritten.colorRange = DEFAULT_HEATMAP_COLOR_RANGE;
+                    }
+                    if (rewritten.weightsTextureSize === undefined) {
+                        rewritten.weightsTextureSize = DEFAULT_HEATMAP_WEIGHTS_TEXTURE_SIZE;
+                    }
                 }
-                const existingTriggers = rewritten.updateTriggers &&
-                    typeof rewritten.updateTriggers === 'object' &&
-                    !Array.isArray(rewritten.updateTriggers)
-                    ? rewritten.updateTriggers
-                    : {};
-                const previousGetWeight = existingTriggers.getWeight;
-                rewritten.updateTriggers = {
-                    ...existingTriggers,
-                    getWeight: previousGetWeight === undefined
-                        ? JSON.stringify(rewritten.colorRange)
-                        : [previousGetWeight, JSON.stringify(rewritten.colorRange)],
-                };
+                return rewritten;
             }
-            return rewritten;
         },
         postProcessConvertedJson: (json) => {
+            nextManagedLayerIndex = 0;
             if (json &&
                 typeof json === 'object' &&
                 'layers' in json &&