@zwishing/emap 0.1.0

package/dist/map/ops/affine.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { AffineLayerOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function affineLayer(ctx: OpContext, opts: AffineLayerOptions): Promise<OpResult>;

package/dist/map/ops/buffer.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { BufferOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function bufferLayer(ctx: OpContext, opts: BufferOptions): Promise<OpResult>;

package/dist/map/ops/check-geometry.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { CheckGeometryOptions, GeometryCheckReport } from '../types';
+import type { OpContext } from './_context';
+export declare function checkGeometry(ctx: OpContext, opts: CheckGeometryOptions): Promise<OpResult<GeometryCheckReport>>;

package/dist/map/ops/clean.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { CleanOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function cleanLayer(ctx: OpContext, opts: CleanOptions): Promise<OpResult>;

package/dist/map/ops/clip-erase.d.ts

@@ -0,0 +1,5 @@
+import { type OpResult } from '../op-result';
+import type { ClipEraseOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function clipLayer(ctx: OpContext, opts: ClipEraseOptions): Promise<OpResult>;
+export declare function eraseLayer(ctx: OpContext, opts: ClipEraseOptions): Promise<OpResult>;

package/dist/map/ops/data-fill.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { DataFillOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function dataFill(ctx: OpContext, opts: DataFillOptions): Promise<OpResult>;

package/dist/map/ops/dissolve.d.ts

@@ -0,0 +1,20 @@
+import { type OpResult } from '../op-result';
+import type { DissolveOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function dissolveLayer(ctx: OpContext, opts: DissolveOptions): Promise<OpResult>;
+/**
+ * Merge the currently-selected features (when they all share the same
+ * source/layer) into one feature via the same `-dissolve` pipeline.
+ *
+ * Recipe:
+ *   1. Stamp a discriminator field directly onto records — selected rows
+ *      get `'M'`, unselected rows get a unique `'k_<id>'` so they pass
+ *      through dissolve unchanged.
+ *   2. Run `-dissolve __emap_merge copy-fields=<all original>`.
+ *   3. Drop the discriminator with `-filter-fields __emap_merge invert`.
+ *
+ * Direct record mutation (instead of an `-each EXPR` pre-pass that
+ * embedded `JSON.stringify(selectedIds)` to test membership) keeps the
+ * command string size O(1) regardless of selection cardinality.
+ */
+export declare function mergeSelected(ctx: OpContext): Promise<OpResult>;

package/dist/map/ops/divide.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { DivideOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function divideLayer(ctx: OpContext, opts: DivideOptions): Promise<OpResult>;

package/dist/map/ops/drop-layer.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { DropLayerOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function dropLayer(ctx: OpContext, opts: DropLayerOptions): Promise<OpResult>;

package/dist/map/ops/each-filter.d.ts

@@ -0,0 +1,5 @@
+import { type OpResult } from '../op-result';
+import type { ApplyExpressionOptions, FilterOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function applyExpression(ctx: OpContext, opts: ApplyExpressionOptions): Promise<OpResult>;
+export declare function filterFeatures(ctx: OpContext, opts: FilterOptions): Promise<OpResult>;

package/dist/map/ops/explode.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { ExplodeOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function explodeLayer(ctx: OpContext, opts: ExplodeOptions): Promise<OpResult>;

package/dist/map/ops/filter-fields.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { FilterFieldsOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function filterFields(ctx: OpContext, opts: FilterFieldsOptions): Promise<OpResult>;

package/dist/map/ops/filter-geom.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { FilterGeomOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function filterGeom(ctx: OpContext, opts: FilterGeomOptions): Promise<OpResult>;

package/dist/map/ops/filter-islands.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { FilterIslandsOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function filterIslands(ctx: OpContext, opts: FilterIslandsOptions): Promise<OpResult>;

package/dist/map/ops/filter-slivers.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { FilterSliversOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function filterSlivers(ctx: OpContext, opts: FilterSliversOptions): Promise<OpResult>;

package/dist/map/ops/innerlines.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { InnerlinesOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function innerlinesLayer(ctx: OpContext, opts: InnerlinesOptions): Promise<OpResult>;

package/dist/map/ops/intersection-points.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { IntersectionPointsLayerOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function intersectionPointsLayer(ctx: OpContext, opts: IntersectionPointsLayerOptions): Promise<OpResult>;

package/dist/map/ops/join-table.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { JoinTableOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function joinTable(ctx: OpContext, opts: JoinTableOptions): Promise<OpResult>;

package/dist/map/ops/lines.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { LinesOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function linesLayer(ctx: OpContext, opts: LinesOptions): Promise<OpResult>;

package/dist/map/ops/merge-layers.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { MergeLayersOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function mergeLayers(ctx: OpContext, opts: MergeLayersOptions): Promise<OpResult>;

package/dist/map/ops/mosaic.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { MosaicOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function mosaicLayer(ctx: OpContext, opts: MosaicOptions): Promise<OpResult>;

package/dist/map/ops/points.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { PointsOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function pointsLayer(ctx: OpContext, opts: PointsOptions): Promise<OpResult>;

package/dist/map/ops/polygons.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { PolygonsOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function polygonsLayer(ctx: OpContext, opts: PolygonsOptions): Promise<OpResult>;

package/dist/map/ops/project.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { ProjectOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function projectLayer(ctx: OpContext, opts: ProjectOptions): Promise<OpResult>;

package/dist/map/ops/rebuild-topology.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { RebuildTopologyOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function rebuildTopology(ctx: OpContext, opts: RebuildTopologyOptions): Promise<OpResult>;

package/dist/map/ops/rename-fields.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { RenameFieldsOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function renameFields(ctx: OpContext, opts: RenameFieldsOptions): Promise<OpResult>;

package/dist/map/ops/rename-layer.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { RenameLayerOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function renameLayer(ctx: OpContext, opts: RenameLayerOptions): Promise<OpResult>;

package/dist/map/ops/simplify.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { SimplifyOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function simplifyLayer(ctx: OpContext, opts: SimplifyOptions): Promise<OpResult>;

package/dist/map/ops/snap.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { SnapOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function snapLayer(ctx: OpContext, opts: SnapOptions): Promise<OpResult>;

package/dist/map/ops/sort-features.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { SortFeaturesOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function sortFeatures(ctx: OpContext, opts: SortFeaturesOptions): Promise<OpResult>;

package/dist/map/ops/split-layer.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { SplitLayerOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function splitLayer(ctx: OpContext, opts: SplitLayerOptions): Promise<OpResult>;

package/dist/map/ops/union.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { UnionOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function unionLayers(ctx: OpContext, opts: UnionOptions): Promise<OpResult>;

package/dist/map/ops/unique-features.d.ts

@@ -0,0 +1,4 @@
+import { type OpResult } from '../op-result';
+import type { UniqueFeaturesOptions } from '../types';
+import type { OpContext } from './_context';
+export declare function uniqueFeatures(ctx: OpContext, opts: UniqueFeaturesOptions): Promise<OpResult>;

package/dist/map/selection.d.ts

@@ -0,0 +1,73 @@
+import type { FeatureRef } from './map';
+/** Mutation modes for {@link Selection.apply}. */
+export type SelectMode = 'replace' | 'add' | 'toggle';
+/** Diff produced by every selection mutation. */
+export interface SelectionDiff {
+    /** Refs newly present after the mutation */
+    added: FeatureRef[];
+    /** Refs newly absent after the mutation */
+    removed: FeatureRef[];
+    /** True when at least one of `added` / `removed` is non-empty */
+    changed: boolean;
+}
+/**
+ * Opaque snapshot returned by {@link Selection.snapshot} and consumed by
+ * {@link Selection.restore}. Implementation detail — do not depend on
+ * the concrete shape.
+ */
+export type SelectionSnapshot = ReadonlySet<string>;
+/**
+ * Persistent multi-source / multi-layer feature selection.
+ *
+ * Storage shape mirrors `HighlightManager`: `Map<source, Map<layer, Set<id>>>`.
+ * That gives O(1) `has` checks, O(1) iteration per layer for downstream
+ * operations, and free deduplication.
+ *
+ * Distinct from highlight on purpose: selection is persistent state ("what
+ * the next operation will act on"), highlight is transient render state
+ * ("what to draw extra strokes on right now").
+ */
+export declare class Selection {
+    private _byKey;
+    private _size;
+    /** Number of distinct selected features across all source/layer pairs. */
+    get size(): number;
+    /** Returns `true` when the given feature is currently in the selection. */
+    has(ref: FeatureRef): boolean;
+    /** Flat list of every selected ref, in insertion order within each layer. */
+    getAll(): FeatureRef[];
+    /** Numeric ids selected within a single source/layer, in insertion order. */
+    getByLayer(source: string, layer: string): number[];
+    /** Remove every entry. Returns the diff of refs that were actually cleared. */
+    clear(): SelectionDiff;
+    /**
+     * Mutate the set according to `mode`:
+     * - `replace`: result is exactly `refs` (clears prior state)
+     * - `add`: union of current state and `refs`
+     * - `toggle`: each ref is flipped (present → removed, absent → added)
+     *
+     * Returns a diff so the caller can fire events with `{ added, removed }`.
+     */
+    apply(refs: ReadonlyArray<FeatureRef>, mode: SelectMode): SelectionDiff;
+    /** Remove the listed refs. Refs not present in the selection are skipped silently. */
+    remove(refs: ReadonlyArray<FeatureRef>): SelectionDiff;
+    /**
+     * Capture the current selection as an opaque snapshot. The returned
+     * value is meant to be handed back to {@link restore} later — its
+     * shape (currently `Set<string>` of encoded refs) is an implementation
+     * detail and may change.
+     *
+     * Used by `Transaction` for rollback so a transaction-internal
+     * operation that clears the selection can be reverted.
+     */
+    snapshot(): SelectionSnapshot;
+    /**
+     * Replace the current selection with the contents of a previously
+     * captured snapshot. Returns the diff between the old state and the
+     * restored state so callers can fire a single `selectionchange` event.
+     */
+    restore(snap: SelectionSnapshot): SelectionDiff;
+    private _addOne;
+    private _removeOne;
+    private _refSetSnapshot;
+}