@sakuzu/maplibre-gl-draw 1.0.0 → 2.0.0

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

@@ -1,42 +0,0 @@
-import type { DatasetColumnarInput, DatasetColumnarPrepared } from './types.js';
-/**
- * Computes the bboxes, the spatial chunks and the spatial index of a columnar table.
- *
- * It is the work that `Dataset.setColumnar` would otherwise do on the main thread. Call it where the table is read (in a Worker), send the result along with the table,
- * and pass both to `setColumnar` (or to `addDataset` as `columnar` and `prepared`). It
- * uses neither maplibre nor WebGL, so it runs in any Worker.
- *
- * @param input The table
- * @returns The prepared arrays, which belong to this table only
- * @throws when the shape of the table does not add up (the same checks as `setColumnar`)
- *
- * @example In a Worker
- * ```ts
- * import { columnarTransferables, prepareDatasetColumnar } from '@sakuzu/maplibre-gl-draw/columnar';
- *
- * self.onmessage = async (event) => {
- *   const input = await readTable(event.data); // your reader: a DatasetColumnarInput
- *   const prepared = prepareDatasetColumnar(input);
- *   self.postMessage({ input, prepared }, columnarTransferables(input, prepared));
- * };
- * ```
- */
-export declare function prepareDatasetColumnar(input: DatasetColumnarInput): DatasetColumnarPrepared;
-/**
- * Lists the buffers of a columnar table (and of its prepared arrays) for the transfer list of
- * `postMessage`, so that they move to the other thread without a copy.
- *
- * The geometry arrays of every child of a mixed geometry column are listed too. Each buffer
- * appears once, even when several arrays share it. A `SharedArrayBuffer` is left out
- * (it is shared, not moved). After the transfer the arrays are empty on the sending side.
- *
- * @param input The table
- * @param prepared The result of {@link prepareDatasetColumnar} for the table (optional)
- * @returns The buffers to pass as the transfer list
- *
- * @example
- * ```ts
- * worker.postMessage({ input, prepared }, columnarTransferables(input, prepared));
- * ```
- */
-export declare function columnarTransferables(input: DatasetColumnarInput, prepared?: DatasetColumnarPrepared): ArrayBuffer[];

package/dist/display/columnar/prepare.js

