@sakuzu/maplibre-gl-draw 1.0.0

package/dist/display/columnar/source.js

@@ -0,0 +1,531 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { toPackedPointStyle } from '../../view/renderers/batch-manager.js';
+import { toLineInstanceColor } from '../../view/renderers/line/line-geometry.js';
+import { toInstancedPointShape, } from '../../view/renderers/point/point-instance.js';
+import { evaluateStyleRuleValue, getStyleRuleChannel } from '../../view/style-rule.js';
+import { toDisplayChunks } from '../chunk.js';
+import { COLLECT_SLICE_ROWS, FIXED_WIDTH_ZOOM, isDrapedGeometry, PackedLinesBuilder, PackedPointsBuilder, pushFallback, } from '../retained.js';
+import { DisplaySpatialIndex } from '../spatial.js';
+import { prepareDatasetColumnar } from './prepare.js';
+import { ColumnarTable, columnValue, isDictionaryColumn, } from './table.js';
+/** The column the zoom of creation of a row is read from (the same key as on a feature) */
+const CREATED_ZOOM_COLUMN = 'createdZoom';
+/** The key of the slots for "no rule color" */
+const NO_RULE_COLOR = '';
+/** The slots of a geometry type (created on the first request) */
+function slotsOfType(maps, type) {
+    let slots = maps.get(type);
+    if (!slots) {
+        slots = new Map();
+        maps.set(type, slots);
+    }
+    return slots;
+}
+/**
+ * The styles of the rows of a table, resolved once per geometry type and rule color
+ */
+class ColumnarStyleSlots {
+    constructor(table, styler, resolver) {
+        Object.defineProperty(this, "table", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: table
+        });
+        Object.defineProperty(this, "styler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: styler
+        });
+        Object.defineProperty(this, "resolver", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: resolver
+        });
+        Object.defineProperty(this, "points", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "lines", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "polygons", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        /** The rule color of each code, when the rule reads a dictionary column */
+        Object.defineProperty(this, "codeColors", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+    }
+    /**
+     * The rule color of a row (null without a rule)
+     *
+     * The same color the rule gives the feature of the row: the rule reads one column, and the
+     * property of the feature is the value of that column.
+     */
+    ruleColorOf(row) {
+        const rule = this.styler.rule;
+        if (!rule)
+            return null;
+        if (rule.kind === 'single')
+            return rule.color;
+        const column = this.table.columns[rule.property];
+        if (column === undefined)
+            return evaluateStyleRuleValue(rule, undefined);
+        if (isDictionaryColumn(column)) {
+            const code = column.codes[row];
+            const cached = code >= 0 ? this.codeColors[code] : undefined;
+            if (cached !== undefined)
+                return cached;
+            const color = evaluateStyleRuleValue(rule, columnValue(column, row));
+            if (code >= 0)
+                this.codeColors[code] = color;
+            return color;
+        }
+        return evaluateStyleRuleValue(rule, columnValue(column, row));
+    }
+    point(type, color) {
+        const key = color ?? NO_RULE_COLOR;
+        const slots = slotsOfType(this.points, type);
+        let slot = slots.get(key);
+        if (!slot) {
+            const style = this.resolver.getPointStyle(this.probe(type, color));
+            slot = { shape: toInstancedPointShape(style.shape), packed: toPackedPointStyle(style) };
+            slots.set(key, slot);
+        }
+        return slot;
+    }
+    line(type, color) {
+        const key = color ?? NO_RULE_COLOR;
+        const slots = slotsOfType(this.lines, type);
+        let slot = slots.get(key);
+        if (!slot) {
+            const stroke = this.resolver.getLineStringStrokeStyle(this.probe(type, color));
+            slot = { stroke, color: toLineInstanceColor(stroke.color, stroke.opacity) };
+            slots.set(key, slot);
+        }
+        return slot;
+    }
+    polygon(type, color) {
+        const key = color ?? NO_RULE_COLOR;
+        const slots = slotsOfType(this.polygons, type);
+        let slot = slots.get(key);
+        if (!slot) {
+            const { fillColor, strokeStyle } = this.resolver.getPolygonStyles(this.probe(type, color));
+            const hasStroke = strokeStyle.opacity > 0 && strokeStyle.width > 0;
+            const styleFor = (strokeWidth) => ({
+                fillColor,
+                fillOpacity: 1,
+                strokeColor: strokeStyle.color,
+                strokeWidth,
+                strokeOpacity: hasStroke ? 1 : 0,
+            });
+            slot = {
+                fillColor,
+                strokeStyle,
+                hasStroke,
+                fixedStyle: styleFor(hasStroke ? -strokeStyle.width : 0),
+                scaledStyle: styleFor(hasStroke ? strokeStyle.width : 0),
+            };
+            slots.set(key, slot);
+        }
+        return slot;
+    }
+    /** A feature of a geometry type carrying the style a row with this rule color gets */
+    probe(type, color) {
+        return {
+            id: '',
+            type,
+            coordinates: [],
+            layerId: '',
+            properties: {},
+            style: this.styler.effectiveStyle(undefined, color, getStyleRuleChannel(type)),
+            locked: false,
+            visible: true,
+        };
+    }
+}
+/**
+ * The contents of a dataset given as a columnar table
+ *
+ * @internal
+ */
+export class ColumnarSource {
+    /**
+     * @param prepared The result of `prepareDatasetColumnar` for this table (computed here when
+     *   omitted)
+     * @throws when the table does not add up, or when `prepared` was made for another length
+     */
+    constructor(input, prepared) {
+        Object.defineProperty(this, "table", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "length", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "bounds", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "chunks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "index", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new DisplaySpatialIndex()
+        });
+        /** The rows have no individual style */
+        Object.defineProperty(this, "maxStylePointRadius", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        /** The features of every row with a geometry, built on the first request */
+        Object.defineProperty(this, "allFeatures", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        /** The row of each id, built on the first request (only with an ids column) */
+        Object.defineProperty(this, "rowById", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        /** The resolved styles, and what they were resolved with */
+        Object.defineProperty(this, "slots", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "slotsKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        this.table = new ColumnarTable(input);
+        this.length = this.table.length;
+        const ready = prepared ?? prepareDatasetColumnar(input);
+        if (ready.length !== this.length || ready.bounds.length !== this.length * 4) {
+            throw new Error(`Columnar input: prepared was made for ${ready.length} rows, the table has ${this.length}`);
+        }
+        this.bounds = ready.bounds;
+        this.chunks = toDisplayChunks({
+            rows: ready.chunkRows,
+            offsets: ready.chunkOffsets,
+            bounds: ready.chunkBounds,
+        });
+        this.index.adopt({
+            nodeSize: ready.indexNodeSize,
+            numItems: ready.indexItemCount,
+            boxes: ready.indexBoxes,
+            indices: ready.indexEntries,
+            levelBounds: ready.indexLevels,
+        });
+    }
+    hasGeometry(row) {
+        return !Number.isNaN(this.bounds[row * 4]);
+    }
+    featureAt(row) {
+        return this.table.featureAt(row, this.hasGeometry(row));
+    }
+    idOf(row) {
+        return this.table.idOf(row);
+    }
+    typeOf(row) {
+        return this.hasGeometry(row) ? (this.table.columnOf(row)?.type ?? null) : null;
+    }
+    rowsOfIds(ids) {
+        const rows = new Set();
+        for (const id of ids) {
+            const row = this.rowOfId(id);
+            if (row >= 0 && this.hasGeometry(row))
+                rows.add(row);
+        }
+        return [...rows].sort((a, b) => a - b);
+    }
+    features() {
+        if (!this.allFeatures) {
+            const features = [];
+            for (let row = 0; row < this.length; row++) {
+                if (this.hasGeometry(row))
+                    features.push(this.featureAt(row));
+            }
+            this.allFeatures = features;
+        }
+        return this.allFeatures;
+    }
+    thinningRole(row) {
+        if (!this.hasGeometry(row))
+            return 'skip';
+        return this.table.columnOf(row)?.type === 'Point' ? 'point' : 'winner';
+    }
+    pointOf(row) {
+        const column = this.table.columnOf(row);
+        return column.position(this.table.childRowOf(row));
+    }
+    styleRadiusOf() {
+        return undefined;
+    }
+    collector(rows, context) {
+        const table = this.table;
+        // Whether the solid lines and polygons of each child are left to the analytic drape
+        const skipDraped = table.children.map((column) => context.skipDrapedFills === true && isDraped(column.type));
+        const createdZoom = table.columns[CREATED_ZOOM_COLUMN];
+        let next = 0;
+        let lastFallbackRow = -1;
+        return {
+            collect: (draft, styles, deadline, now) => {
+                const slots = this.slotsFor(context, styles);
+                const collect = new RowCollector(this, draft, slots, (row) => {
+                    // A Multi geometry comes around once per part; it is sent to immediate mode once
+                    if (row === lastFallbackRow)
+                        return;
+                    lastFallbackRow = row;
+                    pushFallback(draft, context.styler.prepareIfStyled(this.featureAt(row)));
+                });
+                const createdZoomOf = (row) => {
+                    if (createdZoom === undefined)
+                        return undefined;
+                    const value = columnValue(createdZoom, row);
+                    return typeof value === 'number' ? value : undefined;
+                };
+                while (next < rows.length) {
+                    const end = Math.min(rows.length, next + COLLECT_SLICE_ROWS);
+                    for (; next < end; next++) {
+                        const row = rows[next];
+                        if (!context.isDrawn(row))
+                            continue;
+                        const child = table.childOf(row);
+                        if (child < 0)
+                            continue;
+                        const column = table.children[child];
+                        const at = table.childRowOf(row);
+                        const o = column.offsets;
+                        const skip = skipDraped[child];
+                        switch (column.type) {
+                            case 'Point':
+                                // Only a point needs the feature for the predicate of the external renderer
+                                if (context.isExternallyRenderedPoint?.(context.styler.prepareIfStyled(this.featureAt(row)))) {
+                                    break;
+                                }
+                                collect.point(row, column, at);
+                                break;
+                            case 'MultiPoint':
+                                for (let v = o[0][at]; v < o[0][at + 1]; v++)
+                                    collect.point(row, column, v);
+                                break;
+                            case 'LineString':
+                                if (context.pointsOnly)
+                                    break;
+                                collect.line(row, column, o[0][at], o[0][at + 1], createdZoomOf(row), skip);
+                                break;
+                            case 'MultiLineString':
+                                if (context.pointsOnly)
+                                    break;
+                                for (let p = o[0][at]; p < o[0][at + 1]; p++) {
+                                    collect.line(row, column, o[1][p], o[1][p + 1], createdZoomOf(row), skip);
+                                }
+                                break;
+                            case 'Polygon':
+                                if (context.pointsOnly)
+                                    break;
+                                collect.polygon(row, column, o[0][at], o[0][at + 1], o[1], 0, createdZoomOf(row), skip);
+                                break;
+                            case 'MultiPolygon':
+                                if (context.pointsOnly)
+                                    break;
+                                for (let p = o[0][at]; p < o[0][at + 1]; p++) {
+                                    collect.polygon(row, column, o[1][p], o[1][p + 1], o[2], p - o[0][at], createdZoomOf(row), skip);
+                                }
+                                break;
+                        }
+                    }
+                    if (now() >= deadline)
+                        break;
+                }
+                return next >= rows.length;
+            },
+        };
+    }
+    rowOfId(id) {
+        const table = this.table;
+        if (!table.ids) {
+            const row = Number(id);
+            return Number.isInteger(row) && row >= 0 && row < this.length && String(row) === id
+                ? row
+                : -1;
+        }
+        if (!this.rowById) {
+            const map = new Map();
+            for (let row = 0; row < this.length; row++)
+                map.set(table.idOf(row), row);
+            this.rowById = map;
+        }
+        return this.rowById.get(id) ?? -1;
+    }
+    // === Internals ===
+    /** The resolved styles for this dataset and resolver (dropped when the style changed) */
+    slotsFor(context, resolver) {
+        const key = this.slotsKey;
+        if (!this.slots ||
+            !key ||
+            key[0] !== context.styleKey ||
+            key[1] !== context.styler ||
+            key[2] !== resolver) {
+            this.slots = new ColumnarStyleSlots(this.table, context.styler, resolver);
+            this.slotsKey = [context.styleKey, context.styler, resolver];
+        }
+        return this.slots;
+    }
+}
+/** Whether the analytic drape draws the rows of this type */
+function isDraped(type) {
+    return isDrapedGeometry({ type });
+}
+/**
+ * Pushes the parts of the rows of one dataset into the intermediate data of one build
+ *
+ * The decisions are those of `collectFeature` in `retained.ts`, made on the arrays of the table.
+ */
+class RowCollector {
+    constructor(source, draft, slots, fallback) {
+        Object.defineProperty(this, "source", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: source
+        });
+        Object.defineProperty(this, "draft", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: draft
+        });
+        Object.defineProperty(this, "slots", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: slots
+        });
+        Object.defineProperty(this, "fallback", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: fallback
+        });
+    }
+    /**
+     * A point at coordinate `v` of the geometry column of the row (a shape without instancing
+     * support goes to immediate mode)
+     */
+    point(row, column, v) {
+        const slot = this.slots.point(column.type, this.slots.ruleColorOf(row));
+        if (!slot.shape) {
+            this.fallback(row);
+            return;
+        }
+        let builder = this.draft.packedPoints.get(slot.shape);
+        if (!builder) {
+            builder = new PackedPointsBuilder();
+            this.draft.packedPoints.set(slot.shape, builder);
+        }
+        const at = v * column.dimensions;
+        builder.push(column.coords[at], column.coords[at + 1], slot.packed);
+    }
+    /**
+     * A line over the coordinates `[start, end)` of the geometry column of the row (a dashed line
+     * goes to immediate mode)
+     */
+    line(row, column, start, end, createdZoom, skipSolid) {
+        if (end - start < 2)
+            return;
+        const slot = this.slots.line(column.type, this.slots.ruleColorOf(row));
+        const stroke = slot.stroke;
+        if (stroke.lineStyle !== 'solid') {
+            this.fallback(row);
+            return;
+        }
+        // A solid line is drawn by the analytic drape as ground pixels (in this frame only)
+        if (skipSolid && stroke.opacity > 0 && stroke.width > 0)
+            return;
+        const draft = this.draft;
+        const fixed = createdZoom === undefined;
+        let builder = fixed ? draft.packedFixedLines : draft.packedScaledLines;
+        if (!builder) {
+            builder = new PackedLinesBuilder();
+            if (fixed)
+                draft.packedFixedLines = builder;
+            else
+                draft.packedScaledLines = builder;
+        }
+        // A fixed line width is declared by the negative convention (as in `collectLine`)
+        builder.push(column.coords, column.dimensions, start, end, fixed ? -stroke.width : stroke.width, createdZoom ?? FIXED_WIDTH_ZOOM, slot.color);
+    }
+    /**
+     * A polygon made of the rings `[ringStart, ringEnd)` of the geometry column of the row (a dashed
+     * outline goes to immediate mode)
+     *
+     * @param ringOffsets The offsets from a ring to its coordinates
+     */
+    polygon(row, column, ringStart, ringEnd, ringOffsets, partIndex, createdZoom, skipSolid) {
+        if (ringEnd <= ringStart)
+            return;
+        if (ringOffsets[ringStart + 1] - ringOffsets[ringStart] < 3)
+            return;
+        const slot = this.slots.polygon(column.type, this.slots.ruleColorOf(row));
+        if (slot.hasStroke && slot.strokeStyle.lineStyle !== 'solid') {
+            this.fallback(row);
+            return;
+        }
+        if (!slot.hasStroke && slot.fillColor[3] <= 0)
+            return;
+        // The solid fill and outline are drawn by the analytic drape as ground pixels
+        if (skipSolid)
+            return;
+        const rings = new Array(ringEnd - ringStart);
+        for (let r = ringStart; r < ringEnd; r++) {
+            rings[r - ringStart] = column.positions(ringOffsets[r], ringOffsets[r + 1]);
+        }
+        const fixed = createdZoom === undefined;
+        (fixed ? this.draft.fixedPolygons : this.draft.scaledPolygons).push({
+            coordinates: rings,
+            style: fixed ? slot.fixedStyle : slot.scaledStyle,
+            createdZoom: createdZoom ?? FIXED_WIDTH_ZOOM,
+            featureId: this.source.idOf(row),
+            partIndex,
+        });
+    }
+}

package/dist/display/columnar/table.d.ts

@@ -0,0 +1 @@
+export {};