@wells-nelson/data-storage 0.0.0-stage → 0.0.1

package/dist/containers.js

@@ -0,0 +1,283 @@
+/** Persisting a TanStack DB transaction in the background, logging failures. */
+export function persist(tx) {
+    tx.when('settled').catch((err) => console.error('Failed to save change', err));
+}
+export const now = () => Date.now();
+export const uid = () => crypto.randomUUID();
+/**
+ * Operations on whole containers and the low-level row helpers they're built from. Every write
+ * to a cloud data set marks the container pending so the profile can show unsynced changes.
+ */
+export function createContainerOps(options) {
+    const { schema, app, cloud, tombstones, prefs, supabase, remap } = options;
+    const refs = (options.refs ?? {});
+    const roles = options.roles ?? false;
+    const { container, containerField, collections } = schema;
+    function rx(ds, name) {
+        return ds.db.collections[name];
+    }
+    /** Record that a container changed (only cloud data sets track pending changes). */
+    function touch(ds, containerId) {
+        if (ds.location === 'cloud')
+            cloud.markPending(containerId);
+    }
+    /** Delete documents. `updated_at` is bumped first so the deletion wins last-write-wins conflicts. */
+    async function removeDocs(ds, name, ids) {
+        if (ids.length === 0)
+            return;
+        // Gone from the UI right away, and stays gone if a sync briefly brings an old copy back.
+        tombstones.hide(ds.location, ids);
+        const coll = rx(ds, name);
+        const found = await coll.findByIds(ids).exec();
+        if (found.size === 0)
+            return;
+        const t = now();
+        await coll.bulkUpsert([...found.values()].map((d) => ({ ...d.toMutableJSON(), updated_at: t })));
+        await coll.bulkRemove([...found.keys()]);
+    }
+    async function docsWhere(ds, name, selector) {
+        const docs = await rx(ds, name)
+            .find({ selector: selector })
+            .exec();
+        return docs.map((d) => d.toMutableJSON());
+    }
+    /** Insert one row through TanStack DB (optimistic) and mark its container changed. */
+    function insertDoc(ds, name, doc, containerId) {
+        const coll = ds[name];
+        persist(coll.insert(doc));
+        touch(ds, containerId);
+    }
+    /** Update fields of one row through TanStack DB, bumping `updated_at`. */
+    function patch(ds, name, id, containerId, fields) {
+        const coll = ds[name];
+        persist(coll.update(id, (d) => {
+            Object.assign(d, fields);
+            d.updated_at = now();
+        }));
+        touch(ds, containerId);
+    }
+    // ---------------------------------------------------------------- containers
+    /** Create a container (`id`, `updated_at` and, when the schema has it, `created_at` are filled in). */
+    function createContainer(ds, fields) {
+        const id = uid();
+        const t = now();
+        const hasCreatedAt = 'created_at' in (schema.schemas[container].properties ?? {});
+        const doc = { ...fields, id, updated_at: t, ...(hasCreatedAt ? { created_at: t } : {}) };
+        insertDoc(ds, container, doc, id);
+        if (ds.location === 'cloud')
+            cloud.setRole(id, 'owner');
+        return id;
+    }
+    function renameContainer(ds, containerId, name) {
+        patch(ds, container, containerId, containerId, { name });
+    }
+    async function readContainer(ds, containerId) {
+        const out = {};
+        for (const name of collections) {
+            out[name] =
+                name === container
+                    ? await docsWhere(ds, name, { id: containerId })
+                    : await docsWhere(ds, name, { [containerField]: containerId });
+        }
+        return out;
+    }
+    async function removeContainerDocs(ds, containerId) {
+        const docs = await readContainer(ds, containerId);
+        // Children first, the container row last.
+        for (const name of [...collections].reverse()) {
+            await removeDocs(ds, name, docs[name].map((d) => d.id));
+        }
+    }
+    /** Insert a whole container (all collections) into a data set, parents first. Used for copies and seeds. */
+    async function insertContainerDocs(to, docs) {
+        for (const name of collections) {
+            const rows = docs[name] ?? [];
+            if (rows.length === 0)
+                continue;
+            const result = await rx(to, name).bulkUpsert(rows);
+            if (result.error.length)
+                throw new Error(`Saving ${name} failed`);
+        }
+    }
+    /**
+     * Copy rows to a new container id, regenerating every id when `newIds` (so the copy is
+     * independent), and giving all rows a fresh `updated_at` so they beat any older (e.g.
+     * soft-deleted) server copy under last-write-wins. Pure; exported for testing.
+     */
+    function remapContainer(docs, containerId, newIds) {
+        const ids = new Map();
+        const map = (id) => {
+            if (!newIds || !id)
+                return id;
+            let next = ids.get(id);
+            if (!next)
+                ids.set(id, (next = uid()));
+            return next;
+        };
+        const t = now();
+        const cid = map(containerId);
+        const rows = {};
+        for (const name of collections) {
+            const refFields = refs[name] ?? [];
+            rows[name] = docs[name].map((d) => {
+                const row = { ...d, id: name === container ? cid : map(d.id), updated_at: t };
+                if (name !== container)
+                    row[containerField] = cid;
+                for (const f of refFields)
+                    row[f] = map(row[f]);
+                return remap ? remap(name, row, map) : row;
+            });
+        }
+        return { rows, containerId: cid };
+    }
+    async function copyContainer(from, to, containerId, newIds) {
+        const { rows, containerId: cid } = remapContainer(await readContainer(from, containerId), containerId, newIds);
+        if (to.location === 'cloud') {
+            cloud.markPending(cid);
+            cloud.setRole(cid, 'owner');
+        }
+        // Rows deliberately written again (e.g. a container moved back here) must not stay hidden.
+        for (const name of collections)
+            tombstones.unhide(to.location, rows[name].map((r) => r.id));
+        await insertContainerDocs(to, rows);
+        return cid;
+    }
+    /** Remove a cloud container from this device only; nothing is deleted on Supabase. */
+    async function purgeCloudContainer(containerId) {
+        const ds = app.dataSet('cloud');
+        cloud.block(containerId);
+        await removeContainerDocs(ds, containerId);
+    }
+    function requireOnline() {
+        if (!cloud.online)
+            throw new Error('This needs an internet connection. Try again once you are back online.');
+    }
+    async function otherMembers(containerId) {
+        requireOnline();
+        const members = await supabase.fetchMembers(containerId);
+        return members.filter((m) => m.email !== cloud.email);
+    }
+    const isOwner = (m) => !roles || m.role === 'owner';
+    /** local-only -> cloud-enabled. Same ids; uploads (or queues the upload when offline). */
+    async function makeCloud(containerId) {
+        const local = app.dataSet('local');
+        await copyContainer(local, app.dataSet('cloud'), containerId, false);
+        await removeContainerDocs(local, containerId);
+    }
+    /**
+     * cloud-enabled -> local-only. Unshared containers are deleted from Supabase and kept here
+     * with the same ids. Shared ones stay on Supabase for the others; we keep a copy under new
+     * ids and leave. Returns the id of the local container.
+     */
+    async function makeLocal(containerId) {
+        const cloudDs = app.dataSet('cloud');
+        const local = app.dataSet('local');
+        const others = await otherMembers(containerId);
+        if (others.length === 0) {
+            await copyContainer(cloudDs, local, containerId, false);
+            await removeContainerDocs(cloudDs, containerId);
+            prefs.markPrompted([containerId]);
+            return containerId;
+        }
+        // Copy before leaving: if leaving fails the worst case is an extra local copy, not lost data.
+        const newId = await copyContainer(cloudDs, local, containerId, true);
+        await supabase.leave(containerId, cloud.email);
+        await purgeCloudContainer(containerId);
+        prefs.markPrompted([newId]);
+        prefs.replaceContainer(containerId, newId);
+        return newId;
+    }
+    /**
+     * Delete a container. For a cloud container we only leave it while other owners remain
+     * (without roles: while it's shared with anyone); otherwise it's deleted for everyone.
+     */
+    async function deleteContainer(ds, containerId) {
+        // Hide it immediately so it never flashes back while the delete runs.
+        tombstones.hide(ds.location, [containerId]);
+        try {
+            if (ds.location === 'local') {
+                await removeContainerDocs(ds, containerId);
+            }
+            else {
+                const others = await otherMembers(containerId);
+                if (others.some(isOwner)) {
+                    await supabase.leave(containerId, cloud.email);
+                    await purgeCloudContainer(containerId);
+                }
+                else {
+                    await removeContainerDocs(ds, containerId);
+                }
+            }
+        }
+        catch (err) {
+            tombstones.unhide(ds.location, [containerId]);
+            throw err;
+        }
+        prefs.replaceContainer(containerId, null);
+    }
+    /** Leave a shared container (non-owners, or owners while other owners remain). */
+    async function leaveContainer(containerId) {
+        requireOnline();
+        tombstones.hide('cloud', [containerId]);
+        try {
+            await supabase.leave(containerId, cloud.email);
+        }
+        catch (err) {
+            tombstones.unhide('cloud', [containerId]);
+            throw err;
+        }
+        await purgeCloudContainer(containerId);
+        prefs.replaceContainer(containerId, null);
+    }
+    /** For a container we were removed from: keep a local-only copy (new ids), drop the cloud copy. */
+    async function keepRevokedCopy(containerId) {
+        const newId = await copyContainer(app.dataSet('cloud'), app.dataSet('local'), containerId, true);
+        await purgeCloudContainer(containerId);
+        prefs.markPrompted([newId]);
+        prefs.replaceContainer(containerId, newId);
+        return newId;
+    }
+    async function removeRevoked(containerId) {
+        await purgeCloudContainer(containerId);
+        prefs.replaceContainer(containerId, null);
+    }
+    /**
+     * Merge the local and cloud containers for display: hidden (deleted) ones dropped, and one
+     * entry per id while a container moves between data sets (the cloud copy wins).
+     */
+    function entries(localRows, cloudRows) {
+        const byId = new Map();
+        for (const row of localRows) {
+            if (!tombstones.has('local', row.id))
+                byId.set(row.id, { container: row, location: 'local', role: 'owner' });
+        }
+        for (const row of cloudRows) {
+            if (!tombstones.has('cloud', row.id)) {
+                byId.set(row.id, { container: row, location: 'cloud', role: cloud.roleOf(row.id) });
+            }
+        }
+        return [...byId.values()];
+    }
+    return {
+        rx,
+        touch,
+        removeDocs,
+        docsWhere,
+        insertDoc,
+        patch,
+        createContainer,
+        renameContainer,
+        readContainer,
+        removeContainerDocs,
+        insertContainerDocs,
+        remapContainer,
+        copyContainer,
+        makeCloud,
+        makeLocal,
+        deleteContainer,
+        leaveContainer,
+        keepRevokedCopy,
+        removeRevoked,
+        entries
+    };
+}

