geo-polygonize 0.33.1 → 0.35.0

package/dist/slim/es/index_threads.d.ts

@@ -16,4 +16,5 @@ export * from "./bindings/TilingOptions";
 export * from "./bindings/TouchPolicy";
 export * from "./bindings/ZOptions";
 export * from "./bindings/ZPolicy";
+export * from "./cfb";
 export default init;

package/dist/slim/pkg-scalar/geo_polygonize.d.ts

@@ -0,0 +1,119 @@
+import { PolygonizerOptions } from '../pkg-wrapper/bindings/PolygonizerOptions';
+/* tslint:disable */
+/* eslint-disable */
+
+export class PolygonizerWasmError {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(name: string, message: string);
+    readonly message: string;
+    readonly name: string;
+}
+
+export class WasmPolygonResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    coords_len(): number;
+    coords_ptr(): number;
+    flat_line_ids_len(): number;
+    flat_line_ids_ptr(): number;
+    polygon_offsets_len(): number;
+    polygon_offsets_ptr(): number;
+    ring_offsets_len(): number;
+    ring_offsets_ptr(): number;
+    stride(): number;
+    readonly cut_edges: any;
+    readonly dangles: any;
+    readonly diagnostics: any;
+    readonly invalid_rings: any;
+    readonly provenance: any;
+}
+
+export function polygonize(geojson_str: string, node_input?: boolean | null, snap_grid_size?: number | null, extract_only_polygonal?: boolean | null, report_mode?: boolean | null): string;
+
+/**
+ * Polygonizes an Arrow IPC stream containing a GeoArrow LineString array.
+ *
+ * This zero-copy path avoids JSON serialization overhead and returns a binary
+ * Arrow IPC stream containing a GeoArrow Polygon array. Requires the options
+ * to be passed as a parsed JS object.
+ */
+export function polygonizeGeoArrowWithOptions(ipc_bytes: Uint8Array, options_val: Partial<PolygonizerOptions>): Uint8Array;
+
+/**
+ * Polygonizes a GeoJSON FeatureCollection using the canonical `PolygonizerOptions`.
+ *
+ * This is the primary entry point for JavaScript users. It accepts a JSON string
+ * of options and returns a JSON string representing the result, including faces,
+ * dangles, cut-lines, and (optionally) provenance/diagnostics.
+ */
+export function polygonizeWithOptions(geojson_str: string, options_val: Partial<PolygonizerOptions>): string;
+
+export function polygonizeWithOptionsBuffer(coords: Float64Array, offsets: Uint32Array, stride: number, options_val: Partial<PolygonizerOptions>, line_ids?: Uint32Array | null): WasmPolygonResult;
+
+export function polygonize_buffers(coords: Float64Array, offsets: Uint32Array, stride: number, node_input: boolean, snap_grid_size: number, line_ids?: Uint32Array | null): WasmPolygonResult;
+
+export function polygonize_geoarrow(ipc_bytes: Uint8Array, node_input: boolean, snap_grid_size: number, extract_only_polygonal: boolean): Uint8Array;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_polygonizerwasmerror_free: (a: number, b: number) => void;
+    readonly __wbg_wasmpolygonresult_free: (a: number, b: number) => void;
+    readonly polygonize: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number, number];
+    readonly polygonizeGeoArrowWithOptions: (a: number, b: number, c: any) => [number, number, number, number];
+    readonly polygonizeWithOptions: (a: number, b: number, c: any) => [number, number, number, number];
+    readonly polygonizeWithOptionsBuffer: (a: number, b: number, c: number, d: number, e: number, f: any, g: number, h: number) => [number, number, number];
+    readonly polygonize_buffers: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
+    readonly polygonize_geoarrow: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
+    readonly polygonizerwasmerror_message: (a: number) => [number, number];
+    readonly polygonizerwasmerror_name: (a: number) => [number, number];
+    readonly polygonizerwasmerror_new: (a: number, b: number, c: number, d: number) => number;
+    readonly wasmpolygonresult_coords_len: (a: number) => number;
+    readonly wasmpolygonresult_coords_ptr: (a: number) => number;
+    readonly wasmpolygonresult_cut_edges: (a: number) => any;
+    readonly wasmpolygonresult_dangles: (a: number) => any;
+    readonly wasmpolygonresult_diagnostics: (a: number) => any;
+    readonly wasmpolygonresult_flat_line_ids_len: (a: number) => number;
+    readonly wasmpolygonresult_flat_line_ids_ptr: (a: number) => number;
+    readonly wasmpolygonresult_invalid_rings: (a: number) => any;
+    readonly wasmpolygonresult_polygon_offsets_len: (a: number) => number;
+    readonly wasmpolygonresult_polygon_offsets_ptr: (a: number) => number;
+    readonly wasmpolygonresult_provenance: (a: number) => any;
+    readonly wasmpolygonresult_ring_offsets_len: (a: number) => number;
+    readonly wasmpolygonresult_ring_offsets_ptr: (a: number) => number;
+    readonly wasmpolygonresult_stride: (a: number) => number;
+    readonly polygonize_ffi: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly polygonize_with_options_ffi: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    readonly polygonize_result_free: () => void;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/dist/slim/pkg-scalar/geo_polygonize_bg.wasm.d.ts