@@ -1,116 +0,0 @@
-// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
-// SPDX-License-Identifier: AGPL-3.0-only
-/**
- * The preparation of a columnar table, callable in a Worker
- *
- * It computes what a dataset needs before it can draw and hit test a table: the
- * bbox of every row, the spatial chunks and the spatial index. Done in a Worker together with the
- * reading of a file, the main thread receives the table and this result without a copy and
- * computes none of it again.
- *
- * A pure module: it depends on neither maplibre nor WebGL nor the DOM.
- */
-import { buildPackedRTree } from '../packed-rtree.js';
-import { partitionRows } from '../partition.js';
-import { ColumnarTable, isDictionaryColumn } from './table.js';
-/**
- * Computes the bboxes, the spatial chunks and the spatial index of a columnar table.
- *
- * It is the work that `Dataset.setColumnar` would otherwise do on the main thread. Call it where the table is read (in a Worker), send the result along with the table,
- * and pass both to `setColumnar` (or to `addDataset` as `columnar` and `prepared`). It
- * uses neither maplibre nor WebGL, so it runs in any Worker.
- *
- * @param input The table
- * @returns The prepared arrays, which belong to this table only
- * @throws when the shape of the table does not add up (the same checks as `setColumnar`)
- *
- * @example In a Worker
- * ```ts
- * import { columnarTransferables, prepareDatasetColumnar } from '@sakuzu/maplibre-gl-draw/columnar';
- *
- * self.onmessage = async (event) => {
- *   const input = await readTable(event.data); // your reader: a DatasetColumnarInput
- *   const prepared = prepareDatasetColumnar(input);
- *   self.postMessage({ input, prepared }, columnarTransferables(input, prepared));
- * };
- * ```
- */
-export function prepareDatasetColumnar(input) {
-    const table = new ColumnarTable(input);
-    const bounds = table.computeBounds();
-    const chunks = partitionRows(bounds, table.computeVertexCounts());
-    const index = buildPackedRTree(bounds);
-    return {
-        length: table.length,
-        bounds,
-        chunkRows: chunks.rows,
-        chunkOffsets: chunks.offsets,
-        chunkBounds: chunks.bounds,
-        indexNodeSize: index.nodeSize,
-        indexItemCount: index.numItems,
-        indexBoxes: index.boxes,
-        indexEntries: index.indices,
-        indexLevels: index.levelBounds,
-    };
-}
-/**
- * Lists the buffers of a columnar table (and of its prepared arrays) for the transfer list of
- * `postMessage`, so that they move to the other thread without a copy.
- *
- * The geometry arrays of every child of a mixed geometry column are listed too. Each buffer
- * appears once, even when several arrays share it. A `SharedArrayBuffer` is left out
- * (it is shared, not moved). After the transfer the arrays are empty on the sending side.
- *
- * @param input The table
- * @param prepared The result of {@link prepareDatasetColumnar} for the table (optional)
- * @returns The buffers to pass as the transfer list
- *
- * @example
- * ```ts
- * worker.postMessage({ input, prepared }, columnarTransferables(input, prepared));
- * ```
- */
-export function columnarTransferables(input, prepared) {
-    const buffers = new Set();
-    const add = (view) => {
-        if (view && view.buffer instanceof ArrayBuffer)
-            buffers.add(view.buffer);
-    };
-    const addColumn = (column) => {
-        if (!column)
-            return;
-        if (isDictionaryColumn(column))
-            add(column.codes);
-        else if (ArrayBuffer.isView(column))
-            add(column);
-    };
-    const addGeometry = (geometry) => {
-        add(geometry.coords);
-        for (const offsets of geometry.offsets ?? [])
-            add(offsets);
-    };
-    const geometry = input.geometry;
-    if (geometry.type === 'Mixed') {
-        add(geometry.types);
-        add(geometry.offsets);
-        for (const child of geometry.children)
-            addGeometry(child);
-    }
-    else {
-        addGeometry(geometry);
-    }
-    add(input.validity);
-    addColumn(input.ids);
-    for (const column of Object.values(input.columns ?? {}))
-        addColumn(column);
-    if (prepared) {
-        add(prepared.bounds);
-        add(prepared.chunkRows);
-        add(prepared.chunkOffsets);
-        add(prepared.chunkBounds);
-        add(prepared.indexBoxes);
-        add(prepared.indexEntries);
-        add(prepared.indexLevels);
-    }
-    return [...buffers];
-}

package/dist/display/index.d.ts

@@ -1,13 +0,0 @@
-/**
- * Display module
- *
- * Read-only layers that show large amounts of data (datasets). They are a
- * path independent of the Store and do not go through the mechanisms of editing,
- * undo or events.
- *
- * Only the symbols that src/index.ts publishes are listed here (see "The public
- * surface" in CONTRIBUTING.md). Internal code imports from the defining file.
- */
-export type { DatasetColumn, DatasetColumnarGeometry, DatasetColumnarGeometryType, DatasetColumnarInput, DatasetColumnarMixedGeometry, DatasetColumnarPrepared, DatasetDictionaryCodes, DatasetDictionaryColumn, } from './columnar/types.js';
-export type { DatasetCollisionThinning, DatasetThinningStats, ResolvedCollisionThinning, } from './thinning.js';
-export type { Dataset, DatasetBaseStyle, DatasetChangePayload, DatasetClickEventPayload, DatasetClickPayload, DatasetEventMap, DatasetFeatureInput, DatasetFeatureProvider, DatasetHoverPayload, DatasetOptions, DatasetOrder, DatasetPlacement, DatasetZoomScale, } from './types.js';

