@walkthru-earth/objex 1.1.0 → 1.2.1

package/dist/i18n/en.js

@@ -30,6 +30,14 @@ export const en = {
     'connection.accessKey': 'Access Key',
     'connection.secretKey': 'Secret Key',
     'connection.credentialNotice': "Your credentials are stored only in your browser's password manager if you choose to save them. They are never sent to any external server or stored in local storage.",
+    'connection.corsTitle': 'CORS Configuration',
+    'connection.corsRequired': 'Browser access requires CORS to be enabled on your bucket. Without it, requests will be blocked.',
+    'connection.corsDefault': 'CORS is enabled by default. No configuration needed.',
+    'connection.corsDocs': 'Official CORS docs',
+    'connection.corsCliTitle': 'Enable CORS via CLI',
+    'connection.readOnlyTitle': 'Read-Only Access',
+    'connection.readOnlyDocs': 'Official permissions docs',
+    'connection.readOnlyCliTitle': 'Restrict via CLI',
     'connection.testSuccess': 'Connection successful',
     'connection.testFail': 'Connection failed. Check your settings and try again.',
     'connection.testButton': 'Test Connection',
@@ -194,6 +202,12 @@ export const en = {
     'database.tablesHeader': 'Tables',
     'database.loadingTable': 'Loading table...',
     'database.selectTable': 'Select a table to browse',
+    // DuckLake
+    'ducklake.loading': 'Attaching DuckLake catalog...',
+    'ducklake.snapshot': 'Snapshot',
+    'ducklake.snapshots': 'snapshots',
+    'ducklake.noTables': 'No tables in this schema',
+    'ducklake.extensionHint': 'The DuckLake extension may not be available for this DuckDB-WASM version.',
     // PDF Viewer
     'pdf.badge': 'PDF',
     'pdf.loading': 'Loading PDF...',
@@ -317,6 +331,7 @@ export const en = {
     'map.loadingFgb': 'Loading FlatGeobuf...',
     'map.loadingCog': 'Loading COG...',
     'map.loadingZarr': 'Loading Zarr data...',
+    'map.zarrTooLarge': 'Array too large for map view ({shape}, ~{tiles} tiles). This dataset needs a multiscale pyramid for tiled rendering.',
     'map.features': 'features',
     'map.limit': '(limit)',
     'map.of': 'of',
@@ -327,6 +342,7 @@ export const en = {
     'map.flatgeobufInfo': 'FlatGeobuf Info',
     'map.cogInfo': 'COG Info',
     'map.cogCorsError': 'Cannot load COG: the server does not allow cross-origin requests (CORS). The file must be hosted with CORS headers enabled.',
+    'map.cogInvalidTiff': 'This file is not a valid TIFF. The server advertises image/tiff but the bytes do not match the TIFF signature, the file may be corrupt, encrypted, or mislabeled.',
     'map.cogUnsupportedFormat': 'This COG uses {{type}} format which is not supported for map rendering. Only RGB COGs can be displayed.',
     'map.noGeoColumn': 'No geometry column detected in schema',
     'map.noData': 'No data available for map view',
@@ -366,6 +382,15 @@ export const en = {
     'mapInfo.columns': 'Columns',
     'mapInfo.size': 'Size',
     'mapInfo.bands': 'Bands',
+    // COG Controls
+    'cog.style': 'Style',
+    'cog.band': 'Band',
+    'cog.singleBand': 'Single',
+    'cog.colorRamp': 'Color ramp',
+    'cog.pixelValue': 'Pixel Value',
+    'cog.reading': 'Reading pixel...',
+    'cog.rescale': 'Rescale',
+    'cog.rescaleReset': 'Reset',
     // PMTiles Viewer
     'pmtiles.mapView': 'Map',
     'pmtiles.archiveView': 'Archive',

package/dist/i18n/index.svelte.d.ts

@@ -1,5 +1,4 @@
 export type Locale = 'en' | 'ar';
-export declare function getLocale(): Locale;
 export declare function setLocale(l: Locale): void;
 export declare function getDir(): 'ltr' | 'rtl';
 /**

package/dist/i18n/index.svelte.js

@@ -3,9 +3,6 @@ import { en } from './en.js';
 const translations = { en, ar };
 const RTL_LOCALES = new Set(['ar']);
 let currentLocale = $state('en');
-export function getLocale() {
-    return currentLocale;
-}
 export function setLocale(l) {
     currentLocale = l;
 }

package/dist/index.d.ts

@@ -10,6 +10,8 @@ export { UrlAdapter } from './storage/url-adapter.js';
 export type { Connection, ConnectionConfig, FileEntry, Tab, Theme, WriteResult } from './types.js';
 export { copyToClipboard, wireCodeCopyButtons } from './utils/clipboard.js';
 export { getNativeScheme, resolveCloudUrl, safeDecodeURIComponent } from './utils/cloud-url.js';
+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 { handleLoadError } from './utils/error.js';

package/dist/index.js

@@ -10,6 +10,7 @@ export { UrlAdapter } from './storage/url-adapter.js';
 export { copyToClipboard, wireCodeCopyButtons } from './utils/clipboard.js';
 // Cloud URL resolution
 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';
 // Error handling
 export { handleLoadError } from './utils/error.js';

package/dist/query/engine.d.ts

@@ -35,15 +35,27 @@ export interface SchemaField {
     type: string;
     nullable: boolean;
 }
+/**
+ * Abstraction over a DuckDB query source. Decouples schema / CRS / count
+ * helpers from assuming a file-backed path. `ref` is the FROM-clause target
+ * inserted into generated SQL (e.g. `read_parquet('url')` for files, or
+ * `attached_db."schema"."table"` for attached databases). `filePath` is
+ * optional and only used as a shortcut for Parquet file-level metadata
+ * queries (`parquet_kv_metadata`, `parquet_file_metadata`), not for SQL.
+ */
+export interface QuerySource {
+    ref: string;
+    filePath?: string;
+}
 export interface QueryEngine {
     query(connId: string, sql: string): Promise<QueryResult>;
     queryForMap(connId: string, sql: string, geomCol: string, geomColType: string, sourceCrs?: string | null): Promise<MapQueryResult>;
-    getSchema(connId: string, path: string): Promise<SchemaField[]>;
-    getRowCount(connId: string, path: string): Promise<number>;
+    getSchema(connId: string, source: QuerySource): Promise<SchemaField[]>;
+    getRowCount(connId: string, source: QuerySource): Promise<number>;
     /** Detect CRS from GeoParquet metadata. Returns e.g. 'EPSG:27700' or null if WGS84/unknown. */
-    detectCrs(connId: string, path: string, geomCol: string): Promise<string | null>;
+    detectCrs(connId: string, source: QuerySource, geomCol: string): Promise<string | null>;
     /** Combined schema + CRS detection in a single connection (fewer web worker round-trips). */
-    getSchemaAndCrs?(connId: string, path: string, findGeoCol: (schema: SchemaField[]) => string | null): Promise<{
+    getSchemaAndCrs?(connId: string, source: QuerySource, findGeoCol: (schema: SchemaField[]) => string | null): Promise<{
         schema: SchemaField[];
         geomCol: string | null;
         crs: string | null;
@@ -51,6 +63,10 @@ export interface QueryEngine {
     queryCancellable?(connId: string, sql: string): QueryHandle;
     queryForMapCancellable?(connId: string, sql: string, geomCol: string, geomColType: string, sourceCrs?: string | null): MapQueryHandle;
     forceCancel?(): Promise<void>;
+    /** Register a file buffer in DuckDB-WASM's virtual filesystem for ATTACH. */
+    registerFileBuffer?(name: string, buffer: Uint8Array): Promise<void>;
+    /** Drop a previously registered file from DuckDB-WASM's virtual filesystem. */
+    dropFile?(name: string): Promise<void>;
     releaseMemory(): Promise<void>;
     dispose(): Promise<void>;
 }

package/dist/query/index.d.ts

@@ -1,4 +1,5 @@
 import type { QueryEngine } from './engine';
 export declare function getQueryEngine(): Promise<QueryEngine>;
-export type { MapQueryHandle, MapQueryResult, QueryEngine, QueryHandle, QueryResult, SchemaField } from './engine';
+export type { MapQueryHandle, MapQueryResult, QueryEngine, QueryHandle, QueryResult, QuerySource, SchemaField } from './engine';
 export { QueryCancelledError } from './engine';
+export { type ResolvedTableSource, resolveTableSource, resolveTableSourceAsync } from './source.js';

package/dist/query/index.js

@@ -17,3 +17,4 @@ export async function getQueryEngine() {
     return enginePromise;
 }
 export { QueryCancelledError } from './engine';
+export { resolveTableSource, resolveTableSourceAsync } from './source.js';

package/dist/query/source.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Resolve a Tab to a QuerySource — the abstraction every engine helper
+ * consumes. A tab is either file-backed (path → `read_parquet('url')`) or
+ * SQL-backed (`tab.sourceRef` is a pre-built FROM-clause target, such as an
+ * attached DuckLake table).
+ *
+ * This module is the only place that knows how to map a Tab to both a SQL
+ * FROM target AND a resolved file URL, so TableViewer and DatabaseViewer
+ * stay free of ad-hoc branching.
+ */
+import type { Tab } from '../types.js';
+import type { QuerySource } from './engine.js';
+/**
+ * True when a source ref points at a self-authenticating HTTPS URL (e.g. a
+ * presigned `read_parquet('https://...?X-Amz-Signature=...')`). Used to decide
+ * whether DuckDB needs S3 credential config — presigned URLs don't.
+ */
+export declare function isHttpsSourceRef(ref: string): boolean;
+export interface ResolvedTableSource extends QuerySource {
+    /**
+     * True when the tab is file-backed and hyparquet / parquet metadata
+     * shortcuts apply. False for SQL-backed sources like attached DuckLake
+     * tables.
+     */
+    isFileSource: boolean;
+    /** File URL used for hyparquet metadata fetches. Null for SQL-backed sources. */
+    fileUrl: string | null;
+    /** Display label, typically the tab name. */
+    label: string;
+}
+/**
+ * Resolve a tab to its QuerySource. Must be called lazily (inside reactive
+ * expressions or functions) because `tab.sourceRef` and `tab.path` can change
+ * over a tab's lifetime.
+ */
+export declare function resolveTableSource(tab: Tab): ResolvedTableSource;
+/**
+ * Async counterpart of `resolveTableSource`. Returns a presigned HTTPS URL
+ * for `signed-s3` connections so DuckDB httpfs can fetch without the
+ * `Authorization` header preflight.
+ */
+export declare function resolveTableSourceAsync(tab: Tab): Promise<ResolvedTableSource>;

package/dist/query/source.js

@@ -0,0 +1,54 @@
+/**
+ * Resolve a Tab to a QuerySource — the abstraction every engine helper
+ * consumes. A tab is either file-backed (path → `read_parquet('url')`) or
+ * SQL-backed (`tab.sourceRef` is a pre-built FROM-clause target, such as an
+ * attached DuckLake table).
+ *
+ * This module is the only place that knows how to map a Tab to both a SQL
+ * FROM target AND a resolved file URL, so TableViewer and DatabaseViewer
+ * stay free of ad-hoc branching.
+ */
+import { buildDuckDbSource } from '../file-icons/index.js';
+import { buildDuckDbUrl, buildDuckDbUrlAsync } from '../utils/url.js';
+/**
+ * True when a source ref points at a self-authenticating HTTPS URL (e.g. a
+ * presigned `read_parquet('https://...?X-Amz-Signature=...')`). Used to decide
+ * whether DuckDB needs S3 credential config — presigned URLs don't.
+ */
+export function isHttpsSourceRef(ref) {
+    return /(?:^|\(\s*['"])https:\/\//.test(ref);
+}
+function toResolved(tab, fileUrl) {
+    if (tab.sourceRef) {
+        return {
+            ref: tab.sourceRef,
+            filePath: undefined,
+            isFileSource: false,
+            fileUrl: null,
+            label: tab.name
+        };
+    }
+    return {
+        ref: buildDuckDbSource(tab.path, fileUrl ?? ''),
+        filePath: tab.path,
+        isFileSource: true,
+        fileUrl,
+        label: tab.name
+    };
+}
+/**
+ * Resolve a tab to its QuerySource. Must be called lazily (inside reactive
+ * expressions or functions) because `tab.sourceRef` and `tab.path` can change
+ * over a tab's lifetime.
+ */
+export function resolveTableSource(tab) {
+    return toResolved(tab, tab.sourceRef ? null : buildDuckDbUrl(tab));
+}
+/**
+ * Async counterpart of `resolveTableSource`. Returns a presigned HTTPS URL
+ * for `signed-s3` connections so DuckDB httpfs can fetch without the
+ * `Authorization` header preflight.
+ */
+export async function resolveTableSourceAsync(tab) {
+    return toResolved(tab, tab.sourceRef ? null : await buildDuckDbUrlAsync(tab));
+}

package/dist/query/wasm.d.ts

@@ -1,20 +1,22 @@
-import { type MapQueryHandle, type MapQueryResult, type QueryEngine, type QueryHandle, type QueryResult, type SchemaField } from './engine';
+import { type MapQueryHandle, type MapQueryResult, type QueryEngine, type QueryHandle, type QueryResult, type QuerySource, type SchemaField } from './engine';
 export declare class WasmQueryEngine implements QueryEngine {
     query(connId: string, sql: string): Promise<QueryResult>;
     queryForMap(connId: string, sql: string, geomCol: string, geomColType: string, sourceCrs?: string | null): Promise<MapQueryResult>;
-    getSchema(connId: string, path: string): Promise<SchemaField[]>;
-    getRowCount(connId: string, path: string): Promise<number>;
-    getSchemaAndCrs(connId: string, path: string, findGeoCol: (schema: SchemaField[]) => string | null): Promise<{
+    getSchema(connId: string, source: QuerySource): Promise<SchemaField[]>;
+    getRowCount(connId: string, source: QuerySource): Promise<number>;
+    getSchemaAndCrs(connId: string, source: QuerySource, findGeoCol: (schema: SchemaField[]) => string | null): Promise<{
         schema: SchemaField[];
         geomCol: string | null;
         crs: string | null;
     }>;
     private configureStorage;
-    detectCrs(connId: string, path: string, geomCol: string): Promise<string | null>;
+    detectCrs(connId: string, source: QuerySource, geomCol: string): Promise<string | null>;
     private detectCrsWithConn;
     queryCancellable(connId: string, sql: string): QueryHandle;
     queryForMapCancellable(connId: string, sql: string, geomCol: string, geomColType: string, sourceCrs?: string | null): MapQueryHandle;
     forceCancel(): Promise<void>;
+    registerFileBuffer(name: string, buffer: Uint8Array): Promise<void>;
+    dropFile(name: string): Promise<void>;
     releaseMemory(): Promise<void>;
     dispose(): Promise<void>;
 }