@@ -0,0 +1,37 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_polygonizerwasmerror_free: (a: number, b: number) => void;
+export const __wbg_wasmpolygonresult_free: (a: number, b: number) => void;
+export const polygonize: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number, number];
+export const polygonizeGeoArrowWithOptions: (a: number, b: number, c: any) => [number, number, number, number];
+export const polygonizeWithOptions: (a: number, b: number, c: any) => [number, number, number, number];
+export const polygonizeWithOptionsBuffer: (a: number, b: number, c: number, d: number, e: number, f: any, g: number, h: number) => [number, number, number];
+export const polygonize_buffers: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
+export const polygonize_geoarrow: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
+export const polygonizerwasmerror_message: (a: number) => [number, number];
+export const polygonizerwasmerror_name: (a: number) => [number, number];
+export const polygonizerwasmerror_new: (a: number, b: number, c: number, d: number) => number;
+export const wasmpolygonresult_coords_len: (a: number) => number;
+export const wasmpolygonresult_coords_ptr: (a: number) => number;
+export const wasmpolygonresult_cut_edges: (a: number) => any;
+export const wasmpolygonresult_dangles: (a: number) => any;
+export const wasmpolygonresult_diagnostics: (a: number) => any;
+export const wasmpolygonresult_flat_line_ids_len: (a: number) => number;
+export const wasmpolygonresult_flat_line_ids_ptr: (a: number) => number;
+export const wasmpolygonresult_invalid_rings: (a: number) => any;
+export const wasmpolygonresult_polygon_offsets_len: (a: number) => number;
+export const wasmpolygonresult_polygon_offsets_ptr: (a: number) => number;
+export const wasmpolygonresult_provenance: (a: number) => any;
+export const wasmpolygonresult_ring_offsets_len: (a: number) => number;
+export const wasmpolygonresult_ring_offsets_ptr: (a: number) => number;
+export const wasmpolygonresult_stride: (a: number) => number;
+export const polygonize_ffi: (a: number, b: number, c: number, d: number, e: number) => number;
+export const polygonize_with_options_ffi: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+export const polygonize_result_free: () => void;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_start: () => void;

package/dist/slim/pkg-wrapper/bindings/ContainmentOptions.d.ts

@@ -0,0 +1,6 @@
+import type { IndexBackend } from "./IndexBackend";
+import type { TouchPolicy } from "./TouchPolicy";
+export type ContainmentOptions = {
+    touch_policy: TouchPolicy;
+    index_backend: IndexBackend;
+};

package/dist/slim/pkg-wrapper/bindings/DedupPolicy.d.ts

@@ -0,0 +1 @@
+export type DedupPolicy = "KeepAll" | "CanonicalRingHash";

package/dist/slim/pkg-wrapper/bindings/DeterminismOptions.d.ts

@@ -0,0 +1,5 @@
+export type DeterminismOptions = {
+    canonical_sort: boolean;
+    canonical_ring_rotation: boolean;
+    stable_tie_breaks: boolean;
+};

package/dist/slim/pkg-wrapper/bindings/DiagnosticsOptions.d.ts

