@walkthru-earth/objex 0.1.0

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

@@ -0,0 +1,56 @@
+/**
+ * In-memory credential store.
+ *
+ * Credentials are held only in memory — they are never persisted to
+ * localStorage or any other durable storage — so a page refresh clears them.
+ *
+ * The Credential Management API helpers (`storeToNative` / `loadFromNative`)
+ * allow the browser's built-in password manager to save and restore
+ * credentials across page refreshes (Chrome/Edge; silent no-op elsewhere).
+ */
+export interface SigV4Credentials {
+    type: 'sigv4';
+    accessKey: string;
+    secretKey: string;
+}
+export interface AzureCredentials {
+    type: 'sas-token';
+    sasToken: string;
+}
+export type Credentials = SigV4Credentials | AzureCredentials;
+export declare const credentialStore: {
+    /** Store credentials for a connection. */
+    set(connectionId: string, creds: Credentials): void;
+    /** Retrieve credentials for a connection (or undefined). */
+    get(connectionId: string): Credentials | undefined;
+    /** Remove credentials for a connection. */
+    remove(connectionId: string): void;
+    /** Check whether credentials exist for a connection. */
+    has(connectionId: string): boolean;
+    /** Remove all stored credentials. */
+    clear(): void;
+};
+declare global {
+    interface PasswordCredentialData {
+        id: string;
+        name?: string;
+        password: string;
+    }
+    interface PasswordCredential extends Credential {
+        readonly password: string;
+    }
+    var PasswordCredential: {
+        prototype: PasswordCredential;
+        new (data: PasswordCredentialData): PasswordCredential;
+    } | undefined;
+}
+/**
+ * Persist credentials to the browser's native password manager.
+ * Uses PasswordCredential (Chrome/Edge). Silently no-ops on unsupported browsers.
+ */
+export declare function storeToNative(connectionId: string, creds: Credentials): Promise<void>;
+/**
+ * Attempt to load credentials from the browser's native password manager.
+ * Returns the deserialized Credentials, or undefined if unavailable.
+ */
+export declare function loadFromNative(connectionId: string): Promise<Credentials | undefined>;

package/dist/stores/credentials.svelte.js

@@ -0,0 +1,79 @@
+/**
+ * In-memory credential store.
+ *
+ * Credentials are held only in memory — they are never persisted to
+ * localStorage or any other durable storage — so a page refresh clears them.
+ *
+ * The Credential Management API helpers (`storeToNative` / `loadFromNative`)
+ * allow the browser's built-in password manager to save and restore
+ * credentials across page refreshes (Chrome/Edge; silent no-op elsewhere).
+ */
+const store = new Map();
+export const credentialStore = {
+    /** Store credentials for a connection. */
+    set(connectionId, creds) {
+        store.set(connectionId, creds);
+    },
+    /** Retrieve credentials for a connection (or undefined). */
+    get(connectionId) {
+        return store.get(connectionId);
+    },
+    /** Remove credentials for a connection. */
+    remove(connectionId) {
+        store.delete(connectionId);
+    },
+    /** Check whether credentials exist for a connection. */
+    has(connectionId) {
+        return store.has(connectionId);
+    },
+    /** Remove all stored credentials. */
+    clear() {
+        store.clear();
+    }
+};
+/**
+ * Persist credentials to the browser's native password manager.
+ * Uses PasswordCredential (Chrome/Edge). Silently no-ops on unsupported browsers.
+ */
+export async function storeToNative(connectionId, creds) {
+    try {
+        if (typeof PasswordCredential === 'undefined' || !navigator.credentials?.store)
+            return;
+        const password = JSON.stringify(creds);
+        const pc = new PasswordCredential({
+            id: connectionId,
+            password,
+            name: `obstore:${connectionId}`
+        });
+        await navigator.credentials.store(pc);
+    }
+    catch {
+        // Silent fallback — Credential Management API is best-effort
+    }
+}
+/**
+ * Attempt to load credentials from the browser's native password manager.
+ * Returns the deserialized Credentials, or undefined if unavailable.
+ */
+export async function loadFromNative(connectionId) {
+    try {
+        if (typeof PasswordCredential === 'undefined' || !navigator.credentials?.get)
+            return undefined;
+        const credential = await navigator.credentials.get({
+            password: true,
+            mediation: 'silent'
+        });
+        if (!credential || credential.type !== 'password')
+            return undefined;
+        const pc = credential;
+        if (pc.id !== connectionId || !pc.password)
+            return undefined;
+        const parsed = JSON.parse(pc.password);
+        if (parsed.type === 'sigv4' || parsed.type === 'sas-token')
+            return parsed;
+    }
+    catch {
+        // Silent fallback
+    }
+    return undefined;
+}

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