package/dist/database.d.ts

@@ -0,0 +1,24 @@
+import { type RxCollection, type RxConflictHandler, type RxDatabase, type RxStorage } from 'rxdb/plugins/core';
+import type { CollectionName, DocMap, StoreSchema } from './types.js';
+export type Collections<D extends DocMap> = {
+    [N in CollectionName<D>]: RxCollection<D[N]>;
+};
+export type Database<D extends DocMap> = RxDatabase<Collections<D>>;
+export declare function docsEqual(a: Record<string, unknown>, b: Record<string, unknown>): boolean;
+/**
+ * Last write wins: whichever side carries the newer `updated_at` (client clock) is kept.
+ * Ties go to the server so every device converges on the same state.
+ */
+export declare const lastWriteWins: RxConflictHandler<{
+    updated_at: number;
+}>;
+export type StorageFactory = () => RxStorage<any, any>;
+/** Browser code uses Dexie (IndexedDB); scripts and tests can swap in memory storage. */
+export declare function setStorageFactory(factory: StorageFactory): void;
+export interface OpenDatabaseOptions {
+    storage?: StorageFactory;
+    /** Share the database between tabs (default true). */
+    multiInstance?: boolean;
+}
+/** Create an RxDB database with one collection per schema, all using last-write-wins. */
+export declare function openDatabase<D extends DocMap>(name: string, schema: Pick<StoreSchema<D>, 'collections' | 'schemas'>, { storage, multiInstance }?: OpenDatabaseOptions): Promise<Database<D>>;