@@ -0,0 +1,4 @@
+export type DiagnosticsOptions = {
+    enabled: boolean;
+    report_mode: boolean;
+};

package/dist/slim/pkg-wrapper/bindings/IndexBackend.d.ts

@@ -0,0 +1 @@
+export type IndexBackend = "RStar" | "PackedNative";

package/dist/slim/pkg-wrapper/bindings/NodingBackend.d.ts

@@ -0,0 +1 @@
+export type NodingBackend = "Snap" | "Advanced";

package/dist/slim/pkg-wrapper/bindings/NodingOptions.d.ts

@@ -0,0 +1,6 @@
+import type { NodingBackend } from "./NodingBackend";
+import type { SnapMode } from "./SnapMode";
+export type NodingOptions = {
+    backend: NodingBackend;
+    snap_mode: SnapMode;
+};

package/dist/slim/pkg-wrapper/bindings/PolygonizerOptions.d.ts

@@ -0,0 +1,92 @@
+import type { ContainmentOptions } from "./ContainmentOptions";
+import type { DeterminismOptions } from "./DeterminismOptions";
+import type { DiagnosticsOptions } from "./DiagnosticsOptions";
+import type { NodingOptions } from "./NodingOptions";
+import type { ProvenanceOptions } from "./ProvenanceOptions";
+import type { SnapStrategy } from "./SnapStrategy";
+import type { TargetProfile } from "./TargetProfile";
+import type { TilingOptions } from "./TilingOptions";
+import type { ZOptions } from "./ZOptions";
+/**
+ * The canonical configuration object for the `geo-polygonize` engine.
+ *
+ * This struct controls every aspect of the polygonization pipeline, including
+ * topological robustness, feature output, containment policies, noding, and determinism.
+ */
+export type PolygonizerOptions = {
+    /**
+     * Determines the execution environment profile (e.g., Native, WasmSingleThread, WasmThreads).
+     *
+     * Default: `TargetProfile::Native`
+     */
+    target: TargetProfile;
+    /**
+     * Whether to robustly node the input before polygonization.
+     *
+     * Enable this for real-world linework where segment intersections may not
+     * already exist as explicit vertices. This is slower than the fast path but
+     * avoids missing faces and unresolved crossings.
+     *
+     * Default: `false`
+     */
+    node_input: boolean;
+    /**
+     * The snapping grid size used for vertex deduplication and noding operations.
+     *
+     * Vertices falling within the same grid cell are coalesced. A size of `0.0`
+     * indicates exact floating-point evaluation without grid snapping.
+     *
+     * Default: `1e-10`
+     */
+    snap_grid_size: number;
+    /**
+     * If `true`, only pure, outermost polygonal shells are returned.
+     *
+     * Floating dangles, internal cut-lines, or invalid rings will be discarded.
+     *
+     * Default: `false`
+     */
+    extract_only_polygonal: boolean;
+    /**
+     * The underlying strategy to apply when snapping coordinate geometries.
+     *
+     * See `SnapStrategy` for differences between strict `Grid` snapping and
+     * Shapely/GEOS `GeosCompat` strategies.
+     *
+     * Default: `SnapStrategy::Grid`
+     */
+    snap_strategy: SnapStrategy;
+    /**
+     * Configures the noding engine backend and behavior.
+     */
+    noding: NodingOptions;
+    /**
+     * Configures how topological relationships (containment) are calculated
+     * during face formation.
+     */
+    containment: ContainmentOptions;
+    /**
+     * Optional configuration for tiled, distributed execution across huge datasets.
+     */
+    tiling?: TilingOptions;
+    /**
+     * Configures Z-axis coordinate handling.
+     */
+    z: ZOptions;
+    /**
+     * Configuration for enforcing exact topological determinism.
+     */
+    determinism: DeterminismOptions;
+    /**
+     * Options for capturing diagnostic topology failures.
+     */
+    diagnostics: DiagnosticsOptions;
+    /**
+     * Options for mapping final faces back to original input geometry IDs.
+     */
+    provenance: ProvenanceOptions;
+    /**
+     * An optional identifier for the input dataset.
+     */
+    input_profile_id?: string;
+};

package/dist/slim/pkg-wrapper/bindings/ProvenanceOptions.d.ts

