@walkthru-earth/objex 0.1.0

package/dist/storage/index.js

@@ -0,0 +1,37 @@
+import { connectionStore } from '../stores/connections.svelte.js';
+import { BrowserAzureAdapter } from './browser-azure.js';
+import { BrowserCloudAdapter } from './browser-cloud.js';
+import { UrlAdapter } from './url-adapter.js';
+const adapterCache = new Map();
+// Singleton UrlAdapter — stateless, no connection needed
+const urlAdapter = new UrlAdapter();
+/**
+ * Returns the appropriate storage adapter for the given source.
+ * Caches adapter instances per connectionId.
+ */
+export function getAdapter(source, connectionId) {
+    if (source === 'url') {
+        return urlAdapter;
+    }
+    if (!connectionId) {
+        throw new Error('A connectionId is required for remote storage adapters.');
+    }
+    let adapter = adapterCache.get(connectionId);
+    if (adapter)
+        return adapter;
+    const conn = connectionStore.getById(connectionId);
+    if (conn?.provider === 'azure') {
+        adapter = new BrowserAzureAdapter(connectionId);
+    }
+    else {
+        adapter = new BrowserCloudAdapter(connectionId);
+    }
+    adapterCache.set(connectionId, adapter);
+    return adapter;
+}
+/**
+ * Clear cached adapter for a connection (call on connection update/delete).
+ */
+export function clearAdapterCache(connectionId) {
+    adapterCache.delete(connectionId);
+}

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

@@ -0,0 +1,19 @@
+import type { FileEntry, WriteResult } from '../types.js';
+import type { StorageAdapter } from './adapter.js';
+/**
+ * Minimal adapter for direct HTTPS URLs (source: 'url').
+ * Only supports read/head — no listing or writing.
+ * The `path` parameter is the full HTTPS URL.
+ */
+export declare class UrlAdapter implements StorageAdapter {
+    readonly supportsWrite = false;
+    read(url: string, offset?: number, length?: number, signal?: AbortSignal): Promise<Uint8Array>;
+    head(url: string, signal?: AbortSignal): Promise<FileEntry>;
+    list(): Promise<FileEntry[]>;
+    put(): Promise<WriteResult>;
+    delete(): Promise<void>;
+    deletePrefix(): Promise<{
+        deleted: number;
+    }>;
+    copy(): Promise<WriteResult>;
+}

package/dist/storage/url-adapter.js

@@ -0,0 +1,51 @@
+/**
+ * Minimal adapter for direct HTTPS URLs (source: 'url').
+ * Only supports read/head — no listing or writing.
+ * The `path` parameter is the full HTTPS URL.
+ */
+export class UrlAdapter {
+    supportsWrite = false;
+    async read(url, offset, length, signal) {
+        const headers = {};
+        if (offset !== undefined && length !== undefined) {
+            headers.Range = `bytes=${offset}-${offset + length - 1}`;
+        }
+        else if (offset !== undefined) {
+            headers.Range = `bytes=${offset}-`;
+        }
+        const res = await fetch(url, { headers, signal });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+        return new Uint8Array(await res.arrayBuffer());
+    }
+    async head(url, signal) {
+        const res = await fetch(url, { method: 'HEAD', signal });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+        const name = url.split('/').pop()?.split('?')[0] || 'file';
+        const ext = name.includes('.') ? name.split('.').pop().toLowerCase() : '';
+        return {
+            name,
+            path: url,
+            is_dir: false,
+            size: Number(res.headers.get('content-length') || 0),
+            modified: new Date(res.headers.get('last-modified') || 0).getTime(),
+            extension: ext
+        };
+    }
+    async list() {
+        return [];
+    }
+    async put() {
+        throw new Error('Write not supported for direct URL sources');
+    }
+    async delete() {
+        throw new Error('Delete not supported for direct URL sources');
+    }
+    async deletePrefix() {
+        throw new Error('Delete not supported for direct URL sources');
+    }
+    async copy() {
+        throw new Error('Copy not supported for direct URL sources');
+    }
+}

package/dist/stores/CLAUDE.md

