@sqlrooms/deck 0.29.0-rc.2

package/dist/datasets/usePreparedDeckDatasets.d.ts

@@ -0,0 +1,3 @@
+import type { DeckDatasetInput, PreparedDeckDatasetState } from '../types';
+export declare function usePreparedDeckDatasets(datasets: Record<string, DeckDatasetInput>): Record<string, PreparedDeckDatasetState>;
+//# sourceMappingURL=usePreparedDeckDatasets.d.ts.map

package/dist/datasets/usePreparedDeckDatasets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePreparedDeckDatasets.d.ts","sourceRoot":"","sources":["../../src/datasets/usePreparedDeckDatasets.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,gBAAgB,EAAE,wBAAwB,EAAC,MAAM,UAAU,CAAC;AAIzE,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,GACzC,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAqE1C"}

package/dist/datasets/usePreparedDeckDatasets.js

@@ -0,0 +1,61 @@
+import { useEffect, useState } from 'react';
+import { useStoreWithDuckDb } from '@sqlrooms/duckdb';
+import { resolveArrowTable } from './normalizeDatasets';
+import { prepareDeckDataset } from '../prepare/prepareDeckDataset';
+export function usePreparedDeckDatasets(datasets) {
+    const executeSql = useStoreWithDuckDb((state) => state.db.executeSql);
+    const [states, setStates] = useState({});
+    useEffect(() => {
+        let cancelled = false;
+        setStates(Object.fromEntries(Object.entries(datasets).map(([datasetId, input]) => [
+            datasetId,
+            input.sqlQuery ? { status: 'loading' } : { status: 'loading' },
+        ])));
+        for (const [datasetId, input] of Object.entries(datasets)) {
+            const run = async () => {
+                try {
+                    let table = resolveArrowTable(input);
+                    if (!table && input.sqlQuery) {
+                        const queryHandle = await executeSql(input.sqlQuery);
+                        if (!queryHandle) {
+                            throw new Error(`Query for dataset "${datasetId}" was cancelled.`);
+                        }
+                        table = await queryHandle;
+                    }
+                    if (!table) {
+                        throw new Error(`Dataset "${datasetId}" could not resolve an Arrow table.`);
+                    }
+                    const prepared = prepareDeckDataset({
+                        datasetId,
+                        table,
+                        geometryColumn: input.geometryColumn,
+                        geometryEncodingHint: input.geometryEncodingHint,
+                    });
+                    if (!cancelled) {
+                        setStates((current) => ({
+                            ...current,
+                            [datasetId]: { status: 'ready', prepared },
+                        }));
+                    }
+                }
+                catch (error) {
+                    if (!cancelled) {
+                        setStates((current) => ({
+                            ...current,
+                            [datasetId]: {
+                                status: 'error',
+                                error: error instanceof Error ? error : new Error(String(error)),
+                            },
+                        }));
+                    }
+                }
+            };
+            void run();
+        }
+        return () => {
+            cancelled = true;
+        };
+    }, [datasets, executeSql]);
+    return states;
+}
+//# sourceMappingURL=usePreparedDeckDatasets.js.map

