@nika-js/onlymap 0.5.3 → 0.5.7

package/dist/geoparquet-kW7KUrwB.js

@@ -0,0 +1,35 @@
+import { r as p, n as d } from "./index-CUKgoX_E.js";
+function g(t) {
+  if (t == null) return !0;
+  const e = t, n = e.id?.code;
+  return n != null ? n === 84 || n === 4326 || n === "CRS84" || n === "4326" : typeof e.name == "string" && /^\s*(ogc:)?(wgs\s*84|crs\s*84|wgs84)\s*$/i.test(e.name);
+}
+function y(t) {
+  const e = t;
+  return typeof e?.name == "string" && e.name ? `"${e.name}"` : e?.id?.code != null ? `${e.id.authority ?? "?"}:${e.id.code}` : "a non-CRS84 CRS";
+}
+function h(t, e, n) {
+  const o = e.primary_column;
+  if (!o)
+    throw new Error(`data="${n}": GeoParquet "geo" metadata names no primary_column — can't tell which column is geometry.`);
+  const c = e.columns?.[o]?.crs;
+  if (!g(c))
+    throw new Error(
+      `data="${n}": GeoParquet CRS ${y(c)} isn't CRS84/EPSG:4326 — reprojection isn't supported yet (deck.gl renders lng/lat). Reproject first, e.g. ogr2ogr -t_srs EPSG:4326 out.parquet in.parquet.`
+    );
+  if (t.length === 0)
+    return console.warn(`[onlymapjs] data="${n}": GeoParquet has no rows — empty layer.`), [];
+  const u = t.map((r) => r[o]);
+  if (u.every((r) => r != null && r.type === "Point")) {
+    const r = t.map(({ [o]: i, ...m }) => m), a = p(r), s = u.map((i) => i.coordinates ?? void 0);
+    return { length: t.length, columns: { ...a?.columns ?? {}, [o]: s } };
+  }
+  const l = t.map(({ [o]: r, ...a }) => {
+    const s = a.id;
+    return { type: "Feature", ...s != null ? { id: s } : {}, geometry: r ?? null, properties: a };
+  });
+  return d({ type: "FeatureCollection", features: l });
+}
+export {
+  h as geoParquetToLayerData
+};

package/dist/geoparquet.d.ts

@@ -0,0 +1,33 @@
+/**
+ * GeoParquet (spec: issue #14). Decodes with hyparquet — a pure-JS, zero-dep
+ * Parquet reader — plus hyparquet-compressors for snappy/gzip/zstd (its zstd
+ * IS the same `fzstd` the Arrow path already bundles; no second codec ships).
+ * hyparquet reads the GeoParquet `geo` file metadata and decodes the WKB
+ * primary geometry column to GeoJSON geometry itself, so no WKB decoder is
+ * ours to maintain.
+ *
+ * What IS ours: `geo` metadata validation, a CRS84 guard (deck.gl renders in
+ * lng/lat — a projected file would land in the ocean, so a non-CRS84 CRS is a
+ * loud structured error until the reprojection workstream lands, NOT a silent
+ * skip the way GL does it), and the Arrow geometry rule from
+ * `arrowTableToLayerData` — all-Point tables transpose to columnar (zero row
+ * materialization on the render path), while lines/polygons/mixed become
+ * GeoJSON feature rows that every geometry consumer speaks.
+ */
+import type { LayerData } from "./ir";
+/** The parsed GeoParquet `geo` file-metadata value (a JSON string in key_value_metadata). */
+export interface GeoParquetMetadata {
+    primary_column?: string;
+    columns?: Record<string, {
+        encoding?: string;
+        geometry_types?: string[];
+        crs?: unknown;
+    }>;
+}
+/**
+ * hyparquet rows (geometry already decoded to GeoJSON) → LayerData, applying
+ * the CRS guard and the Arrow all-Point-columnar / lines-polys-feature-rows
+ * split. `rows` is consumed after the geo-metadata gate in data-layer's
+ * PARQUET_FORMAT.
+ */
+export declare function geoParquetToLayerData(rows: Record<string, unknown>[], geo: GeoParquetMetadata, url: string): LayerData;

package/dist/image-overlay.d.ts