@@ -0,0 +1,29 @@
+# stores/
+
+Svelte 5 rune-based stores. All use `$state` / `$state.raw` / `$derived`.
+
+```mermaid
+graph LR
+    CONN[connections.svelte.ts] --> CRED[credentials.svelte.ts]
+    TABS[tabs.svelte.ts] --> TR[tab-resources.svelte.ts]
+    FILES[files.svelte.ts] --> CONN
+    BR[browser.svelte.ts] --> FILES
+    SET[settings.svelte.ts]
+    QH[query-history.svelte.ts]
+    SL[safelock.svelte.ts]
+```
+
+| File | Export | Used by |
+|------|--------|--------|
+| `connections.svelte.ts` | `connectionStore` | url.ts, browser-azure, browser-cloud, storage/index, ConnectionDialog, Sidebar, TableToolbar, +page.svelte |
+| `credentials.svelte.ts` | `credentialStore` | url.ts, browser-azure, browser-cloud, Sidebar, query/wasm |
+| `tabs.svelte.ts` | `tabStore` | StatusBar, TabBar, Sidebar, FileRow, FileTreeSidebar, +page.svelte |
+| `tab-resources.svelte.ts` | `tabResources` | CogViewer, TableViewer, FlatGeobufViewer, ArchiveViewer, ModelViewer, GeoParquetMapViewer, DatabaseViewer, MediaViewer, PdfViewer, RawViewer, MarkdownViewer, ZarrMapViewer, NotebookViewer, MapViewer, CodeViewer, ImageViewer, PmtilesViewer |
+| `files.svelte.ts` | `fileStore` | StatusBar |
+| `browser.svelte.ts` | `browser` | StatusBar, Sidebar, FileBrowser, DropZone, UploadButton, FileRow, DeleteConfirmDialog, FileTreeSidebar, RenameDialog, CreateFolderDialog, +page.svelte |
+| `settings.svelte.ts` | `settings` | LocaleToggle, ThemeToggle, scroll-area, TableViewer, FlatGeobufViewer, GeoParquetMapViewer, MapContainer, CodeMirrorEditor, +layout.svelte |
+| `query-history.svelte.ts` | `queryHistory` | TableViewer, QueryHistoryPanel, SqlEditor |
+| `safelock.svelte.ts` | `safeLock` | SafeLockToggle, FileBrowser, DropZone, FileRow |
+
+All stores are module-level singletons (SPA, no SSR).
+Use `$state.raw` for arrays >100 items. Credentials never touch localStorage.

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

@@ -0,0 +1,28 @@
+import type { Connection, FileEntry } from '../types.js';
+export declare const browser: {
+    readonly activeConnection: Connection | null;
+    readonly currentPrefix: string;
+    readonly entries: FileEntry[];
+    readonly loading: boolean;
+    readonly error: string | null;
+    readonly uploading: boolean;
+    readonly uploadProgress: {
+        current: number;
+        total: number;
+    };
+    readonly canWrite: boolean;
+    browse: (connection: Connection, prefix?: string) => Promise<void>;
+    navigateTo: (prefix: string) => Promise<void>;
+    navigateUp: () => Promise<void>;
+    clear: () => void;
+    refresh: () => Promise<void>;
+    uploadFile: (fileName: string, data: Uint8Array, contentType?: string) => Promise<void>;
+    uploadFiles: (files: Array<{
+        name: string;
+        data: Uint8Array;
+        type?: string;
+    }>) => Promise<void>;
+    deleteEntry: (entry: FileEntry) => Promise<void>;
+    renameEntry: (entry: FileEntry, newName: string) => Promise<void>;
+    createFolder: (name: string) => Promise<void>;
+};

package/dist/stores/browser.svelte.js