package/dist/datasets/usePreparedDeckDatasets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePreparedDeckDatasets.js","sourceRoot":"","sources":["../../src/datasets/usePreparedDeckDatasets.ts"],"names":[],"mappings":"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","sourcesContent":["import {useEffect, useState} from 'react';\nimport {useStoreWithDuckDb} from '@sqlrooms/duckdb';\nimport type {DeckDatasetInput, PreparedDeckDatasetState} from '../types';\nimport {resolveArrowTable} from './normalizeDatasets';\nimport {prepareDeckDataset} from '../prepare/prepareDeckDataset';\n\nexport function usePreparedDeckDatasets(\n  datasets: Record<string, DeckDatasetInput>,\n): Record<string, PreparedDeckDatasetState> {\n  const executeSql = useStoreWithDuckDb((state) => state.db.executeSql);\n  const [states, setStates] = useState<Record<string, PreparedDeckDatasetState>>(\n    {},\n  );\n\n  useEffect(() => {\n    let cancelled = false;\n\n    setStates(\n      Object.fromEntries(\n        Object.entries(datasets).map(([datasetId, input]) => [\n          datasetId,\n          input.sqlQuery ? {status: 'loading'} : {status: 'loading'},\n        ]),\n      ),\n    );\n\n    for (const [datasetId, input] of Object.entries(datasets)) {\n      const run = async () => {\n        try {\n          let table = resolveArrowTable(input);\n          if (!table && input.sqlQuery) {\n            const queryHandle = await executeSql(input.sqlQuery);\n            if (!queryHandle) {\n              throw new Error(`Query for dataset \"${datasetId}\" was cancelled.`);\n            }\n            table = await queryHandle;\n          }\n\n          if (!table) {\n            throw new Error(`Dataset \"${datasetId}\" could not resolve an Arrow table.`);\n          }\n\n          const prepared = prepareDeckDataset({\n            datasetId,\n            table,\n            geometryColumn: input.geometryColumn,\n            geometryEncodingHint: input.geometryEncodingHint,\n          });\n\n          if (!cancelled) {\n            setStates((current) => ({\n              ...current,\n              [datasetId]: {status: 'ready', prepared},\n            }));\n          }\n        } catch (error) {\n          if (!cancelled) {\n            setStates((current) => ({\n              ...current,\n              [datasetId]: {\n                status: 'error',\n                error: error instanceof Error ? error : new Error(String(error)),\n              },\n            }));\n          }\n        }\n      };\n\n      void run();\n    }\n\n    return () => {\n      cancelled = true;\n    };\n  }, [datasets, executeSql]);\n\n  return states;\n}\n"]}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * {@include ../README.md}
+ * @packageDocumentation
+ */
+export { DeckMap } from './DeckMap';
+export { ColorScaleLegend } from './ColorScaleLegend';
+export { createDeckJsonConfiguration } from './json/createDeckJsonConfiguration';
+export { prepareDeckDataset } from './prepare/prepareDeckDataset';
+export type { DeckDatasetInput, DeckMapProps, DeckQueryResultLike, LayerColorLegendConfig, LayerColorScale, LayerColorScaleProp, LayerExtensionProps, PreparedDeckDatasetState, } from './types';
+export type { GeometryEncodingHint, PreparedDeckDataset, PreparedGeoArrowLayerData, ResolvedGeometryColumn, ResolvedGeometryEncoding, } from './prepare/types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAC;AAClC,OAAO,EAAC,gBAAgB,EAAC,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAC,2BAA2B,EAAC,MAAM,oCAAoC,CAAC;AAC/E,OAAO,EAAC,kBAAkB,EAAC,MAAM,8BAA8B,CAAC;AAEhE,YAAY,EACV,gBAAgB,EAChB,YAAY,EACZ,mBAAmB,EACnB,sBAAsB,EACtB,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,wBAAwB,GACzB,MAAM,SAAS,CAAC;AACjB,YAAY,EACV,oBAAoB,EACpB,mBAAmB,EACnB,yBAAyB,EACzB,sBAAsB,EACtB,wBAAwB,GACzB,MAAM,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,9 @@
+/**
+ * {@include ../README.md}
+ * @packageDocumentation
+ */
+export { DeckMap } from './DeckMap';
+export { ColorScaleLegend } from './ColorScaleLegend';
+export { createDeckJsonConfiguration } from './json/createDeckJsonConfiguration';
+export { prepareDeckDataset } from './prepare/prepareDeckDataset';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAC;AAClC,OAAO,EAAC,gBAAgB,EAAC,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAC,2BAA2B,EAAC,MAAM,oCAAoC,CAAC;AAC/E,OAAO,EAAC,kBAAkB,EAAC,MAAM,8BAA8B,CAAC","sourcesContent":["/**\n * {@include ../README.md}\n * @packageDocumentation\n */\n\nexport {DeckMap} from './DeckMap';\nexport {ColorScaleLegend} from './ColorScaleLegend';\nexport {createDeckJsonConfiguration} from './json/createDeckJsonConfiguration';\nexport {prepareDeckDataset} from './prepare/prepareDeckDataset';\n\nexport type {\n  DeckDatasetInput,\n  DeckMapProps,\n  DeckQueryResultLike,\n  LayerColorLegendConfig,\n  LayerColorScale,\n  LayerColorScaleProp,\n  LayerExtensionProps,\n  PreparedDeckDatasetState,\n} from './types';\nexport type {\n  GeometryEncodingHint,\n  PreparedDeckDataset,\n  PreparedGeoArrowLayerData,\n  ResolvedGeometryColumn,\n  ResolvedGeometryEncoding,\n} from './prepare/types';\n"]}