package/dist/database.js

@@ -0,0 +1,39 @@
+import { createRxDatabase } from 'rxdb/plugins/core';
+const IGNORED_FIELDS = new Set(['_meta', '_rev', '_attachments']);
+export function docsEqual(a, b) {
+    const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+    for (const key of keys) {
+        if (IGNORED_FIELDS.has(key))
+            continue;
+        if (a[key] !== b[key])
+            return false;
+    }
+    return true;
+}
+/**
+ * Last write wins: whichever side carries the newer `updated_at` (client clock) is kept.
+ * Ties go to the server so every device converges on the same state.
+ */
+export const lastWriteWins = {
+    isEqual: (a, b) => docsEqual(a, b),
+    resolve: async ({ newDocumentState, realMasterState }) => (newDocumentState.updated_at ?? 0) > (realMasterState.updated_at ?? 0) ? newDocumentState : realMasterState
+};
+let storageFactory = () => {
+    throw new Error('No RxDB storage configured. Call setStorageFactory() or pass `storage`.');
+};
+/** Browser code uses Dexie (IndexedDB); scripts and tests can swap in memory storage. */
+export function setStorageFactory(factory) {
+    storageFactory = factory;
+}
+/** Create an RxDB database with one collection per schema, all using last-write-wins. */
+export async function openDatabase(name, schema, { storage, multiInstance = true } = {}) {
+    const db = await createRxDatabase({
+        name,
+        storage: (storage ?? storageFactory)(),
+        multiInstance,
+        eventReduce: true,
+        closeDuplicates: true
+    });
+    await db.addCollections(Object.fromEntries(schema.collections.map((n) => [n, { schema: schema.schemas[n], conflictHandler: lastWriteWins }])));
+    return db;
+}