package/dist/display/types.js

@@ -1,43 +0,0 @@
-// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
-// SPDX-License-Identifier: AGPL-3.0-only
-/** Recursively checks whether it contains a position with 3 or more elements */
-function hasExtraPositionElements(value) {
-    if (typeof value[0] === 'number') {
-        return value.length !== 2;
-    }
-    return value.some(hasExtraPositionElements);
-}
-/** Returns a copy with every position truncated to the 2 elements [longitude, latitude] */
-function truncatePositions(value) {
-    if (typeof value[0] === 'number') {
-        return [value[0], value[1]];
-    }
-    return value.map(truncatePositions);
-}
-/**
- * Normalizes the input into a feature of the same shape as in the Store
- *
- * It fills in the optional fields and, since it is not put into the Store, layerId defaults to an
- * empty string. The coordinates may contain 3-element positions coming from GeoJSON (with an
- * elevation), so a copy truncated to 2 elements is made only when they do (ordinary input with
- * only 2 elements is not copied).
- *
- * @internal
- */
-export function normalizeDisplayFeature(input) {
-    const coords = input.coordinates;
-    const coordinates = hasExtraPositionElements(coords)
-        ? truncatePositions(coords)
-        : input.coordinates;
-    return {
-        id: input.id,
-        type: input.type,
-        coordinates,
-        layerId: input.layerId ?? '',
-        groupId: input.groupId,
-        properties: input.properties ?? {},
-        style: input.style,
-        locked: input.locked ?? false,
-        visible: input.visible !== false,
-    };
-}

package/dist/maplibre-gl-draw.d.ts

@@ -1,47 +0,0 @@
-/**
- * The factory of a draw instance: it builds the context, the event bridge, the rendering,
- * the input handling, the modes and the plugin manager, and registers the release of each
- * one for destroy.
- *
- * The Store is the single source of truth: input goes through the dispatcher into the Store,
- * and the view and the events follow the Store's notifications.
- */
-import type { Map as MapLibreMap } from 'maplibre-gl';
-import type { MapLibreGLDraw } from './api/api.js';
-import type { Options } from './api/context.js';
-export type { EventPayloads, MapLibreGLDraw } from './api/api.js';
-export type { Options } from './api/context.js';
-export type { ImportExportAPI } from './api/import-export/index.js';
-export type { Data, LoadResult, Metadata } from './store/types.js';
-/**
- * Creates a draw instance on a MapLibre map: the drawing and editing tools, their rendering and
- * their input handling.
- *
- * It can be called before, while or after the map loads. The render layers are added as soon
- * as the style accepts layers, and added again after `setStyle`. Unless
- * `initDefaultLayer: false` is given, the document starts with one empty layer. The instance
- * turns off the map's box zoom (Shift + drag selects features instead) and gives it back on
- * {@link MapLibreGLDraw.destroy}. Several instances can share a page, each on its own map.
- *
- * @param map the MapLibre map to draw on
- * @param options the options; every one can be omitted (see {@link Options})
- * @returns the draw instance
- *
- * @example
- * ```typescript
- * import { createMapLibreGLDraw } from '@sakuzu/maplibre-gl-draw';
- * import * as maplibregl from 'maplibre-gl';
- *
- * const map = new maplibregl.Map({
- *   container: 'map',
- *   style: 'https://demotiles.maplibre.org/style.json',
- *   center: [139.767, 35.681],
- *   zoom: 12,
- * });
- * const draw = createMapLibreGLDraw(map, { defaultMode: 'select' });
- *
- * draw.setMode('draw_polygon');
- * draw.on('draw.feature.create', ({ feature }) => console.log('Created', feature.id));
- * ```
- */
-export declare function createMapLibreGLDraw(map: MapLibreMap, options?: Options): MapLibreGLDraw;

package/dist/modes/cursor.js