package/dist/json/compileColorScale.d.ts

@@ -0,0 +1,35 @@
+import type * as arrow from 'apache-arrow';
+import type { LayerColorScale } from '../types';
+export type ResolvedColorLegend = {
+    type: 'continuous';
+    title: string;
+    gradient: string;
+    ticks: Array<{
+        label: string;
+        offset: number;
+    }>;
+} | {
+    type: 'stepped';
+    title: string;
+    items: Array<{
+        label: string;
+        color: [number, number, number, number];
+    }>;
+} | {
+    type: 'categorical';
+    title: string;
+    items: Array<{
+        label: string;
+        color: [number, number, number, number];
+    }>;
+};
+export declare function compileColorScale(options: {
+    table: arrow.Table;
+    colorScale: LayerColorScale;
+}): (value: unknown) => [number, number, number, number];
+export declare function buildColorScaleLegend(options: {
+    table: arrow.Table;
+    colorScale: LayerColorScale;
+    title?: string;
+}): ResolvedColorLegend | null;
+//# sourceMappingURL=compileColorScale.d.ts.map

package/dist/json/compileColorScale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compileColorScale.d.ts","sourceRoot":"","sources":["../../src/json/compileColorScale.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAC;AAW3C,OAAO,KAAK,EAKV,eAAe,EAChB,MAAM,UAAU,CAAC;AA+GlB,MAAM,MAAM,mBAAmB,GAC3B;IACE,IAAI,EAAE,YAAY,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,KAAK,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;CAC/C,GACD;IACE,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,KAAK,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;KAAC,CAAC,CAAC;CACxE,GACD;IACE,IAAI,EAAE,aAAa,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,KAAK,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;KAAC,CAAC,CAAC;CACxE,CAAC;AA0SN,wBAAgB,iBAAiB,CAAC,OAAO,EAAE;IACzC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC;IACnB,UAAU,EAAE,eAAe,CAAC;CAC7B,WAdgB,OAAO,sCAqKvB;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE;IAC7C,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC;IACnB,UAAU,EAAE,eAAe,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,GAAG,mBAAmB,GAAG,IAAI,CAgJ7B"}

package/dist/json/compileColorScale.js