@@ -0,0 +1,83 @@
+import type { LayerAssetState } from "./ir";
+export type ImageBounds = [west: number, south: number, east: number, north: number];
+export interface DroneExifData {
+    latitude: number;
+    longitude: number;
+    RelativeAltitude: number;
+    ExifImageWidth: number;
+    ExifImageHeight: number;
+    GimbalYawDegree: number;
+    GimbalPitchDegree: number;
+    GimbalRollDegree: number;
+    FocalLength?: number;
+    Make?: string;
+    Model?: string;
+    GPSAltitude?: number;
+}
+export interface DroneImageMetadata {
+    /** Normalized source metadata. GPS remains the camera position, not the pitch-adjusted footprint center. */
+    exifData: DroneExifData;
+    sourceCenter: [longitude: number, latitude: number];
+    adjustedCenter: [longitude: number, latitude: number];
+    gsdX: number;
+    gsdY: number;
+    fovDegrees: number;
+    sensorWidthMm: number;
+    sensorHeightMm: number;
+    nonNadir: boolean;
+    pixelRotationDegrees: number;
+}
+export interface ResolveImageOverlayOptions {
+    /** Manual camera overrides for models absent from the bundled database. Width and height must be supplied together. */
+    sensorWidthMm?: number;
+    sensorHeightMm?: number;
+    /** Overrides EXIF FocalLength. No guessed focal-length fallback is used. */
+    focalLengthMm?: number;
+}
+export interface ResolvedImageOverlay {
+    /** Original JPEG when no pixel transform was needed; otherwise a transparency-preserving PNG. */
+    image: Blob;
+    bounds: ImageBounds;
+    metadata: DroneImageMetadata;
+}
+export interface DroneSensorDimensions {
+    widthMm: number;
+    heightMm: number;
+}
+/**
+ * PlanetGPT's stage-1 camera roster. Pixel pitch was present in its tuple but
+ * never participates in FOV/GSD, so this contract retains only used values.
+ */
+export declare const DRONE_SENSOR_DATABASE: Readonly<Record<string, DroneSensorDimensions>>;
+/** Normalize exifr's permissive output into the serializable contract used by all later stages. */
+export declare function normalizeDroneExif(rawValue: unknown): DroneExifData;
+export declare function determineDroneFovDegrees(exif: DroneExifData, options?: ResolveImageOverlayOptions): {
+    fovDegrees: number;
+    sensor: DroneSensorDimensions;
+    focalLengthMm: number;
+};
+/** PlanetGPT-compatible non-nadir center approximation. */
+export declare function adjustCenterForPitch(latitude: number, longitude: number, altitude: number, pitch: number, yaw: number): {
+    latitude: number;
+    longitude: number;
+};
+/** PlanetGPT-compatible yaw-expanded, north-aligned WGS84 footprint. */
+export declare function calculateDroneFootprint(latitude: number, longitude: number, altitude: number, yaw: number, imageWidth: number, imageHeight: number, diagonalFovDegrees: number): {
+    bounds: ImageBounds;
+    gsdX: number;
+    gsdY: number;
+};
+/**
+ * Public one-shot resolver. Hosts with persistence upload `image`, store
+ * `bounds` + `metadata`, and reconstruct later with explicit bounds so
+ * collaborators/reloads never re-read EXIF.
+ */
+export declare function resolveImageOverlay(input: string | Blob, options?: ResolveImageOverlayOptions): Promise<ResolvedImageOverlay>;
+/**
+ * Shared synchronous IR bridge for DOM and programmatic front ends. It starts
+ * one async resolution, returns a pending placeholder, and asks every waiting
+ * map/controller to reconcile once the cached result settles.
+ */
+export declare function resolveImageOverlayProps(props: Record<string, unknown>, onLoaded: () => void, snapshot?: boolean): LayerAssetState;
+/** @internal Test isolation; URL caches otherwise intentionally live for the page, like Data Layer URL caches. */
+export declare function resetImageOverlayCacheForTests(): void;

package/dist/{index-BCgjJcZn.js → index-BLy1eTWe.js}

@@ -1,4 +1,4 @@
-import { ai as Bt, av as Xt, aw as Yt, ax as Us } from "./index-BoAq5XsU.js";
+import { ak as Bt, ax as Xt, ay as Yt, az as Us } from "./index-CUKgoX_E.js";
 import { w as gs, t as Hs, f as Ws, m as Qs } from "./mgrs-BY9bIvp4.js";
 import { c as Xs } from "./convert-arrow-schema-DrAihRf9.js";
 import { y as Ys, A as bt, a as Ks, z as Vs, R as Zs } from "./recordbatch-Bpc0uxFn.js";