@@ -0,0 +1,20 @@
+import type { FileEntry } from '../types.js';
+export type SortField = 'name' | 'size' | 'modified' | 'extension';
+export type SortDirection = 'asc' | 'desc';
+export interface SortConfig {
+    field: SortField;
+    direction: SortDirection;
+}
+export declare const fileStore: {
+    readonly entries: FileEntry[];
+    readonly currentPath: string;
+    readonly loading: boolean;
+    readonly error: string | null;
+    readonly sortConfig: SortConfig;
+    setFiles(entries: FileEntry[]): void;
+    setPath(path: string): void;
+    setLoading(state: boolean): void;
+    setError(message: string | null): void;
+    sort(field: SortField): void;
+};
+export { fileStore as files };

package/dist/stores/files.svelte.js

@@ -0,0 +1,76 @@
+function sortEntries(entries, config) {
+    const sorted = [...entries];
+    const dir = config.direction === 'asc' ? 1 : -1;
+    sorted.sort((a, b) => {
+        // Directories always come first
+        if (a.is_dir && !b.is_dir)
+            return -1;
+        if (!a.is_dir && b.is_dir)
+            return 1;
+        switch (config.field) {
+            case 'name':
+                return dir * a.name.localeCompare(b.name, undefined, { sensitivity: 'base' });
+            case 'size':
+                return dir * (a.size - b.size);
+            case 'modified':
+                return dir * (a.modified - b.modified);
+            case 'extension':
+                return dir * a.extension.localeCompare(b.extension, undefined, { sensitivity: 'base' });
+            default:
+                return 0;
+        }
+    });
+    return sorted;
+}
+function createFilesStore() {
+    let files = $state([]);
+    let currentPath = $state('');
+    let loading = $state(false);
+    let error = $state(null);
+    let sortConfig = $state({ field: 'name', direction: 'asc' });
+    return {
+        get entries() {
+            return files;
+        },
+        get currentPath() {
+            return currentPath;
+        },
+        get loading() {
+            return loading;
+        },
+        get error() {
+            return error;
+        },
+        get sortConfig() {
+            return sortConfig;
+        },
+        setFiles(entries) {
+            files = sortEntries(entries, sortConfig);
+            error = null;
+        },
+        setPath(path) {
+            currentPath = path;
+        },
+        setLoading(state) {
+            loading = state;
+        },
+        setError(message) {
+            error = message;
+        },
+        sort(field) {
+            if (sortConfig.field === field) {
+                // Toggle direction if clicking the same field
+                sortConfig = {
+                    field,
+                    direction: sortConfig.direction === 'asc' ? 'desc' : 'asc'
+                };
+            }
+            else {
+                sortConfig = { field, direction: 'asc' };
+            }
+            files = sortEntries(files, sortConfig);
+        }
+    };
+}
+export const fileStore = createFilesStore();
+export { fileStore as files };

package/dist/stores/query-history.svelte.d.ts

@@ -0,0 +1,16 @@
+export interface QueryHistoryEntry {
+    id: string;
+    sql: string;
+    timestamp: number;
+    durationMs: number;
+    rowCount: number;
+    error?: string;
+    connectionId?: string;
+}
+export declare const queryHistory: {
+    readonly entries: QueryHistoryEntry[];
+    add(entry: Omit<QueryHistoryEntry, "id">): void;
+    remove(id: string): void;
+    clear(): void;
+    search(query: string): QueryHistoryEntry[];
+};

package/dist/stores/query-history.svelte.js

@@ -0,0 +1,57 @@
+const STORAGE_KEY = 'obstore-explore-query-history';
+const MAX_ENTRIES = 200;
+function loadEntries() {
+    if (typeof window === 'undefined')
+        return [];
+    try {
+        const raw = localStorage.getItem(STORAGE_KEY);
+        if (raw)
+            return JSON.parse(raw);
+    }
+    catch {
+        // ignore parse errors
+    }
+    return [];
+}
+function persistEntries(entries) {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        localStorage.setItem(STORAGE_KEY, JSON.stringify(entries));
+    }
+    catch {
+        // ignore storage errors
+    }
+}
+function createQueryHistoryStore() {
+    let entries = $state(loadEntries());
+    function save() {
+        persistEntries(entries);
+    }
+    return {
+        get entries() {
+            return entries;
+        },
+        add(entry) {
+            const newEntry = {
+                ...entry,
+                id: crypto.randomUUID()
+            };
+            entries = [newEntry, ...entries].slice(0, MAX_ENTRIES);
+            save();
+        },
+        remove(id) {
+            entries = entries.filter((e) => e.id !== id);
+            save();
+        },
+        clear() {
+            entries = [];
+            save();
+        },
+        search(query) {
+            const q = query.toLowerCase();
+            return entries.filter((e) => e.sql.toLowerCase().includes(q));
+        }
+    };
+}
+export const queryHistory = createQueryHistoryStore();

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