package/dist/dataset.d.ts

@@ -0,0 +1,18 @@
+import type { RxCollection } from 'rxdb/plugins/core';
+import type { Database } from './database.js';
+import type { CollectionName, DocMap, Location, StoreSchema } from './types.js';
+declare function makeCollection<T extends object>(id: string, rxCollection: RxCollection<T>): import("@tanstack/db").Collection<T, string, import("@tanstack/db").UtilsRecord, never, T> & import("@tanstack/db").NonSingleResult;
+export type TSCollection<T extends object> = ReturnType<typeof makeCollection<T>>;
+/**
+ * One RxDB database plus a TanStack DB collection on top of each RxDB collection.
+ * Components query the TanStack collections; bulk operations go straight to RxDB.
+ */
+export type DataSet<D extends DocMap> = {
+    location: Location;
+    db: Database<D>;
+} & {
+    [N in CollectionName<D>]: TSCollection<D[N]>;
+};
+export declare function createDataSet<D extends DocMap>(location: Location, db: Database<D>, schema: Pick<StoreSchema<D>, 'collections' | 'container' | 'containerField' | 'indexContainerField'>): DataSet<D>;
+export declare function disposeDataSet<D extends DocMap>(ds: DataSet<D>, collections: readonly CollectionName<D>[]): Promise<void>;
+export {};

package/dist/dataset.js

