@walkthru-earth/objex 1.2.1 → 1.3.0

package/dist/components/viewers/ZarrMapViewer.svelte.d.ts

@@ -1,11 +1,17 @@
-import type { Tab } from '../../types';
-import { type ZarrNode } from '../../utils/zarr.js';
+import type { Tab } from '../../types.js';
+import { type ZarrHierarchy, type ZarrNode } from '../../utils/zarr.js';
 type $$ComponentProps = {
     tab: Tab;
     variables: ZarrNode[];
     coords?: ZarrNode[];
     spatialRefAttrs: Record<string, any> | null;
     zarrVersion?: number | null;
+    /**
+     * Full pre-loaded hierarchy. When present, `detectGeoZarr` can short-circuit
+     * to the `@developmentseed/deck.gl-zarr` path for GeoZarr-valid stores.
+     * Non-GeoZarr stores fall through to `@carbonplan/zarr-layer`.
+     */
+    hierarchy?: ZarrHierarchy | null;
 };
 declare const ZarrMapViewer: import("svelte").Component<$$ComponentProps, {}, "">;
 type ZarrMapViewer = ReturnType<typeof ZarrMapViewer>;

package/dist/components/viewers/ZarrViewer.svelte

@@ -474,6 +474,7 @@ function selectStoreAttrs() {
 					coords={coordArrays}
 					spatialRefAttrs={hierarchy?.spatialRefAttrs ?? null}
 					zarrVersion={hierarchy?.zarrVersion}
+					hierarchy={hierarchy ?? null}
 				/>
 			{/await}
 		{/key}

package/dist/i18n/ar.js

@@ -40,6 +40,8 @@ export const ar = {
     'connection.readOnlyCliTitle': 'تقييد عبر سطر الأوامر',
     'connection.testSuccess': 'الاتصال ناجح',
     'connection.testFail': 'فشل الاتصال. تحقق من الإعدادات وحاول مرة أخرى.',
+    'connection.duplicateMerged': 'تم العثور على اتصال موجود ("{name}") لهذه الحاوية. تم تحديث بيانات الاعتماد.',
+    'connection.duplicateBlocked': 'يوجد بالفعل اتصال آخر ("{name}") يستخدم هذه الحاوية. عدّله بدلاً من ذلك.',
     'connection.testButton': 'اختبار الاتصال',
     'connection.testing': 'جارٍ الاختبار...',
     'connection.cancel': 'إلغاء',
@@ -300,6 +302,7 @@ export const ar = {
     'code.stacCatalog': 'كتالوج STAC',
     'code.stacCollection': 'مجموعة STAC',
     'code.stacItem': 'عنصر STAC',
+    'code.stacGeoparquet': 'stac-geoparquet',
     'code.browseStac': 'تصفح',
     'code.keplerGl': 'Kepler.gl',
     'code.openKepler': 'فتح الخريطة',
@@ -382,11 +385,35 @@ export const ar = {
     'mapInfo.columns': 'الأعمدة',
     'mapInfo.size': 'الحجم',
     'mapInfo.bands': 'النطاقات',
+    'map.mosaicEmpty': 'كتالوج STAC لا يحتوي على عناصر بها أصول COG.',
+    'map.mosaicNoAssets': 'لا تحتوي عناصر STAC على عنوان URL صالح لأصل COG.',
+    'map.multiCogMissingBands': 'عنصر STAC هذا ينقصه نطاقات الأحمر والأخضر والأزرق اللازمة للتركيب.',
+    'map.multiCogPreset.label': 'الإعداد المسبق',
+    'map.multiCogPreset.trueColor': 'ألوان طبيعية',
+    'map.multiCogPreset.falseColorIR': 'أشعة تحت حمراء كاذبة اللون',
+    'map.multiCogPreset.swir': 'الأشعة تحت الحمراء قصيرة الموجة',
+    'map.multiCogPreset.vegetation': 'الغطاء النباتي',
+    'map.multiCogPreset.agriculture': 'الزراعة',
+    // تبديل عرض STAC (StacTabViewer)
+    'stac.viewMosaic': 'خريطة',
+    'stac.viewMultiCog': 'خريطة (نطاقات)',
+    'stac.viewStacMap': 'stac-map',
+    'stac.viewBrowser': 'متصفح STAC',
+    'stac.viewJson': 'JSON',
+    'stac.viewTable': 'جدول',
+    'stac.stacBrowserJsonOnly': 'متصفح STAC يدعم كتالوجات JSON فقط. استخدم stac-map لملفات parquet.',
+    'stac.iframeDisabledPrivate': 'معطل للبكتات الخاصة، الإطار الخارجي لا يستطيع توقيع طلباته. استخدم الخريطة أو JSON بدلاً من ذلك.',
+    'stac.iframePrivateBucketWarning': 'بكت خاص، الإطار الخارجي لا يستطيع توقيع طلباته، لذا ستفشل طلبات العناصر الفرعية بـ 403. لكن المانيفست الجذري سيعمل.',
+    'stac.mosaicSourcesOne': 'فسيفساء، {count} مصدر',
+    'stac.mosaicSourcesOther': 'فسيفساء، {count} مصادر',
+    'stac.mosaicInfo': 'معلومات الفسيفساء',
+    'stac.mosaicSourcesLabel': 'المصادر',
     // COG Controls
     'cog.style': 'النمط',
     'cog.band': 'النطاق',
     'cog.singleBand': 'نطاق واحد',
     'cog.colorRamp': 'تدرج الألوان',
+    'cog.colorRampSearch': 'بحث في التدرجات…',
     'cog.pixelValue': 'قيمة البكسل',
     'cog.reading': 'قراءة البكسل...',
     'cog.rescale': 'إعادة القياس',

package/dist/i18n/en.js

@@ -40,6 +40,8 @@ export const en = {
     'connection.readOnlyCliTitle': 'Restrict via CLI',
     'connection.testSuccess': 'Connection successful',
     'connection.testFail': 'Connection failed. Check your settings and try again.',
+    'connection.duplicateMerged': 'Matched an existing connection ("{name}") for this bucket. Credentials were updated.',
+    'connection.duplicateBlocked': 'Another connection ("{name}") already uses this bucket. Edit that one instead.',
     'connection.testButton': 'Test Connection',
     'connection.testing': 'Testing...',
     'connection.cancel': 'Cancel',
@@ -300,6 +302,7 @@ export const en = {
     'code.stacCatalog': 'STAC Catalog',
     'code.stacCollection': 'STAC Collection',
     'code.stacItem': 'STAC Item',
+    'code.stacGeoparquet': 'stac-geoparquet',
     'code.browseStac': 'Browse',
     'code.keplerGl': 'Kepler.gl',
     'code.openKepler': 'Open Map',
@@ -382,11 +385,35 @@ export const en = {
     'mapInfo.columns': 'Columns',
     'mapInfo.size': 'Size',
     'mapInfo.bands': 'Bands',
+    'map.mosaicEmpty': 'STAC catalog has no items with COG assets.',
+    'map.mosaicNoAssets': 'None of the STAC items expose a usable COG asset URL.',
+    'map.multiCogMissingBands': 'This STAC item is missing the red/green/blue bands required for a composite.',
+    'map.multiCogPreset.label': 'Preset',
+    'map.multiCogPreset.trueColor': 'True Color',
+    'map.multiCogPreset.falseColorIR': 'False-Color IR',
+    'map.multiCogPreset.swir': 'SWIR',
+    'map.multiCogPreset.vegetation': 'Vegetation',
+    'map.multiCogPreset.agriculture': 'Agriculture',
+    // STAC tab toggle (StacTabViewer)
+    'stac.viewMosaic': 'Map',
+    'stac.viewMultiCog': 'Map (Bands)',
+    'stac.viewStacMap': 'stac-map',
+    'stac.viewBrowser': 'STAC Browser',
+    'stac.viewJson': 'JSON',
+    'stac.viewTable': 'Table',
+    'stac.stacBrowserJsonOnly': 'STAC Browser supports JSON catalogs only. Use stac-map for parquet.',
+    'stac.iframeDisabledPrivate': 'Disabled for private buckets, the external iframe cannot sign its own crawl. Use Map or JSON instead.',
+    'stac.iframePrivateBucketWarning': 'Private bucket, the external iframe cannot sign its own crawl, so child items will 403. The top manifest still renders.',
+    'stac.mosaicSourcesOne': 'Mosaic, {count} source',
+    'stac.mosaicSourcesOther': 'Mosaic, {count} sources',
+    'stac.mosaicInfo': 'Mosaic info',
+    'stac.mosaicSourcesLabel': 'Sources',
     // COG Controls
     'cog.style': 'Style',
     'cog.band': 'Band',
     'cog.singleBand': 'Single',
     'cog.colorRamp': 'Color ramp',
+    'cog.colorRampSearch': 'Search ramps…',
     'cog.pixelValue': 'Pixel Value',
     'cog.reading': 'Reading pixel...',
     'cog.rescale': 'Rescale',

package/dist/index.d.ts

@@ -14,6 +14,8 @@ export type { CogInfo, GeoBounds } from './utils/cog.js';
 export { buildDataTypeLabel, clampBounds, SF_LABELS, safeClamp } from './utils/cog.js';
 export type { TypeCategory } from './utils/column-types.js';
 export { classifyType, typeBadgeClass, typeColor, typeLabel } from './utils/column-types.js';
+export type { ConnectionIdentityInput } from './utils/connection-identity.js';
+export { connectionIdentityKey, isSameConnectionIdentity, normalizeEndpoint, normalizeProvider } from './utils/connection-identity.js';
 export { handleLoadError } from './utils/error.js';
 export { escapeCsvField, serializeToCsv, serializeToJson } from './utils/export.js';
 export type { SortConfig, SortDirection, SortField } from './utils/file-sort.js';
@@ -28,6 +30,8 @@ export type { ParsedMarkdownDocument, SqlBlock } from './utils/markdown-sql.js';
 export { interpolateTemplates, markSqlBlocks, parseMarkdownDocument } from './utils/markdown-sql.js';
 export type { GeoColumnMeta, GeoParquetMeta, ParquetFileMetadata } from './utils/parquet-metadata.js';
 export { extractBounds, extractEpsgFromGeoMeta, extractGeometryTypes, readParquetMetadata } from './utils/parquet-metadata.js';
+export type { StacBboxStruct, StacGeoparquetRow, StacGeoparquetSchemaColumn, StacRowToItemOptions } from './utils/stac-geoparquet.js';
+export { flattenStacBbox, isStacGeoparquetSchema, pickStacPrimaryAsset, resolveStacAssetHref, STAC_GEOPARQUET_REQUIRED_COLUMNS, stacRowToItem } from './utils/stac-geoparquet.js';
 export type { Defaults, ParsedStorageUrl, StorageProvider } from './utils/storage-url.js';
 export { describeParseResult, looksLikeUrl, parseStorageUrl } from './utils/storage-url.js';
 export type { GeoType, ParsedGeometry } from './utils/wkb.js';

package/dist/index.js

@@ -12,6 +12,7 @@ export { copyToClipboard, wireCodeCopyButtons } from './utils/clipboard.js';
 export { getNativeScheme, resolveCloudUrl, safeDecodeURIComponent } from './utils/cloud-url.js';
 export { buildDataTypeLabel, clampBounds, SF_LABELS, safeClamp } from './utils/cog.js';
 export { classifyType, typeBadgeClass, typeColor, typeLabel } from './utils/column-types.js';
+export { connectionIdentityKey, isSameConnectionIdentity, normalizeEndpoint, normalizeProvider } from './utils/connection-identity.js';
 // Error handling
 export { handleLoadError } from './utils/error.js';
 // Data export / serialization
@@ -24,6 +25,7 @@ export { generateHexDump } from './utils/hex.js';
 export { loadFromStorage, persistToStorage } from './utils/local-storage.js';
 export { interpolateTemplates, markSqlBlocks, parseMarkdownDocument } from './utils/markdown-sql.js';
 export { extractBounds, extractEpsgFromGeoMeta, extractGeometryTypes, readParquetMetadata } from './utils/parquet-metadata.js';
+export { flattenStacBbox, isStacGeoparquetSchema, pickStacPrimaryAsset, resolveStacAssetHref, STAC_GEOPARQUET_REQUIRED_COLUMNS, stacRowToItem } from './utils/stac-geoparquet.js';
 export { describeParseResult, looksLikeUrl, parseStorageUrl } from './utils/storage-url.js';
 // Utilities
 export { findGeoColumn, findGeoColumnFromRows, parseWKB, toBinary } from './utils/wkb.js';

package/dist/query/stac-geoparquet.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Read a stac-geoparquet file through the existing DuckDB-WASM engine and
+ * materialize a standard STAC FeatureCollection in memory.
+ *
+ * Reuses:
+ *   - `getQueryEngine()` + `queryCancellable`/`query` for the single worker
+ *   - `resolveTableSourceAsync(tab)` for presigned `signed-s3` URL handling
+ *   - `stacRowToItem` from `utils/stac-geoparquet.js` for the pure transform
+ *   - `parseWKB` from `utils/wkb.js` for geometry decoding
+ *
+ * The returned `FeatureCollection` is the same shape `classifyStac()` returns
+ * as `{ kind: 'item-collection', fc }`, so downstream viewers
+ * (`StacMosaicViewer`, `MultiCogViewer`) consume it unchanged.
+ */
+import type { Tab } from '../types.js';
+import type { StacFeatureCollection } from '../utils/stac.js';
+export interface QueryStacGeoparquetOptions {
+    signal?: AbortSignal;
+    /** Hard cap on rows. Matches `hydrateStacItems` default. */
+    limit?: number;
+}
+/**
+ * Query a stac-geoparquet tab and return a STAC FeatureCollection whose
+ * features are proper STAC Items (assets absolutized, WKB decoded, bbox
+ * flattened).
+ *
+ * @param tab - the tab pointing at the `.parquet` file
+ * @param connId - connection id used for DuckDB's httpfs S3 config; pass
+ *   an empty string for URL-source tabs (DuckDB will use anonymous httpfs)
+ */
+export declare function queryStacGeoparquetFeatureCollection(tab: Tab, connId: string, opts?: QueryStacGeoparquetOptions): Promise<StacFeatureCollection>;

package/dist/query/stac-geoparquet.js

@@ -0,0 +1,136 @@
+/**
+ * Read a stac-geoparquet file through the existing DuckDB-WASM engine and
+ * materialize a standard STAC FeatureCollection in memory.
+ *
+ * Reuses:
+ *   - `getQueryEngine()` + `queryCancellable`/`query` for the single worker
+ *   - `resolveTableSourceAsync(tab)` for presigned `signed-s3` URL handling
+ *   - `stacRowToItem` from `utils/stac-geoparquet.js` for the pure transform
+ *   - `parseWKB` from `utils/wkb.js` for geometry decoding
+ *
+ * The returned `FeatureCollection` is the same shape `classifyStac()` returns
+ * as `{ kind: 'item-collection', fc }`, so downstream viewers
+ * (`StacMosaicViewer`, `MultiCogViewer`) consume it unchanged.
+ */
+import { stacRowToItem } from '../utils/stac-geoparquet.js';
+import { parseWKB } from '../utils/wkb.js';
+import { QueryCancelledError } from './engine.js';
+import { getQueryEngine } from './index.js';
+import { resolveTableSourceAsync } from './source.js';
+const DEFAULT_LIMIT = 2000;
+/**
+ * Build the SELECT list. All columns are optional in the stac-geoparquet
+ * spec, so we only project what we know we'll use and the spec requires.
+ * The optional `proj:*` / `raster:*` / `bands` columns are sniffed from the
+ * schema so missing columns don't trigger a DuckDB binder error.
+ */
+function buildSelectList(availableColumns) {
+    const required = [
+        'id',
+        'collection',
+        'type',
+        'stac_version',
+        'stac_extensions',
+        'assets',
+        'bbox',
+        'links'
+    ];
+    const optional = [
+        'datetime',
+        'proj:code',
+        'proj:bbox',
+        'proj:transform',
+        'proj:shape',
+        'raster:spatial_resolution',
+        'bands'
+    ];
+    const cols = [];
+    for (const name of required) {
+        if (availableColumns.has(name))
+            cols.push(quoteIdent(name));
+    }
+    for (const name of optional) {
+        if (availableColumns.has(name))
+            cols.push(quoteIdent(name));
+    }
+    // Always project geometry as WKB so parseWKB can decode it regardless of
+    // whether DuckDB presents it as the v1.5 GEOMETRY type or a plain BLOB.
+    if (availableColumns.has('geometry')) {
+        cols.push('ST_AsWKB(geometry) AS geom_wkb');
+    }
+    return cols.join(', ');
+}
+function quoteIdent(name) {
+    return `"${name.replace(/"/g, '""')}"`;
+}
+/**
+ * Query a stac-geoparquet tab and return a STAC FeatureCollection whose
+ * features are proper STAC Items (assets absolutized, WKB decoded, bbox
+ * flattened).
+ *
+ * @param tab - the tab pointing at the `.parquet` file
+ * @param connId - connection id used for DuckDB's httpfs S3 config; pass
+ *   an empty string for URL-source tabs (DuckDB will use anonymous httpfs)
+ */
+export async function queryStacGeoparquetFeatureCollection(tab, connId, opts = {}) {
+    const { signal, limit = DEFAULT_LIMIT } = opts;
+    if (signal?.aborted)
+        throw new QueryCancelledError();
+    const engine = await getQueryEngine();
+    const resolved = await resolveTableSourceAsync(tab);
+    if (signal?.aborted)
+        throw new QueryCancelledError();
+    // Discover which optional columns are present so the SELECT list doesn't
+    // reference missing columns.
+    const schema = await engine.getSchema(connId, resolved);
+    if (signal?.aborted)
+        throw new QueryCancelledError();
+    const available = new Set(schema.map((f) => f.name));
+    const selectList = buildSelectList(available);
+    if (!available.has('geometry') || !available.has('assets')) {
+        throw new Error('Not a stac-geoparquet file (missing geometry or assets column)');
+    }
+    const sql = `SELECT ${selectList} FROM ${resolved.ref} LIMIT ${limit}`;
+    // Prefer cancellable path when the engine exposes it.
+    let resultPromise;
+    let cancel = null;
+    if (engine.queryCancellable) {
+        const handle = engine.queryCancellable(connId, sql);
+        cancel = handle.cancel;
+        resultPromise = handle.result;
+    }
+    else {
+        resultPromise = engine.query(connId, sql);
+    }
+    const onAbort = () => {
+        cancel?.().catch(() => { });
+    };
+    signal?.addEventListener('abort', onAbort, { once: true });
+    let rows;
+    try {
+        const result = await resultPromise;
+        rows = result.rows ?? [];
+    }
+    finally {
+        signal?.removeEventListener('abort', onAbort);
+    }
+    if (signal?.aborted)
+        throw new QueryCancelledError();
+    // Asset hrefs in stac-geoparquet are typically written relative to each
+    // item's original `self` URL, not the parquet URL. The stactools default
+    // layout places each item JSON at `{catalog_dir}/{item.id}/{item.id}.json`,
+    // so a per-row base of `{parquet_dir}/{item.id}/` resolves `./foo.tif` to
+    // `{parquet_dir}/{item.id}/foo.tif`. Absolute hrefs pass through unchanged
+    // via `resolveStacAssetHref`.
+    const parquetUrl = resolved.fileUrl ?? tab.path;
+    const parquetDir = parquetUrl.replace(/[^/]*(?:\?.*)?$/, '');
+    const features = rows.map((row) => {
+        const id = typeof row.id === 'string' ? row.id : String(row.id ?? '');
+        const itemBase = id ? `${parquetDir}${id}/` : parquetUrl;
+        return stacRowToItem(row, itemBase, { wkbParser: parseWKB });
+    });
+    return {
+        type: 'FeatureCollection',
+        features
+    };
+}

package/dist/stores/connections.svelte.d.ts

@@ -1,55 +1,70 @@
 import type { Connection, ConnectionConfig } from '../types.js';
+import { type ConnectionIdentityInput } from '../utils/connection-identity.js';
 import type { DetectedHost } from '../utils/host-detection.js';
+/**
+ * Outcome of a write. `existed` is true when dedup reused an already-saved
+ * connection, false when a new row was persisted. Callers that present UI
+ * (dialogs, toasts) use this to decide whether to say "created" or "merged
+ * into existing".
+ */
+export interface ConnectionWriteResult {
+    id: string;
+    existed: boolean;
+}
+/**
+ * Thrown by `update()` when the proposed identity collides with a different
+ * saved connection. Lets the UI tell the user which connection already owns
+ * that identity instead of silently producing a phantom duplicate.
+ */
+export declare class DuplicateConnectionError extends Error {
+    readonly existingId: string;
+    readonly existingName: string;
+    constructor(existingId: string, existingName: string);
+}
 export declare const connectionStore: {
     readonly items: Connection[];
     readonly loaded: boolean;
     /**
      * Load connections from localStorage.
-     * Safe to call multiple times — subsequent calls are no-ops.
+     * Safe to call multiple times, subsequent calls are no-ops.
      */
     load(): Promise<void>;
-    /**
-     * Force-reload connections.
-     */
     reload(): Promise<void>;
     /**
-     * Save a new connection to localStorage.
+     * Persist a connection. If an existing connection shares the same
+     * identity (see `connectionIdentityKey`), it's reused and its
+     * credentials are refreshed from the new config instead of spawning
+     * a duplicate record. Returns `{ id, existed }` so UI can distinguish
+     * "created" from "merged".
      */
-    save(config: ConnectionConfig): Promise<string | null>;
+    save(config: ConnectionConfig): Promise<ConnectionWriteResult>;
     /**
-     * Update an existing connection.
+     * Update an existing connection. Throws `DuplicateConnectionError`
+     * when the new identity would collide with a different saved row,
+     * rather than silently overwriting and leaving a phantom duplicate.
      */
     update(id: string, config: ConnectionConfig): Promise<boolean>;
-    /**
-     * Remove a connection by ID.
-     */
     remove(id: string): Promise<boolean>;
-    /**
-     * Test whether a connection is reachable via a lightweight list.
-     */
     test(id: string): Promise<boolean>;
     /**
      * Test a connection using provided config values (works for both new
      * and existing connections without saving first).
      */
     testWithConfig(config: ConnectionConfig, existingId?: string): Promise<boolean>;
-    /** True when a dialog open has been requested and not yet consumed. */
     readonly dialogRequested: boolean;
-    /** Request opening the new-connection dialog from anywhere. */
     requestDialog(): void;
-    /** Mark the dialog request as consumed. */
     clearDialogRequest(): void;
-    /**
-     * Synchronous lookup by ID (from the already-loaded list).
-     */
     getById(id: string): Connection | undefined;
     /**
-     * Find an existing connection that matches bucket + endpoint.
+     * Find an already-saved connection that matches the canonical identity
+     * of `input` (provider + bucket + endpoint/region per provider rules).
+     * Used by auto-detect, manual-add dedup, and edit-collision checks.
      */
-    findByBucketEndpoint(bucket: string, endpoint: string): Connection | undefined;
+    findByIdentity(input: ConnectionIdentityInput): Connection | undefined;
     /**
-     * Create a connection from a DetectedHost, deduplicating by bucket+endpoint.
-     * Returns the connection ID (existing or newly created).
+     * Auto-connect path for a URL-detected bucket. Reuses an existing
+     * connection when identity matches, otherwise creates one anonymously.
+     * Always returns the final connection ID.
      */
     saveHostConnection(detected: DetectedHost): Promise<string>;
 };