@walkthru-earth/objex 1.3.1 → 1.5.0

package/dist/query/stac-geoparquet.js

@@ -1,136 +0,0 @@
-/**
- * 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/utils/clipboard.d.ts

@@ -1,13 +0,0 @@
-/**
- * Copy text to clipboard and run a feedback callback for COPY_FEEDBACK_MS.
- * Silently catches clipboard errors (e.g. insecure context).
- *
- * @returns true if copy succeeded, false otherwise.
- */
-export declare function copyToClipboard(text: string, onFeedback?: (copied: boolean) => void): Promise<boolean>;
-/**
- * Wire click-to-copy on all elements matching `selector` inside `root`.
- * Each element must have `data-code` (URI-encoded) with the text to copy.
- * Adds/removes a `copied` CSS class for visual feedback.
- */
-export declare function wireCodeCopyButtons(root: Element, selector: string): void;

package/dist/utils/clipboard.js

@@ -1,38 +0,0 @@
-import { COPY_FEEDBACK_MS } from '../constants.js';
-/**
- * Copy text to clipboard and run a feedback callback for COPY_FEEDBACK_MS.
- * Silently catches clipboard errors (e.g. insecure context).
- *
- * @returns true if copy succeeded, false otherwise.
- */
-export async function copyToClipboard(text, onFeedback) {
-    try {
-        await navigator.clipboard.writeText(text);
-        onFeedback?.(true);
-        setTimeout(() => onFeedback?.(false), COPY_FEEDBACK_MS);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Wire click-to-copy on all elements matching `selector` inside `root`.
- * Each element must have `data-code` (URI-encoded) with the text to copy.
- * Adds/removes a `copied` CSS class for visual feedback.
- */
-export function wireCodeCopyButtons(root, selector) {
-    for (const btn of root.querySelectorAll(selector)) {
-        btn.addEventListener('click', async () => {
-            const code = decodeURIComponent(btn.dataset.code ?? '');
-            try {
-                await navigator.clipboard.writeText(code);
-                btn.classList.add('copied');
-                setTimeout(() => btn.classList.remove('copied'), COPY_FEEDBACK_MS);
-            }
-            catch {
-                // clipboard not available
-            }
-        });
-    }
-}

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

@@ -1,27 +0,0 @@
-/**
- * Cloud storage protocol URL utilities — pure TS, no Svelte dependency.
- *
- * Converts cloud protocol URLs (s3://, gs://) to HTTPS URLs for browser access.
- * Provider-aware native scheme lookup.
- */
-/**
- * Map provider to its native URI scheme prefix.
- * Derived from the registry's `schemes` array (first entry is the primary scheme).
- * Falls back to 's3' for providers without a scheme (S3-compatible).
- */
-export declare function getNativeScheme(provider: string): string;
-/**
- * Safely decode a percent-encoded URI component.
- * Returns the original string if decoding fails (malformed sequences).
- */
-export declare function safeDecodeURIComponent(s: string): string;
-/**
- * Convert a cloud storage protocol URL (s3://, gs://) to an HTTPS URL
- * for browser access. Returns the original URL if already HTTP(S) or unknown.
- *
- * Supported:
- * - `s3://bucket/key` → `https://s3.{region}.amazonaws.com/{bucket}/{key}`
- *   (region auto-detected from bucket name when possible)
- * - `gs://bucket/key` → `https://storage.googleapis.com/{bucket}/{key}`
- */
-export declare function resolveCloudUrl(url: string): string;

package/dist/utils/cloud-url.js

@@ -1,61 +0,0 @@
-/**
- * Cloud storage protocol URL utilities — pure TS, no Svelte dependency.
- *
- * Converts cloud protocol URLs (s3://, gs://) to HTTPS URLs for browser access.
- * Provider-aware native scheme lookup.
- */
-import { buildProviderBaseUrl, PROVIDERS } from '../storage/providers.js';
-/** AWS region pattern — matches prefixes like "us-west-2", "eu-central-1", etc. */
-const AWS_REGION_RE = /^(us|eu|ap|sa|ca|me|af|il)-(north|south|east|west|central|northeast|southeast|northwest|southwest)-\d+/;
-/**
- * Map provider to its native URI scheme prefix.
- * Derived from the registry's `schemes` array (first entry is the primary scheme).
- * Falls back to 's3' for providers without a scheme (S3-compatible).
- */
-export function getNativeScheme(provider) {
-    const def = PROVIDERS[provider];
-    if (def?.schemes.length)
-        return def.schemes[0];
-    return 's3';
-}
-/**
- * Safely decode a percent-encoded URI component.
- * Returns the original string if decoding fails (malformed sequences).
- */
-export function safeDecodeURIComponent(s) {
-    try {
-        return decodeURIComponent(s);
-    }
-    catch {
-        return s;
-    }
-}
-/**
- * Convert a cloud storage protocol URL (s3://, gs://) to an HTTPS URL
- * for browser access. Returns the original URL if already HTTP(S) or unknown.
- *
- * Supported:
- * - `s3://bucket/key` → `https://s3.{region}.amazonaws.com/{bucket}/{key}`
- *   (region auto-detected from bucket name when possible)
- * - `gs://bucket/key` → `https://storage.googleapis.com/{bucket}/{key}`
- */
-export function resolveCloudUrl(url) {
-    // S3 / S3-compatible: s3://, s3a://, s3n://
-    const s3Match = url.match(/^s3[an]?:\/\/([^/]+)\/?(.*)$/);
-    if (s3Match) {
-        const [, bucket, key] = s3Match;
-        // Detect region from bucket name (e.g. "us-west-2.opendata.source.coop")
-        const regionMatch = bucket.match(AWS_REGION_RE);
-        const region = regionMatch ? regionMatch[0] : 'us-east-1';
-        const base = buildProviderBaseUrl('s3', '', bucket, region);
-        return key ? `${base}/${key}` : base;
-    }
-    // Google Cloud Storage: gs://, gcs://
-    const gcsMatch = url.match(/^gcs?:\/\/([^/]+)\/?(.*)$/);
-    if (gcsMatch) {
-        const [, bucket, key] = gcsMatch;
-        const base = buildProviderBaseUrl('gcs', '', bucket, '');
-        return key ? `${base}/${key}` : base;
-    }
-    return url;
-}

package/dist/utils/cog-pure.d.ts

@@ -1,25 +0,0 @@
-/** SampleFormat tag value → human label. */
-export declare const SF_LABELS: Record<number, string>;
-export interface GeoBounds {
-    west: number;
-    south: number;
-    east: number;
-    north: number;
-}
-export interface CogInfo {
-    width: number;
-    height: number;
-    bandCount: number;
-    dataType: string;
-    bounds: GeoBounds;
-    downsampled?: boolean;
-}
-/** Safely clamp a number to a range, treating NaN/Infinity as the fallback. */
-export declare function safeClamp(v: number, lo: number, hi: number, fallback: number): number;
-/** Clamp geographic bounds to valid MapLibre web-Mercator range. */
-export declare function clampBounds(b: GeoBounds): GeoBounds;
-/**
- * Build a data-type label from GeoTIFF sample format and bits per sample.
- * e.g. "uint8", "float32", "int16"
- */
-export declare function buildDataTypeLabel(sampleFormat: number, bitsPerSample: number): string;

package/dist/utils/cog-pure.js

@@ -1,35 +0,0 @@
-// Dependency-free subset of `cog.ts` so that `@walkthru-earth/objex-utils`
-// can re-export these helpers without dragging in `@developmentseed/epsg`,
-// `@developmentseed/geotiff`, `@developmentseed/proj`, `proj4`, or
-// `maplibre-gl`. tsup preserves bare side-effect imports from externalized
-// modules even when all named bindings are tree-shaken, so the pure surface
-// MUST live in a module that has zero heavy imports.
-/** SampleFormat tag value → human label. */
-export const SF_LABELS = {
-    1: 'uint',
-    2: 'int',
-    3: 'float',
-    4: 'void',
-    5: 'complex int',
-    6: 'complex float'
-};
-/** Safely clamp a number to a range, treating NaN/Infinity as the fallback. */
-export function safeClamp(v, lo, hi, fallback) {
-    return Number.isFinite(v) ? Math.max(lo, Math.min(hi, v)) : fallback;
-}
-/** Clamp geographic bounds to valid MapLibre web-Mercator range. */
-export function clampBounds(b) {
-    return {
-        west: safeClamp(b.west, -180, 180, -180),
-        south: safeClamp(b.south, -85.051129, 85.051129, -85.051129),
-        east: safeClamp(b.east, -180, 180, 180),
-        north: safeClamp(b.north, -85.051129, 85.051129, 85.051129)
-    };
-}
-/**
- * Build a data-type label from GeoTIFF sample format and bits per sample.
- * e.g. "uint8", "float32", "int16"
- */
-export function buildDataTypeLabel(sampleFormat, bitsPerSample) {
-    return `${SF_LABELS[sampleFormat] ?? `sf${sampleFormat}`}${bitsPerSample ?? ''}`;
-}

package/dist/utils/column-types.d.ts

@@ -1,5 +0,0 @@
-export type TypeCategory = 'number' | 'string' | 'date' | 'boolean' | 'geo' | 'binary' | 'json' | 'other';
-export declare function classifyType(duckdbType: string): TypeCategory;
-export declare function typeColor(category: TypeCategory): string;
-export declare function typeBadgeClass(category: TypeCategory): string;
-export declare function typeLabel(category: TypeCategory): string;

package/dist/utils/column-types.js

@@ -1,137 +0,0 @@
-const NUMBER_TYPES = [
-    'TINYINT',
-    'SMALLINT',
-    'INTEGER',
-    'BIGINT',
-    'HUGEINT',
-    'UTINYINT',
-    'USMALLINT',
-    'UINTEGER',
-    'UBIGINT',
-    'FLOAT',
-    'DOUBLE',
-    'DECIMAL',
-    'NUMERIC',
-    'REAL',
-    'INT',
-    'INT1',
-    'INT2',
-    'INT4',
-    'INT8',
-    'SIGNED',
-    'SHORT',
-    'LONG'
-];
-const STRING_TYPES = ['VARCHAR', 'TEXT', 'STRING', 'CHAR', 'BPCHAR', 'NAME', 'UUID', 'ENUM'];
-const DATE_TYPES = [
-    'DATE',
-    'TIME',
-    'TIMESTAMP',
-    'TIMESTAMP_S',
-    'TIMESTAMP_MS',
-    'TIMESTAMP_NS',
-    'TIMESTAMP WITH TIME ZONE',
-    'TIMESTAMPTZ',
-    'INTERVAL',
-    'TIMESTAMP_TZ'
-];
-const BOOLEAN_TYPES = ['BOOLEAN', 'BOOL', 'LOGICAL'];
-const GEO_TYPES = [
-    'GEOMETRY',
-    'POINT',
-    'LINESTRING',
-    'POLYGON',
-    'MULTIPOINT',
-    'MULTILINESTRING',
-    'MULTIPOLYGON',
-    'GEOMETRYCOLLECTION',
-    'WKB_GEOMETRY'
-];
-const BINARY_TYPES = ['BLOB', 'BYTEA', 'BINARY', 'VARBINARY'];
-const JSON_TYPES = ['JSON', 'JSONB'];
-export function classifyType(duckdbType) {
-    const upper = duckdbType.toUpperCase().trim();
-    // Handle parameterized types like DECIMAL(18,3), VARCHAR(100)
-    const base = upper.replace(/\(.*\)/, '').trim();
-    if (NUMBER_TYPES.includes(base))
-        return 'number';
-    if (STRING_TYPES.includes(base))
-        return 'string';
-    if (DATE_TYPES.includes(base))
-        return 'date';
-    if (BOOLEAN_TYPES.includes(base))
-        return 'boolean';
-    if (GEO_TYPES.includes(base))
-        return 'geo';
-    if (BINARY_TYPES.includes(base))
-        return 'binary';
-    if (JSON_TYPES.includes(base))
-        return 'json';
-    // Compound types
-    if (base.startsWith('STRUCT') || base.startsWith('MAP') || base.startsWith('UNION'))
-        return 'json';
-    if (base.endsWith('[]') || base.startsWith('LIST'))
-        return 'json';
-    // Fallback checks
-    if (upper.includes('INT') ||
-        upper.includes('FLOAT') ||
-        upper.includes('DOUBLE') ||
-        upper.includes('DECIMAL') ||
-        upper.includes('NUMERIC'))
-        return 'number';
-    if (upper.includes('CHAR') || upper.includes('TEXT') || upper.includes('STRING'))
-        return 'string';
-    if (upper.includes('TIME') || upper.includes('DATE'))
-        return 'date';
-    if (upper.includes('BOOL'))
-        return 'boolean';
-    if (upper.includes('GEOMETRY') || upper.includes('GEO') || upper.includes('WKB'))
-        return 'geo';
-    if (upper.includes('BLOB') || upper.includes('BINARY'))
-        return 'binary';
-    if (upper.includes('JSON') ||
-        upper.includes('STRUCT') ||
-        upper.includes('MAP') ||
-        upper.includes('LIST'))
-        return 'json';
-    return 'other';
-}
-const TYPE_COLORS = {
-    number: 'text-blue-500',
-    string: 'text-green-500',
-    date: 'text-amber-500',
-    boolean: 'text-purple-500',
-    geo: 'text-teal-500',
-    binary: 'text-zinc-500',
-    json: 'text-orange-500',
-    other: 'text-zinc-400'
-};
-const TYPE_BADGE_CLASSES = {
-    number: 'bg-blue-500/10 text-blue-600 dark:text-blue-400 border-blue-500/20',
-    string: 'bg-green-500/10 text-green-600 dark:text-green-400 border-green-500/20',
-    date: 'bg-amber-500/10 text-amber-600 dark:text-amber-400 border-amber-500/20',
-    boolean: 'bg-purple-500/10 text-purple-600 dark:text-purple-400 border-purple-500/20',
-    geo: 'bg-teal-500/10 text-teal-600 dark:text-teal-400 border-teal-500/20',
-    binary: 'bg-zinc-500/10 text-zinc-600 dark:text-zinc-400 border-zinc-500/20',
-    json: 'bg-orange-500/10 text-orange-600 dark:text-orange-400 border-orange-500/20',
-    other: 'bg-zinc-500/10 text-zinc-500 dark:text-zinc-400 border-zinc-500/20'
-};
-const TYPE_LABELS = {
-    number: '#',
-    string: 'Aa',
-    date: 'dt',
-    boolean: 'T/F',
-    geo: 'geo',
-    binary: '01',
-    json: '{}',
-    other: '?'
-};
-export function typeColor(category) {
-    return TYPE_COLORS[category];
-}
-export function typeBadgeClass(category) {
-    return TYPE_BADGE_CLASSES[category];
-}
-export function typeLabel(category) {
-    return TYPE_LABELS[category];
-}

package/dist/utils/connection-identity.d.ts

@@ -1,51 +0,0 @@
-/**
- * Canonical connection identity.
- *
- * Single source of truth for deciding when two connection configs point at
- * the same bucket. Used by the connections store to deduplicate auto-detect,
- * manual add, and edit flows, so one physical bucket never ends up with
- * multiple competing local records.
- *
- * Identity rules, per provider:
- *
- *   azure  → (provider, endpoint, bucket)     endpoint carries the account
- *   gcs    → (provider, bucket)               GCS bucket names are global
- *   s3     → (provider, bucket, region)       AWS native: same bucket name
- *                                             can exist in exactly one region,
- *                                             but the region is load-bearing
- *                                             for signing, so a paste with a
- *                                             different region is a distinct
- *                                             connection until the user merges
- *   other  → (provider, endpoint, bucket)     r2, b2, minio, wasabi, storj,
- *                                             digitalocean, contabo, hetzner,
- *                                             linode, ovhcloud, custom
- *
- * Endpoint normalization is aggressive: scheme + host + non-default port +
- * pathname, with trailing slashes and default ports stripped, host lowercased.
- * That collapses the common trip hazards — http vs https, :443 vs empty,
- * trailing slash drift, mixed case host.
- */
-import type { ProviderId } from '../storage/providers.js';
-export interface ConnectionIdentityInput {
-    provider: string;
-    endpoint: string;
-    bucket: string;
-    region: string;
-}
-/**
- * Normalize an endpoint URL to a canonical form suitable for equality checks.
- * Empty / whitespace-only input returns `''` (the "no endpoint" sentinel).
- * Non-URL strings are lowercased and stripped of trailing slashes as a best
- * effort so the comparison is still deterministic.
- */
-export declare function normalizeEndpoint(raw: string | undefined | null): string;
-/** Collapse unknown / empty providers to `'s3'`; otherwise lowercase. */
-export declare function normalizeProvider(provider: string | undefined | null): ProviderId;
-/**
- * Produce a canonical key for a connection's identity. Two connection
- * configs with the same identity key point at the same physical bucket.
- * Returns `''` when the config is too incomplete to identify a bucket.
- */
-export declare function connectionIdentityKey(input: ConnectionIdentityInput): string;
-/** Convenience: true when both inputs share the same non-empty identity. */
-export declare function isSameConnectionIdentity(a: ConnectionIdentityInput, b: ConnectionIdentityInput): boolean;

package/dist/utils/connection-identity.js

@@ -1,97 +0,0 @@
-/**
- * Canonical connection identity.
- *
- * Single source of truth for deciding when two connection configs point at
- * the same bucket. Used by the connections store to deduplicate auto-detect,
- * manual add, and edit flows, so one physical bucket never ends up with
- * multiple competing local records.
- *
- * Identity rules, per provider:
- *
- *   azure  → (provider, endpoint, bucket)     endpoint carries the account
- *   gcs    → (provider, bucket)               GCS bucket names are global
- *   s3     → (provider, bucket, region)       AWS native: same bucket name
- *                                             can exist in exactly one region,
- *                                             but the region is load-bearing
- *                                             for signing, so a paste with a
- *                                             different region is a distinct
- *                                             connection until the user merges
- *   other  → (provider, endpoint, bucket)     r2, b2, minio, wasabi, storj,
- *                                             digitalocean, contabo, hetzner,
- *                                             linode, ovhcloud, custom
- *
- * Endpoint normalization is aggressive: scheme + host + non-default port +
- * pathname, with trailing slashes and default ports stripped, host lowercased.
- * That collapses the common trip hazards — http vs https, :443 vs empty,
- * trailing slash drift, mixed case host.
- */
-const DEFAULT_PORTS = {
-    'https:': '443',
-    'http:': '80'
-};
-/**
- * Normalize an endpoint URL to a canonical form suitable for equality checks.
- * Empty / whitespace-only input returns `''` (the "no endpoint" sentinel).
- * Non-URL strings are lowercased and stripped of trailing slashes as a best
- * effort so the comparison is still deterministic.
- */
-export function normalizeEndpoint(raw) {
-    if (!raw)
-        return '';
-    const trimmed = raw.trim();
-    if (!trimmed)
-        return '';
-    try {
-        const url = new URL(trimmed);
-        const scheme = url.protocol.toLowerCase();
-        const host = url.hostname.toLowerCase();
-        const defaultPort = DEFAULT_PORTS[scheme] ?? '';
-        const port = url.port && url.port !== defaultPort ? `:${url.port}` : '';
-        const path = url.pathname.replace(/\/+$/, '');
-        return `${scheme}//${host}${port}${path}`;
-    }
-    catch {
-        return trimmed.toLowerCase().replace(/\/+$/, '');
-    }
-}
-/** Collapse unknown / empty providers to `'s3'`; otherwise lowercase. */
-export function normalizeProvider(provider) {
-    if (!provider)
-        return 's3';
-    const p = provider.trim().toLowerCase();
-    if (!p || p === 'unknown')
-        return 's3';
-    return p;
-}
-/** Bucket names are case-sensitive on some backends, so preserve case. */
-function normalizeBucket(bucket) {
-    return (bucket ?? '').trim().replace(/^\/+|\/+$/g, '');
-}
-function normalizeRegion(region) {
-    return (region ?? '').trim().toLowerCase();
-}
-/**
- * Produce a canonical key for a connection's identity. Two connection
- * configs with the same identity key point at the same physical bucket.
- * Returns `''` when the config is too incomplete to identify a bucket.
- */
-export function connectionIdentityKey(input) {
-    const provider = normalizeProvider(input.provider);
-    const bucket = normalizeBucket(input.bucket);
-    if (!bucket)
-        return '';
-    const endpoint = normalizeEndpoint(input.endpoint);
-    const region = normalizeRegion(input.region);
-    if (provider === 'azure')
-        return `azure|${endpoint}|${bucket}`;
-    if (provider === 'gcs')
-        return `gcs|${bucket}`;
-    if (provider === 's3' && !endpoint)
-        return `s3|${bucket}|${region}`;
-    return `${provider}|${endpoint}|${bucket}`;
-}
-/** Convenience: true when both inputs share the same non-empty identity. */
-export function isSameConnectionIdentity(a, b) {
-    const key = connectionIdentityKey(a);
-    return key !== '' && key === connectionIdentityKey(b);
-}

package/dist/utils/error.d.ts

@@ -1,8 +0,0 @@
-/**
- * Shared error handling for async viewer load operations.
- */
-/**
- * Extract an error message from an unknown caught value.
- * Returns null for AbortError (caller should silently return).
- */
-export declare function handleLoadError(err: unknown): string | null;

package/dist/utils/error.js

@@ -1,12 +0,0 @@
-/**
- * Shared error handling for async viewer load operations.
- */
-/**
- * Extract an error message from an unknown caught value.
- * Returns null for AbortError (caller should silently return).
- */
-export function handleLoadError(err) {
-    if (err instanceof DOMException && err.name === 'AbortError')
-        return null;
-    return err instanceof Error ? err.message : String(err);
-}