@@ -0,0 +1,25 @@
+import { BasicIndex, createCollection } from '@tanstack/db';
+import { rxdbCollectionOptions } from '@tanstack/rxdb-db-collection';
+function makeCollection(id, rxCollection) {
+    return createCollection(rxdbCollectionOptions({
+        id,
+        rxCollection: rxCollection,
+        startSync: true,
+        gcTime: 0
+    }));
+}
+export function createDataSet(location, db, schema) {
+    const ds = { location, db };
+    for (const name of schema.collections) {
+        const coll = makeCollection(`${db.name}-${name}`, db.collections[name]);
+        // Container pages filter by container; index it when collections get big.
+        if (schema.indexContainerField && name !== schema.container) {
+            coll.createIndex((row) => row[schema.containerField], { indexType: BasicIndex });
+        }
+        ds[name] = coll;
+    }
+    return ds;
+}
+export async function disposeDataSet(ds, collections) {
+    await Promise.all(collections.map((n) => ds[n].cleanup()));
+}

package/dist/env.d.ts

@@ -0,0 +1,20 @@
+export interface EnvConfig {
+    supabaseUrl: string;
+    supabaseAnonKey: string;
+    /** False when either Supabase value is missing: the app runs fully local-only. */
+    cloudConfigured: boolean;
+}
+/**
+ * Read the Supabase settings from Vite env vars. Pass `import.meta.env` from the app, so the
+ * values are replaced at the app's build time:
+ *
+ * ```ts
+ * export const env = envConfig(import.meta.env);
+ * ```
+ *
+ * Values come from `.env.local` during development and from repository variables in the deploy
+ * workflow. When either is missing the app runs fully local-only.
+ */
+export declare function envConfig(env: {
+    readonly [key: string]: unknown;
+}): EnvConfig;

package/dist/env.js