@@ -1,72 +0,0 @@
-// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
-// SPDX-License-Identifier: AGPL-3.0-only
-import { getCursorForHandle, hitTestHandles, } from '../view/ui/handle-test.js';
-/**
- * Cursor management class
- *
- * @internal
- */
-export class CursorManager {
-    constructor(canvas, defaultCursor = 'default') {
-        Object.defineProperty(this, "canvas", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "defaultCursor", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.canvas = canvas;
-        this.defaultCursor = defaultCursor;
-    }
-    /**
-     * Sets the default cursor
-     */
-    setDefault() {
-        this.canvas.style.cursor = this.defaultCursor;
-    }
-    /**
-     * Sets the cursor
-     */
-    set(cursor) {
-        this.canvas.style.cursor = cursor;
-    }
-    /**
-     * Sets the cursor based on the handle hit result
-     */
-    setForHandle(handleHit) {
-        this.canvas.style.cursor = getCursorForHandle(handleHit);
-    }
-    /**
-     * Sets the pointer cursor
-     */
-    setPointer() {
-        this.canvas.style.cursor = 'pointer';
-    }
-    /**
-     * Sets the text cursor
-     */
-    setText() {
-        this.canvas.style.cursor = 'text';
-    }
-    /**
-     * Updates the cursor based on the selected features and the mouse position
-     *
-     * @returns true if a handle was hit
-     */
-    updateForSelection(screenPoint, selectedFeatures, bbox, transform, config, zoom, scope) {
-        if (!bbox || selectedFeatures.length === 0) {
-            return false;
-        }
-        const handleHit = hitTestHandles(screenPoint, selectedFeatures, transform, config, zoom, scope);
-        if (handleHit) {
-            this.setForHandle(handleHit);
-            return true;
-        }
-        return false;
-    }
-}

package/dist/modes/index.d.ts

@@ -1,7 +0,0 @@
-/**
- * Modes module
- *
- * Only the symbols that src/index.ts publishes are listed here (see "The public
- * surface" in CONTRIBUTING.md). Internal code imports from the defining file.
- */
-export type { ModeContext, ModeFactory, ModeHandler, SnapInputType } from './handler.js';

package/dist/operations/index.d.ts

@@ -1,9 +0,0 @@
-/**
- * Operations module
- *
- * Only the symbols that src/index.ts publishes are listed here (see "The public
- * surface" in CONTRIBUTING.md). Internal code imports from the defining file.
- */
-export type { ResizeState } from './resize.js';
-export type { TraceGraph, TraceGraphEdge, TraceGraphEndpoint, TraceGraphNode, } from './trace-graph.js';
-export { buildTraceGraph, findTracePath } from './trace-graph.js';

package/dist/operations/index.js

@@ -1,3 +0,0 @@
-// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
-// SPDX-License-Identifier: AGPL-3.0-only
-export { buildTraceGraph, findTracePath } from './trace-graph.js';

package/dist/plugins/index.d.ts

@@ -1,10 +0,0 @@
-/**
- * Plugin System
- *
- * Public API of the plugin system.
- *
- * Only the symbols that src/index.ts publishes are listed here (see "The public
- * surface" in CONTRIBUTING.md). Internal code imports from the defining file.
- */
-export type { DragEndData, DragStartData, Hooks, HoverEvent, MouseLeaveEvent, MutationContext, Plugin, PluginContext, } from './plugin.js';
-export type { HookName, PluginManager } from './plugin-manager.js';

package/dist/plugins/mutation-hooks.d.ts

@@ -1,28 +0,0 @@
-/**
- * Mutation hooks
- *
- * Fires the after-mutation hooks of the plugins (feature / group / layer create, update and
- * delete, and the selection change) from the change notification of the Store. Every write
- * reaches the Store, so a hook sees every mutation whatever made it: the public API, a
- * drawing mode, a drag, the Delete key, import, a plugin, or a change applied from outside to
- * a replaced Store.
- *
- * The hooks run after the Store has changed, once per notification (one transaction), and
- * the hooks of one notification share its batchId and its source. The intermediate updates
- * of an edit in progress (isIntermediate) are not reported; the committing update that
- * follows them is.
- */
-import type { Store } from '../store/store.js';
-import type { StateChanges } from '../store/types.js';
-import type { MutationContext } from './plugin.js';
-import type { PluginManager } from './plugin-manager.js';
-/**
- * Subscribes to the Store and fires the mutation hooks of the plugins
- *
- * @returns the function that stops it
- */
-export declare function subscribeMutationHooks(store: Store, pluginManager: PluginManager): () => void;
-/**
- * Fires the mutation hooks for one change notification of the Store
- */
-export declare function runMutationHooks(pluginManager: PluginManager, changes: StateChanges, ctx: MutationContext): void;

package/dist/plugins/mutation-hooks.js

@@ -1,84 +0,0 @@
-// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
-// SPDX-License-Identifier: AGPL-3.0-only
-/**
- * Subscribes to the Store and fires the mutation hooks of the plugins
- *
- * @returns the function that stops it
- */
-export function subscribeMutationHooks(store, pluginManager) {
-    let notification = 0;
-    return store.subscribe((changes) => {
-        runMutationHooks(pluginManager, changes, {
-            source: changes.source ?? 'local',
-            batchId: `change_${++notification}`,
-        });
-    });
-}
-/**
- * Fires the mutation hooks for one change notification of the Store
- */
-export function runMutationHooks(pluginManager, changes, ctx) {
-    const { features, groups, layers, selection } = changes;
-    if (features) {
-        if (features.created && features.created.length > 0) {
-            pluginManager.runHook('feature:afterCreate', [...features.created], ctx);
-        }
-        const committed = foldCommittedUpdates(features.updated);
-        if (committed.updated.length > 0) {
-            pluginManager.runHook('feature:afterUpdate', committed.updated, committed.original, ctx);
-        }
-        if (features.deleted && features.deleted.length > 0) {
-            pluginManager.runHook('feature:afterDelete', [...features.deleted], ctx);
-        }
-    }
-    if (groups) {
-        for (const group of groups.created ?? []) {
-            pluginManager.runHook('group:afterCreate', group, ctx);
-        }
-        for (const entry of groups.updated ?? []) {
-            pluginManager.runHook('group:afterUpdate', entry.group, entry.previous, ctx);
-        }
-        for (const group of groups.deleted ?? []) {
-            pluginManager.runHook('group:afterDelete', group, ctx);
-        }
-    }
-    if (layers) {
-        for (const layer of layers.created ?? []) {
-            pluginManager.runHook('layer:afterCreate', layer, ctx);
-        }
-        for (const entry of layers.updated ?? []) {
-            pluginManager.runHook('layer:afterUpdate', entry.layer, entry.previous, ctx);
-        }
-        for (const layer of layers.deleted ?? []) {
-            pluginManager.runHook('layer:afterDelete', layer, ctx);
-        }
-    }
-    if (selection) {
-        pluginManager.runHook('selection:afterChange', [...selection.ids], [...selection.previousIds], ctx);
-    }
-}
-/**
- * Folds the committed updates of one notification into one entry per feature (the last
- * state, and the state before the first update), in the order of their first update
- */
-function foldCommittedUpdates(updates) {
-    const byId = new Map();
-    for (const entry of updates ?? []) {
-        if (entry.isIntermediate)
-            continue;
-        const existing = byId.get(entry.id);
-        if (existing) {
-            existing.feature = entry.feature;
-        }
-        else {
-            byId.set(entry.id, { feature: entry.feature, previous: entry.previous });
-        }
-    }
-    const updated = [];
-    const original = [];
-    for (const { feature, previous } of byId.values()) {
-        updated.push(feature);
-        original.push(previous);
-    }
-    return { updated, original };
-}