@@ -0,0 +1,160 @@
+import { getAdapter } from '../storage/index.js';
+import { credentialStore } from './credentials.svelte.js';
+import { safeLock } from './safelock.svelte.js';
+function createBrowserStore() {
+    let activeConnection = $state(null);
+    let currentPrefix = $state('');
+    let entries = $state([]);
+    let loading = $state(false);
+    let error = $state(null);
+    let uploading = $state(false);
+    let uploadProgress = $state({ current: 0, total: 0 });
+    async function browse(connection, prefix) {
+        activeConnection = connection;
+        const startPrefix = prefix ?? connection.rootPrefix ?? '';
+        currentPrefix = startPrefix;
+        loading = true;
+        error = null;
+        entries = [];
+        try {
+            const adapter = getAdapter('remote', connection.id);
+            const result = await adapter.list(startPrefix);
+            entries = result;
+        }
+        catch (e) {
+            error = e instanceof Error ? e.message : String(e);
+        }
+        finally {
+            loading = false;
+        }
+    }
+    async function navigateTo(prefix) {
+        if (!activeConnection)
+            return;
+        await browse(activeConnection, prefix);
+    }
+    async function navigateUp() {
+        if (!activeConnection || !currentPrefix)
+            return;
+        const parts = currentPrefix.replace(/\/+$/, '').split('/');
+        parts.pop();
+        const parent = parts.length > 0 ? `${parts.join('/')}/` : '';
+        await browse(activeConnection, parent);
+    }
+    function clear() {
+        activeConnection = null;
+        currentPrefix = '';
+        entries = [];
+        loading = false;
+        error = null;
+    }
+    async function refresh() {
+        if (!activeConnection)
+            return;
+        await browse(activeConnection, currentPrefix);
+    }
+    function assertWritable() {
+        if (safeLock.locked)
+            throw new Error('Safe lock is enabled. Unlock to perform write operations.');
+        if (!activeConnection)
+            throw new Error('No active connection.');
+    }
+    async function uploadFile(fileName, data, contentType) {
+        assertWritable();
+        const adapter = getAdapter('remote', activeConnection.id);
+        const key = currentPrefix + fileName;
+        await adapter.put(key, data, contentType);
+    }
+    async function uploadFiles(files) {
+        assertWritable();
+        uploading = true;
+        uploadProgress = { current: 0, total: files.length };
+        try {
+            for (const file of files) {
+                await uploadFile(file.name, file.data, file.type);
+                uploadProgress = { current: uploadProgress.current + 1, total: files.length };
+            }
+            await refresh();
+        }
+        finally {
+            uploading = false;
+            uploadProgress = { current: 0, total: 0 };
+        }
+    }
+    async function deleteEntry(entry) {
+        assertWritable();
+        const adapter = getAdapter('remote', activeConnection.id);
+        if (entry.is_dir) {
+            await adapter.deletePrefix(entry.path);
+        }
+        else {
+            await adapter.delete(entry.path);
+        }
+        await refresh();
+    }
+    async function renameEntry(entry, newName) {
+        assertWritable();
+        if (newName === entry.name)
+            throw new Error('New name is the same as the current name.');
+        const adapter = getAdapter('remote', activeConnection.id);
+        // Build the new key by replacing the last segment
+        const parentPrefix = entry.path.replace(/[^/]*\/?$/, '');
+        const newKey = entry.is_dir ? `${parentPrefix + newName}/` : parentPrefix + newName;
+        await adapter.copy(entry.path, newKey);
+        if (entry.is_dir) {
+            await adapter.deletePrefix(entry.path);
+        }
+        else {
+            await adapter.delete(entry.path);
+        }
+        await refresh();
+    }
+    async function createFolder(name) {
+        assertWritable();
+        const adapter = getAdapter('remote', activeConnection.id);
+        const key = `${currentPrefix + name}/`;
+        await adapter.put(key, new Uint8Array(0));
+        await refresh();
+    }
+    return {
+        get activeConnection() {
+            return activeConnection;
+        },
+        get currentPrefix() {
+            return currentPrefix;
+        },
+        get entries() {
+            return entries;
+        },
+        get loading() {
+            return loading;
+        },
+        get error() {
+            return error;
+        },
+        get uploading() {
+            return uploading;
+        },
+        get uploadProgress() {
+            return uploadProgress;
+        },
+        get canWrite() {
+            if (!activeConnection)
+                return false;
+            if (activeConnection.anonymous)
+                return false;
+            return credentialStore.has(activeConnection.id);
+        },
+        browse,
+        navigateTo,
+        navigateUp,
+        clear,
+        refresh,
+        uploadFile,
+        uploadFiles,
+        deleteEntry,
+        renameEntry,
+        createFolder
+    };
+}
+export const browser = createBrowserStore();

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

@@ -0,0 +1,56 @@
+import type { Connection, ConnectionConfig } from '../types.js';
+import type { DetectedHost } from '../utils/host-detection.js';
+export declare const connectionStore: {
+    readonly items: Connection[];
+    readonly loaded: boolean;
+    /**
+     * Load connections from localStorage.
+     * 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.
+     */
+    save(config: ConnectionConfig): Promise<string | null>;
+    /**
+     * Update an existing connection.
+     */
+    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.
+     */
+    findByBucketEndpoint(bucket: string, endpoint: string): Connection | undefined;
+    /**
+     * Create a connection from a DetectedHost, deduplicating by bucket+endpoint.
+     * Returns the connection ID (existing or newly created).
+     */
+    saveHostConnection(detected: DetectedHost): Promise<string>;
+};
+export { connectionStore as connections };