@@ -0,0 +1,17 @@
+/**
+ * Read the Supabase settings from Vite env vars. Pass `import.meta.env` from the app, so the
+ * values are replaced at the app's build time:
+ *
+ * ```ts
+ * export const env = envConfig(import.meta.env);
+ * ```
+ *
+ * Values come from `.env.local` during development and from repository variables in the deploy
+ * workflow. When either is missing the app runs fully local-only.
+ */
+export function envConfig(env) {
+    const read = (key) => (typeof env[key] === 'string' ? env[key] : '');
+    const supabaseUrl = read('VITE_SUPABASE_URL');
+    const supabaseAnonKey = read('VITE_SUPABASE_ANON_KEY');
+    return { supabaseUrl, supabaseAnonKey, cloudConfigured: Boolean(supabaseUrl && supabaseAnonKey) };
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { AppState } from './app.svelte.js';
+export { CloudSync, errorMessage, isRejection, type CloudSyncOptions } from './cloud.svelte.js';
+export { createContainerOps, now, persist, uid, type ContainerDocs, type ContainerEntry, type ContainerOps, type ContainerOpsOptions, type RemapHook } from './containers.js';
+export { docsEqual, lastWriteWins, openDatabase, setStorageFactory, type Collections, type Database, type OpenDatabaseOptions, type StorageFactory } from './database.js';
+export { createDataSet, disposeDataSet, type DataSet, type TSCollection } from './dataset.js';
+export { envConfig, type EnvConfig } from './env.js';
+export { Persisted } from './persisted.svelte.js';
+export { DevicePrefs, defaultPrefsKeys, type DevicePrefsKeys } from './prefs.svelte.js';
+export { field, flatSchema, type FieldSpec } from './schema.js';
+export { createSyncedStore, type SyncedStore, type SyncedStoreConfig } from './store.js';
+export { createSupabaseApi, friendlyError, type Member, type MembersConfig, type SupabaseApi } from './supabase.js';
+export { Tombstones } from './tombstones.svelte.js';
+export { containerIdOf, type CollectionName, type DocBase, type DocMap, type Location, type Nouns, type Role, type StoreSchema } from './types.js';

package/dist/index.js

@@ -0,0 +1,13 @@
+export { AppState } from './app.svelte.js';
+export { CloudSync, errorMessage, isRejection } from './cloud.svelte.js';
+export { createContainerOps, now, persist, uid } from './containers.js';
+export { docsEqual, lastWriteWins, openDatabase, setStorageFactory } from './database.js';
+export { createDataSet, disposeDataSet } from './dataset.js';
+export { envConfig } from './env.js';
+export { Persisted } from './persisted.svelte.js';
+export { DevicePrefs, defaultPrefsKeys } from './prefs.svelte.js';
+export { field, flatSchema } from './schema.js';
+export { createSyncedStore } from './store.js';
+export { createSupabaseApi, friendlyError } from './supabase.js';
+export { Tombstones } from './tombstones.svelte.js';
+export { containerIdOf } from './types.js';

package/dist/persisted.svelte.d.ts

@@ -0,0 +1,12 @@
+/** Reactive value mirrored to localStorage. Storage failures (private mode, quota) are ignored. */
+export declare class Persisted<T> {
+    #private;
+    constructor(key: string, initial: T);
+    get value(): T;
+    set value(v: T);
+    /** Re-point at another key (e.g. when the signed-in user changes). */
+    rekey(key: string, initial: T): void;
+    static read<T>(key: string, fallback: T): T;
+    static write(key: string, value: unknown): void;
+    static remove(key: string): void;
+}

package/dist/persisted.svelte.js

@@ -0,0 +1,46 @@
+/** Reactive value mirrored to localStorage. Storage failures (private mode, quota) are ignored. */
+export class Persisted {
+    #key;
+    #value = $state();
+    constructor(key, initial) {
+        this.#key = key;
+        this.#value = Persisted.read(key, initial);
+    }
+    get value() {
+        return this.#value;
+    }
+    set value(v) {
+        this.#value = v;
+        Persisted.write(this.#key, v);
+    }
+    /** Re-point at another key (e.g. when the signed-in user changes). */
+    rekey(key, initial) {
+        this.#key = key;
+        this.#value = Persisted.read(key, initial);
+    }
+    static read(key, fallback) {
+        try {
+            const raw = localStorage.getItem(key);
+            return raw === null ? fallback : JSON.parse(raw);
+        }
+        catch {
+            return fallback;
+        }
+    }
+    static write(key, value) {
+        try {
+            localStorage.setItem(key, JSON.stringify(value));
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    static remove(key) {
+        try {
+            localStorage.removeItem(key);
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}

package/dist/prefs.svelte.d.ts

@@ -0,0 +1,33 @@
+import type { Nouns } from './types.js';
+export interface DevicePrefsKeys {
+    collapsed: string;
+    prompted: string;
+    defaultContainer: string;
+}
+/**
+ * Default localStorage keys, e.g. for prefix `demo` and noun project:
+ * `demo:collapsed`, `demo:promptedLocalProjects`, `demo:defaultProject`.
+ */
+export declare function defaultPrefsKeys(prefix: string, nouns: Nouns): DevicePrefsKeys;
+/**
+ * Per-device preferences that never sync: the default container (cold-start redirect), which
+ * local-only containers were already offered for cloud sync, and collapsed sections.
+ * Subclass it for app-specific prefs; override `replaceContainer` to keep them in step when a
+ * container changes id or is deleted.
+ */
+export declare class DevicePrefs {
+    #private;
+    /** Set once the cold-start redirect to the default container was considered for this page load. */
+    defaultChecked: boolean;
+    constructor(keys: DevicePrefsKeys);
+    /** The container a cold start of the app opens straight into. */
+    get defaultContainerId(): string | null;
+    setDefaultContainer(id: string | null): void;
+    /** A container moved to a new id (`newId`) or was deleted (`null`). */
+    replaceContainer(oldId: string, newId: string | null): void;
+    isCollapsed(key: string, fallback?: boolean): boolean;
+    setCollapsed(key: string, collapsed: boolean): void;
+    /** Local-only containers already offered in the "make cloud-enabled?" prompt after sign-in. */
+    wasPrompted(id: string): boolean;
+    markPrompted(ids: string[]): void;
+}

package/dist/prefs.svelte.js

@@ -0,0 +1,56 @@
+import { Persisted } from './persisted.svelte.js';
+const cap = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+/**
+ * Default localStorage keys, e.g. for prefix `demo` and noun project:
+ * `demo:collapsed`, `demo:promptedLocalProjects`, `demo:defaultProject`.
+ */
+export function defaultPrefsKeys(prefix, nouns) {
+    return {
+        collapsed: `${prefix}:collapsed`,
+        prompted: `${prefix}:promptedLocal${cap(nouns.plural)}`,
+        defaultContainer: `${prefix}:default${cap(nouns.singular)}`
+    };
+}
+/**
+ * Per-device preferences that never sync: the default container (cold-start redirect), which
+ * local-only containers were already offered for cloud sync, and collapsed sections.
+ * Subclass it for app-specific prefs; override `replaceContainer` to keep them in step when a
+ * container changes id or is deleted.
+ */
+export class DevicePrefs {
+    #collapsed;
+    #prompted;
+    #defaultContainer;
+    /** Set once the cold-start redirect to the default container was considered for this page load. */
+    defaultChecked = false;
+    constructor(keys) {
+        this.#collapsed = new Persisted(keys.collapsed, {});
+        this.#prompted = new Persisted(keys.prompted, []);
+        this.#defaultContainer = new Persisted(keys.defaultContainer, null);
+    }
+    /** The container a cold start of the app opens straight into. */
+    get defaultContainerId() {
+        return this.#defaultContainer.value;
+    }
+    setDefaultContainer(id) {
+        this.#defaultContainer.value = id;
+    }
+    /** A container moved to a new id (`newId`) or was deleted (`null`). */
+    replaceContainer(oldId, newId) {
+        if (this.#defaultContainer.value === oldId)
+            this.#defaultContainer.value = newId;
+    }
+    isCollapsed(key, fallback = false) {
+        return this.#collapsed.value[key] ?? fallback;
+    }
+    setCollapsed(key, collapsed) {
+        this.#collapsed.value = { ...this.#collapsed.value, [key]: collapsed };
+    }
+    /** Local-only containers already offered in the "make cloud-enabled?" prompt after sign-in. */
+    wasPrompted(id) {
+        return this.#prompted.value.includes(id);
+    }
+    markPrompted(ids) {
+        this.#prompted.value = [...new Set([...this.#prompted.value, ...ids])];
+    }
+}

package/dist/schema.d.ts

@@ -0,0 +1,30 @@
+import type { RxJsonSchema } from 'rxdb/plugins/core';
+/** Field shorthands for `flatSchema`. */
+export declare const field: {
+    /** The primary key (RxDB needs a maxLength on it). */
+    readonly id: {
+        readonly type: "string";
+        readonly maxLength: 100;
+    };
+    readonly string: {
+        readonly type: "string";
+    };
+    readonly number: {
+        readonly type: "number";
+    };
+    readonly boolean: {
+        readonly type: "boolean";
+    };
+};
+export type FieldSpec = {
+    type: 'string' | 'number' | 'boolean';
+    maxLength?: number;
+};
+/**
+ * RxDB JSON schema for a flat table: every field required, string `id` primary key, version 0.
+ *
+ * ```ts
+ * const projects = flatSchema<ProjectDoc>({ id: field.id, name: field.string, created_at: field.number, updated_at: field.number });
+ * ```
+ */
+export declare function flatSchema<T>(properties: Record<keyof T & string, FieldSpec>): RxJsonSchema<T>;

package/dist/schema.js

@@ -0,0 +1,24 @@
+/** Field shorthands for `flatSchema`. */
+export const field = {
+    /** The primary key (RxDB needs a maxLength on it). */
+    id: { type: 'string', maxLength: 100 },
+    string: { type: 'string' },
+    number: { type: 'number' },
+    boolean: { type: 'boolean' }
+};
+/**
+ * RxDB JSON schema for a flat table: every field required, string `id` primary key, version 0.
+ *
+ * ```ts
+ * const projects = flatSchema<ProjectDoc>({ id: field.id, name: field.string, created_at: field.number, updated_at: field.number });
+ * ```
+ */
+export function flatSchema(properties) {
+    return {
+        version: 0,
+        primaryKey: 'id',
+        type: 'object',
+        properties,
+        required: Object.keys(properties)
+    };
+}