@walkthru-earth/objex 1.3.0 → 1.4.0

package/dist/utils/stac-geoparquet.js

@@ -1,223 +0,0 @@
-/**
- * stac-geoparquet helpers.
- *
- * Pure TypeScript, zero Svelte / DuckDB / deck.gl dependencies. Re-exported
- * through `@walkthru-earth/objex-utils` so other projects can consume the
- * detection + row-to-Item transforms without pulling the Svelte lib.
- *
- * The module is decoupled from WKB decoding: callers pass a `wkbParser`
- * callback (the objex Svelte lib threads its `parseWKB`; other consumers
- * can plug in `geoarrow-wasm`, `wkx`, or any other library).
- */
-/** Columns every stac-geoparquet file MUST carry per the stac-geoparquet spec. */
-export const STAC_GEOPARQUET_REQUIRED_COLUMNS = [
-    'stac_version',
-    'type',
-    'geometry',
-    'assets'
-];
-/**
- * Detect stac-geoparquet by presence of the required STAC columns.
- *
- * Deliberately type-agnostic: some pipelines know the type (DuckDB DESCRIBE,
- * Arrow Field), others only have the name list (hyparquet schema walk). The
- * set of names is sufficient for routing.
- */
-export function isStacGeoparquetSchema(schema) {
-    if (!Array.isArray(schema) || schema.length === 0)
-        return false;
-    const names = new Set(schema.map((c) => c.name));
-    return STAC_GEOPARQUET_REQUIRED_COLUMNS.every((c) => names.has(c));
-}
-/**
- * Flatten a DuckDB `struct(xmin,ymin,xmax,ymax)` bbox to the `[minX, minY, maxX, maxY]`
- * array shape that STAC Items and deck.gl-geotiff MosaicLayer expect.
- *
- * Pass-through for arrays so callers that already have `[minX,minY,maxX,maxY]`
- * shape (e.g. from a Feature's `bbox` field) don't need a separate path.
- */
-export function flattenStacBbox(bbox) {
-    if (!bbox)
-        return null;
-    if (Array.isArray(bbox)) {
-        if (bbox.length < 4)
-            return null;
-        const [minX, minY, maxX, maxY] = bbox;
-        if (![minX, minY, maxX, maxY].every((v) => Number.isFinite(v)))
-            return null;
-        return [minX, minY, maxX, maxY];
-    }
-    if (typeof bbox === 'object') {
-        const { xmin, ymin, xmax, ymax } = bbox;
-        if (![xmin, ymin, xmax, ymax].every((v) => Number.isFinite(v)))
-            return null;
-        return [xmin, ymin, xmax, ymax];
-    }
-    return null;
-}
-/**
- * Resolve a possibly-relative STAC asset href against the parquet file URL.
- *
- * `./foo.tif` or `foo.tif` → absolute against `baseUrl`. Absolute URLs
- * (`http(s)://`, `s3://`, `gs://`, etc.) are returned unchanged.
- */
-export function resolveStacAssetHref(href, baseUrl) {
-    if (!href)
-        return href;
-    if (/^[a-z][a-z0-9+\-.]*:\/\//i.test(href))
-        return href;
-    try {
-        return new URL(href, baseUrl).toString();
-    }
-    catch {
-        return href;
-    }
-}
-/**
- * Pick the "primary" asset from a STAC Item's `assets` map.
- *
- * Priority: caller-specified `preferredKeys` → `data` key → first asset with
- * `roles` containing `'data'` → first asset. Returns `null` if the map is
- * empty or not an object.
- */
-export function pickStacPrimaryAsset(assets, preferredKeys) {
-    if (!assets || typeof assets !== 'object')
-        return null;
-    const entries = Object.entries(assets).filter(([, a]) => a && typeof a === 'object' && typeof a.href === 'string');
-    if (entries.length === 0)
-        return null;
-    if (preferredKeys) {
-        for (const key of preferredKeys) {
-            const match = entries.find(([k]) => k === key);
-            if (match)
-                return { key: match[0], asset: match[1] };
-        }
-    }
-    const data = entries.find(([k]) => k === 'data');
-    if (data)
-        return { key: data[0], asset: data[1] };
-    const byRole = entries.find(([, a]) => Array.isArray(a.roles) && a.roles.includes('data'));
-    if (byRole)
-        return { key: byRole[0], asset: byRole[1] };
-    return { key: entries[0][0], asset: entries[0][1] };
-}
-/**
- * Normalize the `assets` value read from a stac-geoparquet row.
- *
- * DuckDB returns `assets` as a `struct` with a fixed set of named fields (one
- * per asset key present at write-time), which decodes to a plain object.
- * Some rows may have `null` asset values for keys that don't apply to them;
- * those are filtered out.
- */
-function normalizeAssetsField(value, baseUrl) {
-    if (!value || typeof value !== 'object')
-        return undefined;
-    const out = {};
-    for (const [key, raw] of Object.entries(value)) {
-        if (!raw || typeof raw !== 'object')
-            continue;
-        const asset = raw;
-        if (typeof asset.href !== 'string' || !asset.href)
-            continue;
-        out[key] = {
-            ...asset,
-            href: resolveStacAssetHref(asset.href, baseUrl)
-        };
-    }
-    return Object.keys(out).length > 0 ? out : undefined;
-}
-/** Normalize the `links` field, resolving relative hrefs against `baseUrl`. */
-function normalizeLinksField(value, baseUrl) {
-    if (!Array.isArray(value))
-        return undefined;
-    const links = [];
-    for (const raw of value) {
-        if (!raw || typeof raw !== 'object')
-            continue;
-        const link = raw;
-        if (typeof link.href !== 'string' || typeof link.rel !== 'string')
-            continue;
-        links.push({ ...link, href: resolveStacAssetHref(link.href, baseUrl) });
-    }
-    return links.length > 0 ? links : undefined;
-}
-/**
- * Convert one stac-geoparquet row into a standard STAC Item JSON object.
- *
- * Handles:
- *   - `assets` named-struct flattening + relative href resolution
- *   - `bbox` struct → `[minX, minY, maxX, maxY]` array
- *   - Optional WKB geometry → GeoJSON via `opts.wkbParser`
- *   - `datetime` → ISO string (passes through already-string values)
- *   - Promotes `properties.*` columns (`proj:*`, `datetime`) onto `item.properties`
- */
-export function stacRowToItem(row, baseUrl, opts = {}) {
-    const { wkbParser, wkbColumn = 'geom_wkb', geometryColumn = 'geometry' } = opts;
-    let geometry = row[geometryColumn];
-    if (!geometry) {
-        const wkb = row[wkbColumn];
-        if (wkb && wkbParser) {
-            const bytes = wkb instanceof Uint8Array ? wkb : toUint8Array(wkb);
-            if (bytes) {
-                try {
-                    geometry = wkbParser(bytes) ?? undefined;
-                }
-                catch {
-                    geometry = undefined;
-                }
-            }
-        }
-    }
-    const bbox = flattenStacBbox(row.bbox) ?? undefined;
-    const assets = normalizeAssetsField(row.assets, baseUrl);
-    const links = normalizeLinksField(row.links, baseUrl);
-    const properties = {};
-    // Hoist common STAC-property columns that live at row level in stac-geoparquet.
-    for (const [key, value] of Object.entries(row)) {
-        if (value === null || value === undefined)
-            continue;
-        if (key.startsWith('proj:') || key.startsWith('raster:') || key.startsWith('eo:')) {
-            properties[key] = value;
-        }
-        if (key === 'datetime') {
-            properties.datetime = value instanceof Date ? value.toISOString() : String(value);
-        }
-        if (key === 'bands') {
-            properties.bands = value;
-        }
-    }
-    const item = {
-        type: 'Feature',
-        stac_version: typeof row.stac_version === 'string' ? row.stac_version : '1.0.0',
-        id: typeof row.id === 'string' ? row.id : String(row.id ?? ''),
-        properties
-    };
-    if (typeof row.collection === 'string')
-        item.collection = row.collection;
-    if (Array.isArray(row.stac_extensions)) {
-        item.stac_extensions = row.stac_extensions;
-    }
-    if (bbox)
-        item.bbox = bbox;
-    if (geometry)
-        item.geometry = geometry;
-    if (assets)
-        item.assets = assets;
-    if (links)
-        item.links = links;
-    return item;
-}
-/** Best-effort coercion of a value that may already be bytes into a Uint8Array. */
-function toUint8Array(value) {
-    if (value instanceof Uint8Array)
-        return value;
-    if (value instanceof ArrayBuffer)
-        return new Uint8Array(value);
-    if (ArrayBuffer.isView(value)) {
-        const view = value;
-        return new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
-    }
-    if (Array.isArray(value))
-        return new Uint8Array(value);
-    return null;
-}

package/dist/utils/stac-hydrate.d.ts

@@ -1,38 +0,0 @@
-/**
- * STAC link-following hydrator. Walks `links[rel=item]` (Collection),
- * `links[rel=child]` → `links[rel=item]` (Catalog), and `links[rel=next]`
- * (paginated FeatureCollection / STAC API) into a flat list of StacItems.
- */
-import type { StorageAdapter } from '../storage/adapter.js';
-import { type StacItem, type StacRoutableKind } from './stac.js';
-export interface HydrateOptions {
-    signal: AbortSignal;
-    /** Max parallel fetches. Default 12. */
-    concurrency?: number;
-    /** Hard cap on items; catalogs larger than this are truncated. Default 2000. */
-    limit?: number;
-    /** Follow `links[rel=next]` pagination in FeatureCollections. Default true. */
-    followPagination?: boolean;
-    /** Emit fetched items in batches for progressive rendering. */
-    onBatch?: (items: StacItem[]) => void;
-    /** Emit progress totals for UI. */
-    onProgress?: (fetched: number, totalHinted: number | undefined) => void;
-    /**
-     * Map an absolute HTTPS URL to a bucket-relative key when it belongs to the
-     * caller's connection. When provided and it returns a non-null string,
-     * `fetchJson` routes through the storage adapter (which handles SigV4) instead
-     * of a raw cross-origin `fetch`, so private-bucket catalogs can be walked.
-     */
-    urlToKey?: (absoluteUrl: string) => string | null;
-}
-export interface HydrateResult {
-    items: StacItem[];
-    truncated: boolean;
-    rootBaseHref: string;
-}
-export declare function hydrateStacItems(root: StacRoutableKind, baseHref: string, adapter: StorageAdapter, opts: HydrateOptions): Promise<HydrateResult>;
-/**
- * Resolve a possibly-relative href against a base. STAC catalogs commonly use
- * `./child/foo.json` or `../foo.json`. `new URL(relative, base)` handles both.
- */
-export declare function absolutizeHref(href: string, baseHref: string): string;

package/dist/utils/stac-hydrate.js

@@ -1,243 +0,0 @@
-/**
- * STAC link-following hydrator. Walks `links[rel=item]` (Collection),
- * `links[rel=child]` → `links[rel=item]` (Catalog), and `links[rel=next]`
- * (paginated FeatureCollection / STAC API) into a flat list of StacItems.
- */
-import { isStacCatalog, isStacCollection, isStacFeatureCollection, isStacItem } from './stac.js';
-export async function hydrateStacItems(root, baseHref, adapter, opts) {
-    const limit = opts.limit ?? 2000;
-    const concurrency = opts.concurrency ?? 12;
-    const followPagination = opts.followPagination ?? true;
-    const signal = opts.signal;
-    const urlToKey = opts.urlToKey;
-    const items = [];
-    let truncated = false;
-    const emit = (batch) => {
-        if (batch.length === 0)
-            return;
-        items.push(...batch);
-        opts.onBatch?.(batch);
-        opts.onProgress?.(items.length, undefined);
-    };
-    if (root.kind === 'item') {
-        emit([absolutizeItemAssets(root.item, baseHref)]);
-        return { items, truncated: false, rootBaseHref: baseHref };
-    }
-    if (root.kind === 'item-collection') {
-        await consumeFeatureCollection(root.fc, baseHref, adapter, {
-            signal,
-            concurrency,
-            limit,
-            followPagination,
-            urlToKey,
-            onAccept: (batch) => emit(batch),
-            stopCheck: () => items.length >= limit,
-            onTruncate: () => {
-                truncated = true;
-            }
-        });
-        return { items: items.slice(0, limit), truncated, rootBaseHref: baseHref };
-    }
-    if (root.kind === 'collection' || root.kind === 'catalog') {
-        const itemLinks = collectItemLinks(root.payload, baseHref);
-        const childLinks = root.kind === 'catalog' || itemLinks.length === 0
-            ? collectChildLinks(root.payload, baseHref)
-            : [];
-        if (itemLinks.length > 0) {
-            await fetchItems(itemLinks, adapter, baseHref, {
-                signal,
-                concurrency,
-                urlToKey,
-                onBatch: (batch) => emit(batch),
-                stopCheck: () => items.length >= limit,
-                onTruncate: () => {
-                    truncated = true;
-                }
-            });
-        }
-        if (!truncated && items.length < limit && childLinks.length > 0) {
-            const queue = [...childLinks];
-            const stopCheck = () => items.length >= limit || signal.aborted;
-            const workerCount = Math.min(concurrency, queue.length);
-            const workers = [];
-            for (let i = 0; i < workerCount; i++) {
-                workers.push((async () => {
-                    while (queue.length > 0) {
-                        if (stopCheck()) {
-                            if (items.length >= limit)
-                                truncated = true;
-                            queue.length = 0;
-                            return;
-                        }
-                        const childHref = queue.shift();
-                        if (!childHref)
-                            return;
-                        try {
-                            const childJson = await fetchJson(adapter, childHref, baseHref, signal, urlToKey);
-                            if (stopCheck()) {
-                                if (items.length >= limit)
-                                    truncated = true;
-                                queue.length = 0;
-                                return;
-                            }
-                            const childKind = classifyFetchedJson(childJson);
-                            if (childKind.kind === 'none')
-                                continue;
-                            const sub = await hydrateStacItems(childKind, childHref, adapter, {
-                                ...opts,
-                                limit: limit - items.length,
-                                onBatch: (batch) => emit(batch),
-                                onProgress: undefined
-                            });
-                            if (sub.truncated)
-                                truncated = true;
-                        }
-                        catch {
-                            // Skip unreachable child, keep aggregating.
-                        }
-                    }
-                })());
-            }
-            await Promise.all(workers);
-        }
-        return { items: items.slice(0, limit), truncated, rootBaseHref: baseHref };
-    }
-    return { items, truncated: false, rootBaseHref: baseHref };
-}
-// ─── Internals ──────────────────────────────────────────────────────
-function collectItemLinks(payload, baseHref) {
-    return (payload.links ?? [])
-        .filter((l) => !!l && typeof l.href === 'string' && l.rel === 'item')
-        .map((l) => absolutizeHref(l.href, baseHref));
-}
-function collectChildLinks(payload, baseHref) {
-    return (payload.links ?? [])
-        .filter((l) => !!l && typeof l.href === 'string' && l.rel === 'child')
-        .map((l) => absolutizeHref(l.href, baseHref));
-}
-async function consumeFeatureCollection(fc, baseHref, adapter, ctx) {
-    const accepted = fc.features
-        .filter(isStacItem)
-        .map((item) => absolutizeItemAssets(item, baseHref));
-    ctx.onAccept(accepted);
-    if (ctx.stopCheck()) {
-        ctx.onTruncate();
-        return;
-    }
-    if (!ctx.followPagination)
-        return;
-    const next = (fc.links ?? []).find((l) => l && l.rel === 'next' && typeof l.href === 'string');
-    if (!next)
-        return;
-    const nextHref = absolutizeHref(next.href, baseHref);
-    if (ctx.signal.aborted)
-        return;
-    try {
-        const json = await fetchJson(adapter, nextHref, baseHref, ctx.signal, ctx.urlToKey);
-        if (!isStacFeatureCollection(json))
-            return;
-        await consumeFeatureCollection(json, nextHref, adapter, ctx);
-    }
-    catch {
-        // Pagination dead-end, keep what we have.
-    }
-}
-async function fetchItems(hrefs, adapter, baseHref, ctx) {
-    const queue = [...hrefs];
-    const workers = [];
-    const workerCount = Math.min(ctx.concurrency, queue.length);
-    for (let i = 0; i < workerCount; i++) {
-        workers.push((async () => {
-            while (queue.length > 0) {
-                if (ctx.signal.aborted)
-                    return;
-                if (ctx.stopCheck()) {
-                    ctx.onTruncate();
-                    queue.length = 0;
-                    return;
-                }
-                const href = queue.shift();
-                if (!href)
-                    return;
-                try {
-                    const json = await fetchJson(adapter, href, baseHref, ctx.signal, ctx.urlToKey);
-                    if (isStacItem(json))
-                        ctx.onBatch([absolutizeItemAssets(json, href)]);
-                }
-                catch {
-                    // Skip this item, a dead link is not fatal.
-                }
-            }
-        })());
-    }
-    await Promise.all(workers);
-}
-async function fetchJson(adapter, href, _baseHref, signal, urlToKey) {
-    // Absolute URLs that belong to the caller's own bucket route through the
-    // adapter so SigV4 presigning applies — raw `fetch` would 403 on private
-    // buckets. Foreign origins stay on plain `fetch`. Relative hrefs reach here
-    // only when absolutizeHref could not resolve them against baseHref.
-    if (/^https?:/i.test(href)) {
-        const ownKey = urlToKey ? urlToKey(href) : null;
-        if (ownKey !== null) {
-            const buf = await adapter.read(ownKey, undefined, undefined, signal);
-            return JSON.parse(new TextDecoder().decode(buf));
-        }
-        const res = await fetch(href, { signal });
-        if (!res.ok)
-            throw new Error(`HTTP ${res.status} for ${href}`);
-        return await res.json();
-    }
-    const buf = await adapter.read(href, undefined, undefined, signal);
-    return JSON.parse(new TextDecoder().decode(buf));
-}
-function classifyFetchedJson(json) {
-    if (isStacItem(json))
-        return { kind: 'item', item: json };
-    if (isStacFeatureCollection(json))
-        return { kind: 'item-collection', fc: json };
-    if (isStacCollection(json))
-        return { kind: 'collection', payload: json };
-    if (isStacCatalog(json))
-        return { kind: 'catalog', payload: json };
-    return { kind: 'none' };
-}
-/**
- * Resolve a possibly-relative href against a base. STAC catalogs commonly use
- * `./child/foo.json` or `../foo.json`. `new URL(relative, base)` handles both.
- */
-export function absolutizeHref(href, baseHref) {
-    if (/^https?:/i.test(href) || /^s3:/i.test(href) || /^azure:/i.test(href))
-        return href;
-    try {
-        return new URL(href, baseHref).toString();
-    }
-    catch {
-        return href;
-    }
-}
-/**
- * Return a new StacItem with every asset href resolved against the URL the
- * item itself was fetched from. Asset hrefs in STAC Items are relative to the
- * item JSON (`./B04.tif`, `../scene/asset.tif`), so downstream consumers that
- * hand them to `GeoTIFF.fromUrl` or `fetch` need absolute URLs.
- */
-function absolutizeItemAssets(item, itemHref) {
-    const assets = item.assets;
-    if (!assets)
-        return item;
-    let changed = false;
-    const resolved = {};
-    for (const [key, asset] of Object.entries(assets)) {
-        if (asset?.href && typeof asset.href === 'string') {
-            const abs = absolutizeHref(asset.href, itemHref);
-            if (abs !== asset.href)
-                changed = true;
-            resolved[key] = { ...asset, href: abs };
-        }
-        else {
-            resolved[key] = asset;
-        }
-    }
-    return changed ? { ...item, assets: resolved } : item;
-}

package/dist/utils/stac.d.ts

@@ -1,136 +0,0 @@
-/**
- * STAC (SpatioTemporal Asset Catalog) detection and parsing.
- *
- * Pure TypeScript helpers shared by ViewerRouter, StacMosaicViewer, and
- * MultiCogViewer. No Svelte dependency, publishable via objex-utils.
- */
-/** STAC Link (shared by Catalog/Collection/Item). */
-export interface StacLink {
-    rel: string;
-    href: string;
-    type?: string;
-    title?: string;
-}
-/** STAC Item (GeoJSON Feature shape with stac_version). */
-export interface StacItem {
-    type: 'Feature';
-    stac_version: string;
-    id: string;
-    bbox?: [number, number, number, number];
-    geometry?: unknown;
-    properties?: Record<string, unknown>;
-    assets?: Record<string, StacAsset>;
-    collection?: string;
-    links?: StacLink[];
-}
-/** STAC FeatureCollection (collection of Items). Also used for STAC API responses. */
-export interface StacFeatureCollection {
-    type: 'FeatureCollection';
-    stac_version?: string;
-    features: StacItem[];
-    links?: StacLink[];
-}
-/** STAC Collection (a grouping of Items with its own metadata and links). */
-export interface StacCollection {
-    type: 'Collection';
-    stac_version: string;
-    id: string;
-    description?: string;
-    extent?: {
-        spatial?: {
-            bbox?: number[][];
-        };
-        temporal?: unknown;
-    };
-    links: StacLink[];
-}
-/** STAC Catalog (a directory-like grouping of Catalogs/Collections/Items via links). */
-export interface StacCatalog {
-    type: 'Catalog';
-    stac_version: string;
-    id: string;
-    description?: string;
-    links: StacLink[];
-}
-/** Single asset entry within a STAC item. */
-export interface StacAsset {
-    href: string;
-    type?: string;
-    title?: string;
-    roles?: string[];
-    /** Set when the asset carries `eo:bands`. */
-    'eo:bands'?: {
-        name?: string;
-        common_name?: string;
-    }[];
-}
-/** Sentinel-2 band slot identifier, shared with utils/cog.ts composites. */
-export type BandSlot = 'red' | 'green' | 'blue' | 'nir' | 'swir1' | 'swir2' | 'rededge';
-/** Parsed band map: slot name → HTTPS asset URL. */
-export type BandMap = Partial<Record<BandSlot, string>>;
-/** Asset keys providers use for the single "display COG" asset, in priority order. */
-export declare const STAC_COG_ASSET_KEYS: readonly ["visual", "image", "data", "rendered_preview"];
-/** Shape-check a parsed JSON object as a STAC Item. */
-export declare function isStacItem(json: unknown): json is StacItem;
-/** Shape-check a parsed JSON object as a STAC FeatureCollection. */
-export declare function isStacFeatureCollection(json: unknown): json is StacFeatureCollection;
-/** STAC Collection detection: `type === 'Collection'` + stac_version + links array. */
-export declare function isStacCollection(json: unknown): json is StacCollection;
-/** STAC Catalog detection: `type === 'Catalog'` + stac_version + links array. */
-export declare function isStacCatalog(json: unknown): json is StacCatalog;
-/** Routing verdict for any STAC-shaped JSON payload. */
-export type StacRoutableKind = {
-    kind: 'item';
-    item: StacItem;
-} | {
-    kind: 'item-collection';
-    fc: StacFeatureCollection;
-} | {
-    kind: 'collection';
-    payload: StacCollection;
-} | {
-    kind: 'catalog';
-    payload: StacCatalog;
-} | {
-    kind: 'none';
-};
-/** Classify an arbitrary parsed JSON into one of the STAC routing buckets. */
-export declare function classifyStac(json: unknown): StacRoutableKind;
-/**
- * Pick the COG-ish asset href from a STAC Item. Returns the href of the named
- * asset when `preferred` is given and present, else scans STAC_COG_ASSET_KEYS,
- * else falls back to any asset whose `type` contains "tiff". Returns null when
- * nothing matches.
- */
-export declare function pickCogAssetHref(item: StacItem, preferred?: string): string | null;
-/** True when a single STAC Item exposes a COG-ish asset and a bbox. */
-export declare function detectMosaicCapable(item: StacItem): boolean;
-/** True when a single STAC Item exposes Sentinel-2-style RGB bands (MultiCog). */
-export declare function detectMultiCogCapable(item: StacItem): boolean;
-/** WGS84 bbox helper. Returns `null` if no bbox can be derived. */
-export declare function stacItemBbox(item: StacItem): [number, number, number, number] | null;
-/** Normalized mosaic source entry consumed by MosaicLayer. */
-export interface MosaicSourceMeta {
-    id: string;
-    bbox: [number, number, number, number];
-    href: string;
-}
-/**
- * Normalize a STAC Item or a plain `{id?, bbox, href}` record into a
- * MosaicSourceMeta. Returns null when essentials (bbox / href) are missing.
- */
-export declare function buildMosaicSourceMeta(input: StacItem | {
-    id?: string;
-    bbox: [number, number, number, number] | number[];
-    href: string;
-}, assetKey?: string): MosaicSourceMeta | null;
-/**
- * Map Sentinel-2 STAC item assets to a BandMap. Recognizes:
- *  - `eo:bands[0].common_name` (preferred, stable across providers)
- *  - asset key heuristics for Microsoft PC / Element 84 / AWS S2 L2A buckets
- * Returns an empty map when no bands are identifiable so callers can fall
- * back to a different viewer.
- */
-export declare function extractSentinelBandAssets(item: StacItem): BandMap;
-/** True when the band map has enough channels for a True Color composite. */
-export declare function hasRgbBands(map: BandMap): boolean;