@@ -0,0 +1,527 @@
+import { rgb } from 'd3-color';
+import { scaleDiverging, scaleOrdinal, scaleQuantile, scaleQuantize, scaleSequential, scaleThreshold, } from 'd3-scale';
+import * as chromatic from 'd3-scale-chromatic';
+const DEFAULT_NULL_COLOR = [0, 0, 0, 0];
+const DEFAULT_UNKNOWN_COLOR = [
+    180, 180, 180, 180,
+];
+const DEFAULT_BIN_COUNT = 5;
+const CONTINUOUS_SEQUENTIAL_SCHEMES = {
+    Blues: chromatic.interpolateBlues,
+    BuGn: chromatic.interpolateBuGn,
+    BuPu: chromatic.interpolateBuPu,
+    Cividis: chromatic.interpolateCividis,
+    Cool: chromatic.interpolateCool,
+    CubehelixDefault: chromatic.interpolateCubehelixDefault,
+    GnBu: chromatic.interpolateGnBu,
+    Greens: chromatic.interpolateGreens,
+    Greys: chromatic.interpolateGreys,
+    Inferno: chromatic.interpolateInferno,
+    Magma: chromatic.interpolateMagma,
+    OrRd: chromatic.interpolateOrRd,
+    Oranges: chromatic.interpolateOranges,
+    Plasma: chromatic.interpolatePlasma,
+    PuBu: chromatic.interpolatePuBu,
+    PuBuGn: chromatic.interpolatePuBuGn,
+    PuRd: chromatic.interpolatePuRd,
+    Purples: chromatic.interpolatePurples,
+    Rainbow: chromatic.interpolateRainbow,
+    RdPu: chromatic.interpolateRdPu,
+    Reds: chromatic.interpolateReds,
+    Sinebow: chromatic.interpolateSinebow,
+    Turbo: chromatic.interpolateTurbo,
+    Viridis: chromatic.interpolateViridis,
+    Warm: chromatic.interpolateWarm,
+    YlGn: chromatic.interpolateYlGn,
+    YlGnBu: chromatic.interpolateYlGnBu,
+    YlOrBr: chromatic.interpolateYlOrBr,
+    YlOrRd: chromatic.interpolateYlOrRd,
+};
+const CONTINUOUS_DIVERGING_SCHEMES = {
+    BrBG: chromatic.interpolateBrBG,
+    PRGn: chromatic.interpolatePRGn,
+    PiYG: chromatic.interpolatePiYG,
+    PuOr: chromatic.interpolatePuOr,
+    RdBu: chromatic.interpolateRdBu,
+    RdGy: chromatic.interpolateRdGy,
+    RdYlBu: chromatic.interpolateRdYlBu,
+    RdYlGn: chromatic.interpolateRdYlGn,
+    Spectral: chromatic.interpolateSpectral,
+};
+const DISCRETE_NUMERIC_SCHEMES = {
+    Blues: chromatic.schemeBlues,
+    BuGn: chromatic.schemeBuGn,
+    BuPu: chromatic.schemeBuPu,
+    GnBu: chromatic.schemeGnBu,
+    Greens: chromatic.schemeGreens,
+    Greys: chromatic.schemeGreys,
+    OrRd: chromatic.schemeOrRd,
+    Oranges: chromatic.schemeOranges,
+    PuBu: chromatic.schemePuBu,
+    PuBuGn: chromatic.schemePuBuGn,
+    PuRd: chromatic.schemePuRd,
+    Purples: chromatic.schemePurples,
+    RdPu: chromatic.schemeRdPu,
+    Reds: chromatic.schemeReds,
+    YlGn: chromatic.schemeYlGn,
+    YlGnBu: chromatic.schemeYlGnBu,
+    YlOrBr: chromatic.schemeYlOrBr,
+    YlOrRd: chromatic.schemeYlOrRd,
+    BrBG: chromatic.schemeBrBG,
+    PRGn: chromatic.schemePRGn,
+    PiYG: chromatic.schemePiYG,
+    PuOr: chromatic.schemePuOr,
+    RdBu: chromatic.schemeRdBu,
+    RdGy: chromatic.schemeRdGy,
+    RdYlBu: chromatic.schemeRdYlBu,
+    RdYlGn: chromatic.schemeRdYlGn,
+    Spectral: chromatic.schemeSpectral,
+};
+const CATEGORICAL_SCHEMES = {
+    Accent: chromatic.schemeAccent,
+    Category10: chromatic.schemeCategory10,
+    Dark2: chromatic.schemeDark2,
+    Observable10: chromatic.schemeObservable10,
+    Paired: chromatic.schemePaired,
+    Pastel1: chromatic.schemePastel1,
+    Pastel2: chromatic.schemePastel2,
+    Set1: chromatic.schemeSet1,
+    Set2: chromatic.schemeSet2,
+    Set3: chromatic.schemeSet3,
+    Tableau10: chromatic.schemeTableau10,
+};
+function createNullColorAccessor(nullColor) {
+    return () => nullColor;
+}
+function normalizeColor(color, fallback) {
+    if (!color) {
+        return fallback;
+    }
+    return [color[0], color[1], color[2], color[3] ?? 255];
+}
+function parseColorString(value, alpha = 255) {
+    const parsed = rgb(value);
+    return [parsed.r, parsed.g, parsed.b, alpha];
+}
+function formatLegendNumber(value) {
+    return new Intl.NumberFormat('en-US', {
+        maximumFractionDigits: Math.abs(value) >= 100 ? 0 : 2,
+    }).format(value);
+}
+function resolveFieldName(schemaOwner, requestedField) {
+    const exactMatch = schemaOwner.schema.fields.find((field) => field.name === requestedField)?.name;
+    if (exactMatch) {
+        return exactMatch;
+    }
+    const caseInsensitiveMatches = schemaOwner.schema.fields
+        .map((field) => field.name)
+        .filter((fieldName) => fieldName.toLowerCase() === requestedField.toLowerCase());
+    if (caseInsensitiveMatches.length === 1) {
+        return caseInsensitiveMatches[0];
+    }
+    return undefined;
+}
+function getColumn(table, field) {
+    const resolvedFieldName = resolveFieldName(table, field);
+    if (!resolvedFieldName) {
+        throw new Error(`Unknown colorScale field "${field}".`);
+    }
+    const vector = table.getChild(resolvedFieldName);
+    if (!vector) {
+        throw new Error(`Unable to read colorScale field "${resolvedFieldName}".`);
+    }
+    return {
+        fieldName: resolvedFieldName,
+        vector,
+    };
+}
+function getRowValue(row, fieldName) {
+    if (!row || typeof row !== 'object') {
+        return undefined;
+    }
+    const object = row;
+    const sources = [
+        object,
+        object.properties,
+    ].filter((value) => Boolean(value && typeof value === 'object'));
+    for (const source of sources) {
+        if (fieldName in source) {
+            return source[fieldName];
+        }
+        const caseInsensitiveMatches = Object.keys(source).filter((key) => key.toLowerCase() === fieldName.toLowerCase());
+        if (caseInsensitiveMatches.length === 1) {
+            return source[caseInsensitiveMatches[0]];
+        }
+    }
+    return undefined;
+}
+function toFiniteNumber(value) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : undefined;
+    }
+    if (typeof value === 'bigint') {
+        return Number(value);
+    }
+    if (typeof value === 'string' && value.trim() !== '') {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    return undefined;
+}
+function getNumericValues(vector) {
+    const values = [];
+    for (let index = 0; index < vector.length; index += 1) {
+        const numericValue = toFiniteNumber(vector.get(index));
+        if (numericValue !== undefined) {
+            values.push(numericValue);
+        }
+    }
+    return values;
+}
+function getSequentialDomain(values) {
+    const min = Math.min(...values);
+    const max = Math.max(...values);
+    if (min === max) {
+        return [min - 1, max + 1];
+    }
+    return [min, max];
+}
+function getDivergingDomain(values) {
+    const min = Math.min(...values);
+    const max = Math.max(...values);
+    if (min === max) {
+        return [min - 1, min, max + 1];
+    }
+    if (min < 0 && max > 0) {
+        return [min, 0, max];
+    }
+    return [min, (min + max) / 2, max];
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+function clampBinCount(bins) {
+    return Math.max(2, Math.round(bins));
+}
+function sampleInterpolator(interpolator, bins) {
+    if (bins === 1) {
+        return [interpolator(0.5)];
+    }
+    return Array.from({ length: bins }, (_, index) => interpolator(index / (bins - 1)));
+}
+function getNumericInterpolator(scheme) {
+    const sequential = CONTINUOUS_SEQUENTIAL_SCHEMES[scheme];
+    if (sequential) {
+        return sequential;
+    }
+    return CONTINUOUS_DIVERGING_SCHEMES[scheme];
+}
+function getDiscreteNumericColors(options) {
+    const { scheme, reverse } = options;
+    const bins = clampBinCount(options.bins);
+    const discreteScheme = DISCRETE_NUMERIC_SCHEMES[scheme];
+    const directColors = discreteScheme[bins];
+    const colors = Array.isArray(directColors)
+        ? [...directColors]
+        : sampleInterpolator(getNumericInterpolator(scheme) ??
+            (() => {
+                throw new Error(`Unsupported numeric colorScale scheme "${scheme}".`);
+            })(), bins);
+    return reverse ? colors.reverse() : colors;
+}
+function formatExtentLabel(extent) {
+    const start = toFiniteNumber(extent[0]);
+    const end = toFiniteNumber(extent[1]);
+    if (start === undefined && end === undefined) {
+        return 'unknown';
+    }
+    if (start === undefined && end !== undefined) {
+        return `< ${formatLegendNumber(end)}`;
+    }
+    if (start !== undefined && end === undefined) {
+        return `>= ${formatLegendNumber(start)}`;
+    }
+    return `${formatLegendNumber(start)} - ${formatLegendNumber(end)}`;
+}
+function buildSteppedLegendItems(scale, range) {
+    return range.map((color) => ({
+        label: formatExtentLabel(scale.invertExtent(color)),
+        color: parseColorString(color),
+    }));
+}
+function buildGradient(interpolator) {
+    return `linear-gradient(to right, ${[0, 0.25, 0.5, 0.75, 1]
+        .map((offset) => `${interpolator(offset)} ${offset * 100}%`)
+        .join(', ')})`;
+}
+function getGeoArrowOrRowValue(options) {
+    const { value, fieldName, vector } = options;
+    if (value &&
+        typeof value === 'object' &&
+        'index' in value &&
+        typeof value.index === 'number') {
+        const objectInfo = value;
+        const batch = objectInfo.data?.data;
+        const batchFieldName = batch
+            ? resolveFieldName(batch, fieldName)
+            : undefined;
+        if (batch && batchFieldName) {
+            return batch.getChild(batchFieldName)?.get(objectInfo.index);
+        }
+        return vector.get(objectInfo.index);
+    }
+    return getRowValue(value, fieldName);
+}
+function createContinuousAccessor(options) {
+    const { fieldName, vector, nullColor, colorForValue } = options;
+    return (value) => {
+        const rawValue = getGeoArrowOrRowValue({ value, fieldName, vector });
+        const numericValue = toFiniteNumber(rawValue);
+        if (numericValue === undefined) {
+            return nullColor;
+        }
+        return parseColorString(colorForValue(numericValue));
+    };
+}
+export function compileColorScale(options) {
+    const { table, colorScale } = options;
+    const { fieldName, vector } = getColumn(table, colorScale.field);
+    const nullColor = normalizeColor(colorScale.nullColor, DEFAULT_NULL_COLOR);
+    if (colorScale.type === 'categorical') {
+        const baseRange = CATEGORICAL_SCHEMES[colorScale.scheme];
+        if (!baseRange) {
+            throw new Error(`Unsupported categorical colorScale scheme "${colorScale.scheme}".`);
+        }
+        const range = colorScale.reverse
+            ? [...baseRange].reverse()
+            : [...baseRange];
+        const scale = scaleOrdinal(range);
+        const unknownColor = normalizeColor(colorScale.unknownColor, DEFAULT_UNKNOWN_COLOR);
+        return (value) => {
+            const rawValue = getGeoArrowOrRowValue({ value, fieldName, vector });
+            if (rawValue == null) {
+                return nullColor;
+            }
+            if (typeof rawValue !== 'string' &&
+                typeof rawValue !== 'number' &&
+                typeof rawValue !== 'boolean') {
+                return unknownColor;
+            }
+            return parseColorString(scale(String(rawValue)));
+        };
+    }
+    const numericValues = getNumericValues(vector);
+    if (numericValues.length === 0) {
+        return createNullColorAccessor(nullColor);
+    }
+    if (colorScale.type === 'sequential') {
+        const interpolator = CONTINUOUS_SEQUENTIAL_SCHEMES[colorScale.scheme];
+        const domain = colorScale.domain === 'auto'
+            ? getSequentialDomain(numericValues)
+            : colorScale.domain;
+        const colorInterpolator = colorScale.reverse
+            ? (t) => interpolator(1 - t)
+            : interpolator;
+        const scale = scaleSequential(colorInterpolator).domain(domain);
+        if (colorScale.clamp) {
+            scale.clamp(true);
+        }
+        return createContinuousAccessor({
+            fieldName,
+            vector,
+            nullColor,
+            colorForValue: (value) => scale(value),
+        });
+    }
+    if (colorScale.type === 'diverging') {
+        const interpolator = CONTINUOUS_DIVERGING_SCHEMES[colorScale.scheme];
+        const domain = colorScale.domain === 'auto'
+            ? getDivergingDomain(numericValues)
+            : colorScale.domain;
+        const colorInterpolator = colorScale.reverse
+            ? (t) => interpolator(1 - t)
+            : interpolator;
+        const scale = scaleDiverging(colorInterpolator).domain(domain);
+        if (colorScale.clamp) {
+            scale.clamp(true);
+        }
+        return createContinuousAccessor({
+            fieldName,
+            vector,
+            nullColor,
+            colorForValue: (value) => scale(value),
+        });
+    }
+    if (colorScale.type === 'quantize') {
+        const range = getDiscreteNumericColors({
+            scheme: colorScale.scheme,
+            bins: colorScale.bins ?? DEFAULT_BIN_COUNT,
+            reverse: colorScale.reverse,
+        });
+        const domain = colorScale.domain === 'auto'
+            ? getSequentialDomain(numericValues)
+            : colorScale.domain;
+        const scale = scaleQuantize()
+            .domain(domain)
+            .range(range);
+        return createContinuousAccessor({
+            fieldName,
+            vector,
+            nullColor,
+            colorForValue: scale,
+        });
+    }
+    if (colorScale.type === 'quantile') {
+        const range = getDiscreteNumericColors({
+            scheme: colorScale.scheme,
+            bins: colorScale.bins ?? DEFAULT_BIN_COUNT,
+            reverse: colorScale.reverse,
+        });
+        const scale = scaleQuantile()
+            .domain(numericValues)
+            .range(range);
+        return createContinuousAccessor({
+            fieldName,
+            vector,
+            nullColor,
+            colorForValue: scale,
+        });
+    }
+    const thresholds = [...colorScale.thresholds].sort((left, right) => left - right);
+    if (!thresholds.length) {
+        throw new Error('Threshold colorScale requires at least one threshold.');
+    }
+    const range = getDiscreteNumericColors({
+        scheme: colorScale.scheme,
+        bins: thresholds.length + 1,
+        reverse: colorScale.reverse,
+    });
+    const scale = scaleThreshold()
+        .domain(thresholds)
+        .range(range);
+    return createContinuousAccessor({
+        fieldName,
+        vector,
+        nullColor,
+        colorForValue: (value) => scale(value),
+    });
+}
+export function buildColorScaleLegend(options) {
+    const { table, colorScale, title } = options;
+    const { fieldName, vector } = getColumn(table, colorScale.field);
+    const resolvedTitle = title && title.trim() ? title.trim() : fieldName;
+    if (colorScale.type === 'categorical') {
+        const baseRange = CATEGORICAL_SCHEMES[colorScale.scheme];
+        const range = colorScale.reverse
+            ? [...baseRange].reverse()
+            : [...baseRange];
+        const values = unique(Array.from({ length: vector.length }, (_, index) => vector.get(index)).filter((value) => value != null &&
+            (typeof value === 'string' ||
+                typeof value === 'number' ||
+                typeof value === 'boolean')));
+        if (values.length === 0) {
+            return null;
+        }
+        return {
+            type: 'categorical',
+            title: resolvedTitle,
+            items: values.map((value, index) => ({
+                label: String(value),
+                color: parseColorString(range[index % range.length]),
+            })),
+        };
+    }
+    const numericValues = getNumericValues(vector);
+    if (numericValues.length === 0) {
+        return null;
+    }
+    if (colorScale.type === 'sequential') {
+        const interpolator = CONTINUOUS_SEQUENTIAL_SCHEMES[colorScale.scheme];
+        const domain = colorScale.domain === 'auto'
+            ? getSequentialDomain(numericValues)
+            : colorScale.domain;
+        const colorInterpolator = colorScale.reverse
+            ? (t) => interpolator(1 - t)
+            : interpolator;
+        return {
+            type: 'continuous',
+            title: resolvedTitle,
+            gradient: buildGradient(colorInterpolator),
+            ticks: [
+                { label: formatLegendNumber(domain[0]), offset: 0 },
+                { label: formatLegendNumber((domain[0] + domain[1]) / 2), offset: 50 },
+                { label: formatLegendNumber(domain[1]), offset: 100 },
+            ],
+        };
+    }
+    if (colorScale.type === 'diverging') {
+        const interpolator = CONTINUOUS_DIVERGING_SCHEMES[colorScale.scheme];
+        const domain = colorScale.domain === 'auto'
+            ? getDivergingDomain(numericValues)
+            : colorScale.domain;
+        const colorInterpolator = colorScale.reverse
+            ? (t) => interpolator(1 - t)
+            : interpolator;
+        return {
+            type: 'continuous',
+            title: resolvedTitle,
+            gradient: buildGradient(colorInterpolator),
+            ticks: [
+                { label: formatLegendNumber(domain[0]), offset: 0 },
+                { label: formatLegendNumber(domain[1]), offset: 50 },
+                { label: formatLegendNumber(domain[2]), offset: 100 },
+            ],
+        };
+    }
+    if (colorScale.type === 'quantize') {
+        const range = getDiscreteNumericColors({
+            scheme: colorScale.scheme,
+            bins: colorScale.bins ?? DEFAULT_BIN_COUNT,
+            reverse: colorScale.reverse,
+        });
+        const domain = colorScale.domain === 'auto'
+            ? getSequentialDomain(numericValues)
+            : colorScale.domain;
+        const scale = scaleQuantize()
+            .domain(domain)
+            .range(range);
+        return {
+            type: 'stepped',
+            title: resolvedTitle,
+            items: buildSteppedLegendItems(scale, range),
+        };
+    }
+    if (colorScale.type === 'quantile') {
+        const range = getDiscreteNumericColors({
+            scheme: colorScale.scheme,
+            bins: colorScale.bins ?? DEFAULT_BIN_COUNT,
+            reverse: colorScale.reverse,
+        });
+        const scale = scaleQuantile()
+            .domain(numericValues)
+            .range(range);
+        return {
+            type: 'stepped',
+            title: resolvedTitle,
+            items: buildSteppedLegendItems(scale, range),
+        };
+    }
+    const thresholds = [...colorScale.thresholds].sort((left, right) => left - right);
+    if (!thresholds.length) {
+        return null;
+    }
+    const range = getDiscreteNumericColors({
+        scheme: colorScale.scheme,
+        bins: thresholds.length + 1,
+        reverse: colorScale.reverse,
+    });
+    const scale = scaleThreshold()
+        .domain(thresholds)
+        .range(range);
+    return {
+        type: 'stepped',
+        title: resolvedTitle,
+        items: buildSteppedLegendItems(scale, range),
+    };
+}
+//# sourceMappingURL=compileColorScale.js.map