@@ -0,0 +1,8 @@
+export declare const safeLock: {
+    readonly locked: boolean;
+    readonly initialized: boolean;
+    init: () => Promise<void>;
+    lock: () => void;
+    unlock: () => void;
+    toggle: () => void;
+};

package/dist/stores/safelock.svelte.js

@@ -0,0 +1,52 @@
+const SAFELOCK_KEY = 'obstore-explore-safelock';
+function createSafeLockStore() {
+    let locked = $state(true);
+    let initialized = $state(false);
+    async function init() {
+        if (initialized)
+            return;
+        try {
+            const raw = localStorage.getItem(SAFELOCK_KEY);
+            if (raw !== null) {
+                locked = JSON.parse(raw);
+            }
+        }
+        catch {
+            // ignore
+        }
+        initialized = true;
+    }
+    function persist() {
+        try {
+            localStorage.setItem(SAFELOCK_KEY, JSON.stringify(locked));
+        }
+        catch {
+            // ignore
+        }
+    }
+    function lock() {
+        locked = true;
+        persist();
+    }
+    function unlock() {
+        locked = false;
+        persist();
+    }
+    function toggle() {
+        locked = !locked;
+        persist();
+    }
+    return {
+        get locked() {
+            return locked;
+        },
+        get initialized() {
+            return initialized;
+        },
+        init,
+        lock,
+        unlock,
+        toggle
+    };
+}
+export const safeLock = createSafeLockStore();

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

@@ -0,0 +1,11 @@
+import { type Locale } from '../i18n/index.svelte.js';
+import type { Theme } from '../types.js';
+export declare const settings: {
+    readonly theme: Theme;
+    readonly resolved: "light" | "dark";
+    readonly locale: Locale;
+    readonly featureLimit: number;
+    setTheme(t: Theme): void;
+    setLocale(l: Locale): void;
+    setFeatureLimit(n: number): void;
+};

package/dist/stores/settings.svelte.js

@@ -0,0 +1,101 @@
+import { setLocale } from '../i18n/index.svelte.js';
+const SETTINGS_KEY = 'obstore-explore-settings';
+function loadSettings() {
+    if (typeof window === 'undefined') {
+        return { theme: 'system', locale: 'en', featureLimit: 1000 };
+    }
+    try {
+        const raw = localStorage.getItem(SETTINGS_KEY);
+        if (raw) {
+            const parsed = JSON.parse(raw);
+            return {
+                theme: parsed.theme ?? 'system',
+                locale: parsed.locale ?? 'en',
+                featureLimit: parsed.featureLimit ?? 100
+            };
+        }
+    }
+    catch {
+        // ignore parse errors
+    }
+    return { theme: 'system', locale: 'en', featureLimit: 1000 };
+}
+function persistSettings(settings) {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        localStorage.setItem(SETTINGS_KEY, JSON.stringify(settings));
+    }
+    catch {
+        // ignore storage errors
+    }
+}
+function resolveTheme(theme) {
+    if (theme !== 'system')
+        return theme;
+    if (typeof window === 'undefined')
+        return 'light';
+    return window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
+}
+function createSettingsStore() {
+    const initial = loadSettings();
+    let theme = $state(initial.theme);
+    let locale = $state(initial.locale);
+    let featureLimit = $state(initial.featureLimit);
+    let resolved = $state(resolveTheme(initial.theme));
+    // Sync i18n module and document dir with persisted locale
+    setLocale(initial.locale);
+    if (typeof document !== 'undefined') {
+        const dir = initial.locale === 'ar' ? 'rtl' : 'ltr';
+        document.documentElement.dir = dir;
+        document.documentElement.lang = initial.locale;
+    }
+    function persist() {
+        persistSettings({ theme, locale, featureLimit });
+    }
+    function applyTheme(t) {
+        theme = t;
+        resolved = resolveTheme(t);
+        persist();
+        if (typeof document !== 'undefined') {
+            document.documentElement.classList.toggle('dark', resolved === 'dark');
+        }
+    }
+    function applyLocale(l) {
+        locale = l;
+        setLocale(l);
+        persist();
+        if (typeof document !== 'undefined') {
+            const dir = l === 'ar' ? 'rtl' : 'ltr';
+            document.documentElement.dir = dir;
+            document.documentElement.lang = l;
+        }
+    }
+    // System theme changes are handled by the $effect in +layout.svelte
+    // which properly cleans up the listener. No module-level listener needed.
+    return {
+        get theme() {
+            return theme;
+        },
+        get resolved() {
+            return resolved;
+        },
+        get locale() {
+            return locale;
+        },
+        get featureLimit() {
+            return featureLimit;
+        },
+        setTheme(t) {
+            applyTheme(t);
+        },
+        setLocale(l) {
+            applyLocale(l);
+        },
+        setFeatureLimit(n) {
+            featureLimit = n;
+            persist();
+        }
+    };
+}
+export const settings = createSettingsStore();

