@walkthru-earth/objex 1.3.0 → 1.4.0

package/dist/utils/stac.js

@@ -1,176 +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.
- */
-/** Asset keys providers use for the single "display COG" asset, in priority order. */
-export const STAC_COG_ASSET_KEYS = ['visual', 'image', 'data', 'rendered_preview'];
-/** Shape-check a parsed JSON object as a STAC Item. */
-export function isStacItem(json) {
-    if (!json || typeof json !== 'object')
-        return false;
-    const obj = json;
-    return obj.type === 'Feature' && typeof obj.stac_version === 'string';
-}
-/** Shape-check a parsed JSON object as a STAC FeatureCollection. */
-export function isStacFeatureCollection(json) {
-    if (!json || typeof json !== 'object')
-        return false;
-    const obj = json;
-    if (obj.type !== 'FeatureCollection')
-        return false;
-    if (!Array.isArray(obj.features) || obj.features.length === 0)
-        return false;
-    if (typeof obj.stac_version === 'string')
-        return true;
-    return isStacItem(obj.features[0]);
-}
-/** STAC Collection detection: `type === 'Collection'` + stac_version + links array. */
-export function isStacCollection(json) {
-    if (!json || typeof json !== 'object')
-        return false;
-    const obj = json;
-    return (obj.type === 'Collection' && typeof obj.stac_version === 'string' && Array.isArray(obj.links));
-}
-/** STAC Catalog detection: `type === 'Catalog'` + stac_version + links array. */
-export function isStacCatalog(json) {
-    if (!json || typeof json !== 'object')
-        return false;
-    const obj = json;
-    return obj.type === 'Catalog' && typeof obj.stac_version === 'string' && Array.isArray(obj.links);
-}
-/** Classify an arbitrary parsed JSON into one of the STAC routing buckets. */
-export function classifyStac(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' };
-}
-/**
- * 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 function pickCogAssetHref(item, preferred) {
-    const assets = item.assets ?? {};
-    if (preferred && assets[preferred]?.href)
-        return assets[preferred].href;
-    for (const key of STAC_COG_ASSET_KEYS) {
-        if (assets[key]?.href)
-            return assets[key].href;
-    }
-    for (const asset of Object.values(assets)) {
-        const t = typeof asset?.type === 'string' ? asset.type.toLowerCase() : '';
-        if (asset?.href && t.includes('tiff'))
-            return asset.href;
-    }
-    return null;
-}
-/** True when a single STAC Item exposes a COG-ish asset and a bbox. */
-export function detectMosaicCapable(item) {
-    return stacItemBbox(item) !== null && pickCogAssetHref(item) !== null;
-}
-/** True when a single STAC Item exposes Sentinel-2-style RGB bands (MultiCog). */
-export function detectMultiCogCapable(item) {
-    return hasRgbBands(extractSentinelBandAssets(item));
-}
-/** WGS84 bbox helper. Returns `null` if no bbox can be derived. */
-export function stacItemBbox(item) {
-    if (Array.isArray(item.bbox) && item.bbox.length >= 4) {
-        return [Number(item.bbox[0]), Number(item.bbox[1]), Number(item.bbox[2]), Number(item.bbox[3])];
-    }
-    return null;
-}
-/**
- * Normalize a STAC Item or a plain `{id?, bbox, href}` record into a
- * MosaicSourceMeta. Returns null when essentials (bbox / href) are missing.
- */
-export function buildMosaicSourceMeta(input, assetKey) {
-    if (!input || typeof input !== 'object')
-        return null;
-    if (isStacItem(input)) {
-        const bbox = stacItemBbox(input);
-        if (!bbox)
-            return null;
-        const href = pickCogAssetHref(input, assetKey);
-        if (!href)
-            return null;
-        return {
-            id: String(input.id ?? href),
-            bbox,
-            href
-        };
-    }
-    const raw = input;
-    if (Array.isArray(raw.bbox) && raw.bbox.length >= 4 && typeof raw.href === 'string') {
-        return {
-            id: String(raw.id ?? raw.href),
-            bbox: [Number(raw.bbox[0]), Number(raw.bbox[1]), Number(raw.bbox[2]), Number(raw.bbox[3])],
-            href: raw.href
-        };
-    }
-    return null;
-}
-// Provider-specific asset key conventions. Each entry maps a BandSlot to the
-// asset keys providers are known to use. First match wins, so list more
-// specific keys before generic ones.
-const BAND_KEY_FALLBACKS = {
-    red: ['red', 'B04', 'B4', 'visual-red'],
-    green: ['green', 'B03', 'B3', 'visual-green'],
-    blue: ['blue', 'B02', 'B2', 'visual-blue'],
-    nir: ['nir', 'nir08', 'B08', 'B8', 'B8A'],
-    swir1: ['swir16', 'swir1', 'B11'],
-    swir2: ['swir22', 'swir2', 'B12'],
-    rededge: ['rededge1', 'rededge', 'B05', 'B5']
-};
-/**
- * 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 function extractSentinelBandAssets(item) {
-    const out = {};
-    const assets = item.assets ?? {};
-    for (const [key, asset] of Object.entries(assets)) {
-        if (!asset?.href)
-            continue;
-        const bands = asset['eo:bands'];
-        if (Array.isArray(bands) && bands.length >= 1) {
-            const common = bands[0]?.common_name?.toLowerCase();
-            if (common && isBandSlot(common)) {
-                if (!out[common])
-                    out[common] = asset.href;
-                continue;
-            }
-        }
-        for (const slot of Object.keys(BAND_KEY_FALLBACKS)) {
-            if (BAND_KEY_FALLBACKS[slot].includes(key) && !out[slot]) {
-                out[slot] = asset.href;
-                break;
-            }
-        }
-    }
-    return out;
-}
-function isBandSlot(value) {
-    return (value === 'red' ||
-        value === 'green' ||
-        value === 'blue' ||
-        value === 'nir' ||
-        value === 'swir1' ||
-        value === 'swir2' ||
-        value === 'rededge');
-}
-/** True when the band map has enough channels for a True Color composite. */
-export function hasRgbBands(map) {
-    return Boolean(map.red && map.green && map.blue);
-}