package/dist/stores/connections.svelte.js

@@ -0,0 +1,272 @@
+import { credentialStore, storeToNative } from './credentials.svelte.js';
+const CONNECTIONS_KEY = 'obstore-explore-connections';
+// ---------------------------------------------------------------------------
+// localStorage helpers
+// ---------------------------------------------------------------------------
+function loadFromLocalStorage() {
+    if (typeof window === 'undefined')
+        return [];
+    try {
+        const raw = localStorage.getItem(CONNECTIONS_KEY);
+        if (raw) {
+            return JSON.parse(raw);
+        }
+    }
+    catch {
+        // ignore parse errors
+    }
+    return [];
+}
+function persistToLocalStorage(connections) {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        localStorage.setItem(CONNECTIONS_KEY, JSON.stringify(connections));
+    }
+    catch {
+        // ignore storage errors
+    }
+}
+// ---------------------------------------------------------------------------
+// Store
+// ---------------------------------------------------------------------------
+function createConnectionsStore() {
+    let connections = $state([]);
+    let loaded = $state(false);
+    let dialogRequest = $state(0);
+    return {
+        get items() {
+            return connections;
+        },
+        get loaded() {
+            return loaded;
+        },
+        /**
+         * Load connections from localStorage.
+         * Safe to call multiple times — subsequent calls are no-ops.
+         */
+        async load() {
+            if (loaded)
+                return;
+            connections = loadFromLocalStorage();
+            loaded = true;
+        },
+        /**
+         * Force-reload connections.
+         */
+        async reload() {
+            loaded = false;
+            await this.load();
+        },
+        /**
+         * Save a new connection to localStorage.
+         */
+        async save(config) {
+            const id = crypto.randomUUID();
+            const conn = {
+                id,
+                name: config.name,
+                provider: config.provider,
+                endpoint: config.endpoint,
+                bucket: config.bucket,
+                region: config.region,
+                anonymous: config.anonymous,
+                authMethod: config.authMethod,
+                rootPrefix: config.rootPrefix
+            };
+            connections = [...connections, conn];
+            persistToLocalStorage(connections);
+            // Store credentials in memory (never persisted to localStorage).
+            if (!config.anonymous) {
+                if (config.sas_token) {
+                    const creds = { type: 'sas-token', sasToken: config.sas_token };
+                    credentialStore.set(id, creds);
+                    storeToNative(id, creds).catch(() => { });
+                }
+                else if (config.access_key && config.secret_key) {
+                    const creds = {
+                        type: 'sigv4',
+                        accessKey: config.access_key,
+                        secretKey: config.secret_key
+                    };
+                    credentialStore.set(id, creds);
+                    storeToNative(id, creds).catch(() => { });
+                }
+            }
+            return id;
+        },
+        /**
+         * Update an existing connection.
+         */
+        async update(id, config) {
+            const idx = connections.findIndex((c) => c.id === id);
+            if (idx === -1)
+                return false;
+            connections[idx] = {
+                ...connections[idx],
+                name: config.name,
+                provider: config.provider,
+                endpoint: config.endpoint,
+                bucket: config.bucket,
+                region: config.region,
+                anonymous: config.anonymous,
+                authMethod: config.authMethod,
+                rootPrefix: config.rootPrefix
+            };
+            connections = [...connections];
+            persistToLocalStorage(connections);
+            // Invalidate cached adapter for this connection
+            import('../storage/index.js').then(({ clearAdapterCache }) => clearAdapterCache(id));
+            // Update in-memory credentials.
+            if (!config.anonymous) {
+                if (config.sas_token) {
+                    const creds = { type: 'sas-token', sasToken: config.sas_token };
+                    credentialStore.set(id, creds);
+                    storeToNative(id, creds).catch(() => { });
+                }
+                else if (config.access_key && config.secret_key) {
+                    const creds = {
+                        type: 'sigv4',
+                        accessKey: config.access_key,
+                        secretKey: config.secret_key
+                    };
+                    credentialStore.set(id, creds);
+                    storeToNative(id, creds).catch(() => { });
+                }
+                else {
+                    credentialStore.remove(id);
+                }
+            }
+            else {
+                credentialStore.remove(id);
+            }
+            return true;
+        },
+        /**
+         * Remove a connection by ID.
+         */
+        async remove(id) {
+            const before = connections.length;
+            connections = connections.filter((c) => c.id !== id);
+            persistToLocalStorage(connections);
+            credentialStore.remove(id);
+            // Invalidate cached adapter for this connection
+            import('../storage/index.js').then(({ clearAdapterCache }) => clearAdapterCache(id));
+            return connections.length < before;
+        },
+        /**
+         * Test whether a connection is reachable via a lightweight list.
+         */
+        async test(id) {
+            const { getAdapter } = await import(/* @vite-ignore */ '$lib/storage/index.js');
+            const adapter = getAdapter('remote', id);
+            await adapter.list('');
+            return true;
+        },
+        /**
+         * Test a connection using provided config values (works for both new
+         * and existing connections without saving first).
+         */
+        async testWithConfig(config, existingId) {
+            const tempId = existingId ?? `temp-test-${Date.now()}`;
+            const tempConn = {
+                id: tempId,
+                name: config.name,
+                provider: config.provider,
+                endpoint: config.endpoint,
+                bucket: config.bucket,
+                region: config.region,
+                anonymous: config.anonymous,
+                authMethod: config.authMethod,
+                rootPrefix: config.rootPrefix
+            };
+            // Temporarily register connection + credentials so the adapter can find them
+            const hadConn = connections.some((c) => c.id === tempId);
+            const prevCreds = credentialStore.get(tempId);
+            if (!hadConn) {
+                connections = [...connections, tempConn];
+                // Don't persist — this is a temp test connection
+            }
+            if (!config.anonymous) {
+                if (config.sas_token) {
+                    credentialStore.set(tempId, { type: 'sas-token', sasToken: config.sas_token });
+                }
+                else if (config.access_key && config.secret_key) {
+                    credentialStore.set(tempId, {
+                        type: 'sigv4',
+                        accessKey: config.access_key,
+                        secretKey: config.secret_key
+                    });
+                }
+            }
+            try {
+                const { getAdapter } = await import(/* @vite-ignore */ '$lib/storage/index.js');
+                const adapter = getAdapter('remote', tempId);
+                await adapter.list(config.rootPrefix || '');
+                return true;
+            }
+            finally {
+                // Cleanup: remove temp connection if we added it
+                if (!hadConn) {
+                    connections = connections.filter((c) => c.id !== tempId);
+                    // Don't persist — was never in localStorage
+                }
+                // Restore previous credentials or remove temp ones
+                if (prevCreds) {
+                    credentialStore.set(tempId, prevCreds);
+                }
+                else if (!hadConn) {
+                    credentialStore.remove(tempId);
+                }
+                // Also clear any cached adapter for the temp connection
+                import('../storage/index.js').then(({ clearAdapterCache }) => clearAdapterCache(tempId));
+            }
+        },
+        /** True when a dialog open has been requested and not yet consumed. */
+        get dialogRequested() {
+            return dialogRequest > 0;
+        },
+        /** Request opening the new-connection dialog from anywhere. */
+        requestDialog() {
+            dialogRequest++;
+        },
+        /** Mark the dialog request as consumed. */
+        clearDialogRequest() {
+            dialogRequest = 0;
+        },
+        /**
+         * Synchronous lookup by ID (from the already-loaded list).
+         */
+        getById(id) {
+            return connections.find((c) => c.id === id);
+        },
+        /**
+         * Find an existing connection that matches bucket + endpoint.
+         */
+        findByBucketEndpoint(bucket, endpoint) {
+            return connections.find((c) => c.bucket === bucket && c.endpoint === endpoint);
+        },
+        /**
+         * Create a connection from a DetectedHost, deduplicating by bucket+endpoint.
+         * Returns the connection ID (existing or newly created).
+         */
+        async saveHostConnection(detected) {
+            const existing = this.findByBucketEndpoint(detected.bucket, detected.endpoint);
+            if (existing)
+                return existing.id;
+            const name = detected.bucket === '$web' ? `Azure Static Web` : detected.bucket;
+            const id = await this.save({
+                name,
+                provider: detected.provider === 'unknown' ? 's3' : detected.provider,
+                endpoint: detected.endpoint,
+                bucket: detected.bucket,
+                region: detected.region,
+                anonymous: true,
+                rootPrefix: detected.rootPrefix || undefined
+            });
+            return id;
+        }
+    };
+}
+export const connectionStore = createConnectionsStore();
+export { connectionStore as connections };