@@ -0,0 +1,4 @@
+export type ProvenanceOptions = {
+    enabled: boolean;
+    include_boundary_line_ids: boolean;
+};

package/dist/slim/pkg-wrapper/bindings/SnapMode.d.ts

@@ -0,0 +1 @@
+export type SnapMode = "FloatExact" | "FloatEpsilonDedup" | "IntegerGrid";

package/dist/slim/pkg-wrapper/bindings/SnapStrategy.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Strategy for snapping coordinates to a grid.
+ *
+ * `Grid` applies a standard round-to-nearest integer grid policy `(coord / size).round() * size`.
+ * `GeosCompat` attempts to emulate GEOS / Shapely's `set_precision` behavior, which uses
+ * C++ std::round (rounding halfway cases away from zero).
+ *
+ * **Scale Guidance:**
+ * Use `Grid` for native Rust applications where absolute topological determinism and
+ * intuitive rounding is preferred.
+ * Use `GeosCompat` if you are using `geo-polygonize` to replace a Shapely / GEOS pipeline
+ * and require exact parity for edge cases at precision boundaries.
+ *
+ * **Expected Parity:**
+ * Rust's native `f64::round()` rounds halfway cases away from zero. This perfectly
+ * matches C++ `std::round` behavior, meaning that `Grid` and `GeosCompat` currently
+ * map identical values for basic single-coordinate precision points (e.g., `-0.5` => `-1.0`
+ * and `0.5` => `1.0`).
+ *
+ * **Expected Divergence:**
+ * The divergence between `Grid` and `GeosCompat` strategies typically arises under complex
+ * topological scaling sequences rather than simple single point coordinate rounding, but
+ * the option ensures the library remains semantically compatible with Python/C++ GEOS pipelines.
+ */
+export type SnapStrategy = "Grid" | "GeosCompat";

package/dist/slim/pkg-wrapper/bindings/TargetProfile.d.ts

@@ -0,0 +1 @@
+export type TargetProfile = "Native" | "WasmSingleThread" | "WasmThreads";

package/dist/slim/pkg-wrapper/bindings/TileOwnershipPolicy.d.ts

@@ -0,0 +1 @@
+export type TileOwnershipPolicy = "Centroid" | "RepresentativePointInsidePolygon" | "LexicographicMinVertex" | "CanonicalBoundaryHash";

package/dist/slim/pkg-wrapper/bindings/TilingOptions.d.ts

@@ -0,0 +1,6 @@
+import type { DedupPolicy } from "./DedupPolicy";
+import type { TileOwnershipPolicy } from "./TileOwnershipPolicy";
+export type TilingOptions = {
+    ownership_policy: TileOwnershipPolicy;
+    dedup_policy: DedupPolicy;
+};

package/dist/slim/pkg-wrapper/bindings/TouchPolicy.d.ts

@@ -0,0 +1 @@
+export type TouchPolicy = "AllowPointTouchDisallowEdgeShare" | "TreatAnyTouchAsDisjoint" | "AllowEdgeShare";

package/dist/slim/pkg-wrapper/bindings/ZOptions.d.ts

@@ -0,0 +1,4 @@
+import type { ZPolicy } from "./ZPolicy";
+export type ZOptions = {
+    policy: ZPolicy;
+};

package/dist/slim/pkg-wrapper/bindings/ZPolicy.d.ts

@@ -0,0 +1,5 @@
+export type ZPolicy = "Ignore" | "InterpolateAlongEdge" | "PreferNearestEndpoint" | {
+    "ErrorOnConflict": {
+        max_delta: number;
+    };
+};

package/dist/standard/cjs/cfb.d.ts

@@ -0,0 +1,2 @@
+import type { PolygonizerOptions } from "./bindings/PolygonizerOptions";
+export declare const cfbRobustOptions: PolygonizerOptions;

package/dist/standard/cjs/index.d.ts

@@ -16,4 +16,5 @@ export * from "./bindings/TilingOptions";
 export * from "./bindings/TouchPolicy";
 export * from "./bindings/ZOptions";
 export * from "./bindings/ZPolicy";
+export * from "./cfb";
 export default function init(_input?: any): Promise<typeof exports>;