package/dist/utils/storage-url.d.ts

@@ -1,90 +0,0 @@
-/**
- * Universal cloud storage URL / bucket parser.
- *
- * Accepts the many URI/URL formats that users commonly paste and extracts
- * the correct bucket, region, endpoint, and provider.
- *
- * Supported URI schemes:
- *   s3://   s3a://   s3n://   aws://   — Amazon S3 / S3-compatible
- *   r2://                              — Cloudflare R2
- *   gs://   gcs://                     — Google Cloud Storage
- *   azure://  az://                    — Azure Blob Storage
- *   abfs://   abfss://                — Azure Data Lake (ADLS Gen2)
- *   wasbs://                           — Azure Blob (Hadoop WASB driver)
- *   swift://                           — OpenStack Swift
- *   file://  filesystem://             — Local filesystem
- *
- * Supported HTTPS URL patterns:
- *   https://<bucket>.s3.<region>.amazonaws.com[/prefix]     — AWS virtual-hosted
- *   https://s3.<region>.amazonaws.com/<bucket>[/prefix]     — AWS path-style
- *   https://s3.amazonaws.com/<bucket>                       — AWS global
- *   https://<account>.r2.cloudflarestorage.com/<bucket>     — Cloudflare R2
- *   https://storage.googleapis.com/<bucket>                 — Google Cloud Storage
- *   https://<bucket>.storage.googleapis.com[/prefix]        — GCS virtual-hosted
- *   https://<bucket>.<region>.digitaloceanspaces.com        — DigitalOcean Spaces
- *   https://<region>.digitaloceanspaces.com/<bucket>        — DO Spaces path-style
- *   https://s3.<region>.wasabisys.com/<bucket>              — Wasabi
- *   https://f<id>.backblazeb2.com/file/<bucket>             — Backblaze B2
- *   https://<bucket>.s3.<region>.backblazeb2.com            — B2 S3-compatible
- *   https://<bucket>.oss-<region>.aliyuncs.com              — Alibaba Cloud OSS
- *   https://<bucket>.cos.<region>.myqcloud.com              — Tencent COS
- *   https://storage.yandexcloud.net/<bucket>                — Yandex Cloud
- *   https://gateway.storjshare.io/<bucket>                   — Storj S3 gateway
- *   https://link.storjshare.io/raw/<access>/<bucket>        — Storj linksharing
- *   https://<custom-endpoint>/<bucket>                      — Generic S3-compatible
- *
- * Also handles plain bucket names (no protocol).
- */
-export type StorageProvider = string;
-export interface ParsedStorageUrl {
-    bucket: string;
-    region: string;
-    endpoint: string;
-    provider: StorageProvider;
-    /** Original prefix/path after bucket, if any */
-    prefix: string;
-}
-/** STAC API path test, one source of truth. Tests pathname only. */
-export declare const STAC_API_PATH_RE: RegExp;
-/**
- * Returns true when the host matches any of the provider host patterns
- * that `parseStorageUrl` recognizes on the HTTPS branch.
- */
-export declare function isKnownBucketHost(host: string): boolean;
-export interface Defaults {
-    region?: string;
-    endpoint?: string;
-    provider?: StorageProvider;
-}
-/**
- * Parse a user-provided bucket/URL string into structured storage connection parts.
- */
-export declare function parseStorageUrl(input: string, defaults?: Defaults): ParsedStorageUrl;
-/**
- * Returns true if the input looks like a URL/URI rather than a plain bucket name.
- * Covers all recognized cloud storage URI schemes.
- */
-export declare function looksLikeUrl(input: string): boolean;
-/**
- * Given a parsed URL result, build a human-readable summary of what was detected.
- */
-export declare function describeParseResult(parsed: ParsedStorageUrl): string;
-export type UrlClassification = {
-    kind: 'scheme';
-    parsed: ParsedStorageUrl;
-} | {
-    kind: 'object-storage';
-    parsed: ParsedStorageUrl;
-} | {
-    kind: 'stac-api';
-    url: URL;
-} | {
-    kind: 'remote-file';
-    url: URL;
-};
-/**
- * Classify a user-supplied URL/URI into one of four buckets. Unparseable or
- * plain inputs fall through to `remote-file` with a best-effort URL parse,
- * returning a synthetic `https://` URL when `new URL()` would throw.
- */
-export declare function classifyUrl(input: string): UrlClassification;