package/dist/stores/tab-resources.svelte.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Tab resource registry — deterministic cleanup for viewer resources.
+ *
+ * Viewers register cleanup callbacks (abort controllers, map instances,
+ * cached data) when they mount.  The tab store calls `dispose(tabId)`
+ * on close so resources are freed immediately instead of relying on
+ * garbage collection.
+ */
+type CleanupFn = () => void | Promise<void>;
+export declare const tabResources: {
+    /**
+     * Register a cleanup callback for a tab.
+     * Returns an unregister function (useful in $effect cleanup).
+     */
+    register(tabId: string, cleanup: CleanupFn): () => void;
+    /** Dispose all resources for a single tab. */
+    dispose(tabId: string): Promise<void>;
+    /** Dispose all resources except for the given tab. */
+    disposeAllExcept(keepTabId: string): Promise<void>;
+    /** Dispose every registered tab. */
+    disposeAll(): Promise<void>;
+    /** Check if a tab has any registered resources. */
+    has(tabId: string): boolean;
+};
+export {};

package/dist/stores/tab-resources.svelte.js

@@ -0,0 +1,61 @@
+/**
+ * Tab resource registry — deterministic cleanup for viewer resources.
+ *
+ * Viewers register cleanup callbacks (abort controllers, map instances,
+ * cached data) when they mount.  The tab store calls `dispose(tabId)`
+ * on close so resources are freed immediately instead of relying on
+ * garbage collection.
+ */
+function createTabResourceRegistry() {
+    const registry = new Map();
+    return {
+        /**
+         * Register a cleanup callback for a tab.
+         * Returns an unregister function (useful in $effect cleanup).
+         */
+        register(tabId, cleanup) {
+            if (!registry.has(tabId)) {
+                registry.set(tabId, []);
+            }
+            registry.get(tabId).push(cleanup);
+            return () => {
+                const fns = registry.get(tabId);
+                if (fns) {
+                    const idx = fns.indexOf(cleanup);
+                    if (idx !== -1)
+                        fns.splice(idx, 1);
+                    if (fns.length === 0)
+                        registry.delete(tabId);
+                }
+            };
+        },
+        /** Dispose all resources for a single tab. */
+        async dispose(tabId) {
+            const fns = registry.get(tabId);
+            if (!fns)
+                return;
+            registry.delete(tabId);
+            const results = await Promise.allSettled(fns.map((fn) => fn()));
+            for (const r of results) {
+                if (r.status === 'rejected') {
+                    console.warn('[tab-resources] cleanup error for tab', tabId, r.reason);
+                }
+            }
+        },
+        /** Dispose all resources except for the given tab. */
+        async disposeAllExcept(keepTabId) {
+            const entries = [...registry.entries()].filter(([id]) => id !== keepTabId);
+            await Promise.allSettled(entries.map(([id]) => this.dispose(id)));
+        },
+        /** Dispose every registered tab. */
+        async disposeAll() {
+            const ids = [...registry.keys()];
+            await Promise.allSettled(ids.map((id) => this.dispose(id)));
+        },
+        /** Check if a tab has any registered resources. */
+        has(tabId) {
+            return registry.has(tabId);
+        }
+    };
+}
+export const tabResources = createTabResourceRegistry();

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

@@ -0,0 +1,17 @@
+import type { Tab } from '../types.js';
+export declare const tabStore: {
+    readonly items: Tab[];
+    readonly activeTabId: string | null;
+    readonly active: Tab | undefined;
+    /**
+     * Tabs that should be kept alive in the DOM (mounted but hidden if inactive).
+     * Returns up to MAX_ALIVE tabs in MRU order. The active tab is always included.
+     */
+    readonly aliveTabs: Tab[];
+    open(tab: Tab): void;
+    close(id: string): Promise<void>;
+    closeOthers(id: string): Promise<void>;
+    setActive(id: string): void;
+    update(id: string, partial: Partial<Omit<Tab, "id">>): void;
+};
+export { tabStore as tabs };