sliftutils 1.4.45 → 1.4.46

package/index.d.ts

@@ -845,6 +845,14 @@ declare module "sliftutils/storage/BulkDatabase2/BulkDatabase2" {
             value: T[Column];
             time: number;
         }[] | undefined;
+        /**
+         * Reactive: whether (key, column) is loaded yet — true once we know the answer (value, absent, or
+         * deleted), false while it's still loading. getSingleFieldObjSync returns undefined for BOTH "loading"
+         * and "absent", so use this to tell them apart (e.g. show a spinner only when this is false).
+         */
+        isFieldLoadedSync<Column extends keyof T>(key: string, column: Column): boolean;
+        /** Reactive: whether a whole column is loaded yet (see isFieldLoadedSync). */
+        isColumnLoadedSync<Column extends keyof T>(column: Column): boolean;
         /** The columns present on disk and their byte sizes (no row data read). */
         getColumnInfo(): Promise<BulkColumnInfo[]>;
         /** A cheap snapshot of the collection's shape (row/key counts, total bytes, columns) — no row data. */
@@ -1058,6 +1066,8 @@ declare module "sliftutils/storage/BulkDatabase2/BulkDatabaseBase" {
             value: T[Column];
             time: number;
         }[] | undefined;
+        isFieldLoadedSync<Column extends keyof T>(key: string, column: Column): boolean;
+        isColumnLoadedSync<Column extends keyof T>(column: Column): boolean;
         getColumnInfo(): Promise<{
             column: string;
             byteSize: number;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "1.4.45",
+    "version": "1.4.46",
     "main": "index.js",
     "license": "MIT",
     "files": [

package/storage/BulkDatabase2/BulkDatabase2.d.ts

@@ -80,6 +80,14 @@ export interface IBulkDatabase2<T extends {
         value: T[Column];
         time: number;
     }[] | undefined;
+    /**
+     * Reactive: whether (key, column) is loaded yet — true once we know the answer (value, absent, or
+     * deleted), false while it's still loading. getSingleFieldObjSync returns undefined for BOTH "loading"
+     * and "absent", so use this to tell them apart (e.g. show a spinner only when this is false).
+     */
+    isFieldLoadedSync<Column extends keyof T>(key: string, column: Column): boolean;
+    /** Reactive: whether a whole column is loaded yet (see isFieldLoadedSync). */
+    isColumnLoadedSync<Column extends keyof T>(column: Column): boolean;
     /** The columns present on disk and their byte sizes (no row data read). */
     getColumnInfo(): Promise<BulkColumnInfo[]>;
     /** A cheap snapshot of the collection's shape (row/key counts, total bytes, columns) — no row data. */

package/storage/BulkDatabase2/BulkDatabase2.ts

@@ -65,6 +65,15 @@ export interface IBulkDatabase2<T extends { key: string }> {
     /** Synchronous, reactive read of a whole column ({ key, value, time }). undefined while still loading. */
     getColumnSync<Column extends keyof T>(column: Column): { key: string; value: T[Column]; time: number }[] | undefined;
 
+    /**
+     * Reactive: whether (key, column) is loaded yet — true once we know the answer (value, absent, or
+     * deleted), false while it's still loading. getSingleFieldObjSync returns undefined for BOTH "loading"
+     * and "absent", so use this to tell them apart (e.g. show a spinner only when this is false).
+     */
+    isFieldLoadedSync<Column extends keyof T>(key: string, column: Column): boolean;
+    /** Reactive: whether a whole column is loaded yet (see isFieldLoadedSync). */
+    isColumnLoadedSync<Column extends keyof T>(column: Column): boolean;
+
     /** The columns present on disk and their byte sizes (no row data read). */
     getColumnInfo(): Promise<BulkColumnInfo[]>;
     /** A cheap snapshot of the collection's shape (row/key counts, total bytes, columns) — no row data. */

package/storage/BulkDatabase2/BulkDatabaseBase.d.ts

@@ -154,6 +154,8 @@ export declare class BulkDatabaseBase<T extends {
         value: T[Column];
         time: number;
     }[] | undefined;
+    isFieldLoadedSync<Column extends keyof T>(key: string, column: Column): boolean;
+    isColumnLoadedSync<Column extends keyof T>(column: Column): boolean;
     getColumnInfo(): Promise<{
         column: string;
         byteSize: number;

package/storage/BulkDatabase2/BulkDatabaseBase.ts

@@ -1604,6 +1604,38 @@ export class BulkDatabaseBase<T extends { key: string }> {
         return result;
     }
 
+    // Reactive: whether (key, column) is available to read synchronously yet. true once it's loaded — we
+    // know the answer, whether that's a value, absent, or deleted; false while it's still loading from disk.
+    // Pairs with getSingleFieldObjSync, which returns undefined for BOTH "loading" and "absent" — use this
+    // to tell them apart (e.g. show a spinner only when this is false). Triggers the load if not started,
+    // and (like the sync reads) counts the last-known value served during a reload as loaded.
+    public isFieldLoadedSync<Column extends keyof T>(key: string, column: Column): boolean {
+        void this.syncSetup();
+        this.deps.observe(LOAD_SIGNAL);
+        this.deps.observe(key);
+        const entry = this.overlay.get(key);
+        if (entry !== undefined) {
+            if (entry.value === DELETED) return true;          // known: deleted
+            if (String(column) in entry.value) return true;    // known: overlay holds this column
+            // else: this column falls through to disk — check the base caches below
+        }
+        const cacheKey = nullJoin(String(column), key);
+        if (this.baseFields.has(cacheKey) || this.staleBaseFields.has(cacheKey)) return true;
+        this.ensureBaseField(key, String(column));
+        return false;
+    }
+
+    // Reactive: whether a whole column is available to read synchronously yet (see isFieldLoadedSync).
+    public isColumnLoadedSync<Column extends keyof T>(column: Column): boolean {
+        void this.syncSetup();
+        this.deps.observe(LOAD_SIGNAL);
+        this.deps.observe(OVERLAY_SIGNAL);
+        const col = String(column);
+        if (this.columnCache.has(col) || this.baseColumns.has(col) || this.staleBaseColumns.has(col)) return true;
+        this.ensureBaseColumn(col);
+        return false;
+    }
+
     public async getColumnInfo() {
         let reader = await this.reader();
         return reader.columns;