Build output

addons/Dexie.Observable/dist/dexie-observable.d.ts

@@ -0,0 +1,116 @@
+// Type definitions for dexie-observable v4.0.1-beta.13
+// Project: https://github.com/dexie/Dexie.js/tree/master/addons/Dexie.Observable
+// Definitions by: David Fahlander <http://github.com/dfahlander>
+
+import Dexie, { DexieEventSet } from 'dexie';
+import { IDatabaseChange } from '../api';
+
+export interface SyncNodeConstructor {
+    new() : SyncNode;
+}
+
+//
+// Interfaces of Dexie.Observable
+//            
+
+
+/**
+ * A SyncNode represents a local database instance that subscribes
+ * to changes made on the database.
+ * SyncNodes are stored in the _syncNodes table.
+ * 
+ * Dexie.Syncable extends this interface and allows 'remote' nodes to be stored
+ * as well.
+ */
+export interface SyncNode {
+    id?: number,
+    myRevision: number,
+    type: 'local' | 'remote',
+    lastHeartBeat: number,
+    deleteTimeStamp: number, // In case lastHeartBeat is too old, a value of now + HIBERNATE_GRACE_PERIOD will be set here. If reached before node wakes up, node will be deleted.
+    isMaster: number // 1 if true. Not using Boolean because it's not possible to index Booleans.
+}
+
+export interface ObservableEventSet extends DexieEventSet {
+    (eventName: 'latestRevisionIncremented', subscriber: (dbName: string, latestRevision: number) => void): void;
+    (eventName: 'suicideNurseCall', subscriber: (dbName: string, nodeID: number) => void): void;
+    (eventName: 'intercomm', subscriber: (dbName: string) => void): void;
+    (eventName: 'beforeunload', subscriber: () => void): void;
+}
+
+// Object received by on('message') after sendMessage() or broadcastMessage()
+interface MessageEvent {
+    id: number;
+    type: string;
+    message: any;
+    destinationNode: number;
+    wantReply?: boolean;
+    resolve(result: any): void;
+    reject(error: any): void;
+}
+
+//
+// Extend Dexie interface
+//
+declare module 'dexie' {
+    // Extend methods on db (db.sendMessage(), ...)
+    interface Dexie {
+        // Placeholder where to access the SyncNode class constructor.
+        // (makes it valid to do new db.observable.SyncNode())
+        observable: {
+            version: string;
+            SyncNode: SyncNodeConstructor;
+            sendMessage(
+                type: string, // Don't use 'response' as it is used internally by the framework
+                message: any, // anything that can be saved by IndexedDB
+                destinationNode: number,
+                options: {
+                    wantReply?: boolean;
+                }
+            ): Promise<any> | void; // When wantReply is undefined or false return is void
+
+            broadcastMessage(
+                type: string,
+                message: any, // anything that can be saved by IndexedDB
+                bIncludeSelf: boolean
+            ): void;
+        }
+
+        readonly _localSyncNode: SyncNode;
+
+        _changes: Dexie.Table<IDatabaseChange & {rev: number}, number>;
+        _syncNodes: Dexie.Table<SyncNode, number>;
+        _intercomm: Dexie.Table<any, number>;
+    }
+
+    // Extended events db.on('changes', subscriber), ...
+    interface DbEvents {
+        (eventName: 'changes', subscriber: (changes: IDatabaseChange[], partial: boolean)=>void): void;
+        (eventName: 'cleanup', subscriber: ()=>any): void;
+        (eventName: 'message', subscriber: (msg: MessageEvent)=>any): void;
+    }
+
+    // Extended IndexSpec with uuid boolean for primary key.
+    interface IndexSpec {
+        uuid: boolean;
+    }
+
+    interface DexieConstructor {
+        Observable: {
+            (db: Dexie) : void;
+
+            version: string;
+            createUUID: () => string;
+            on: ObservableEventSet;
+            localStorageImpl: {
+                setItem(key: string, value: string): void,
+                getItem(key: string): string,
+                removeItem(key: string): void; 
+            };
+            _onStorage: (event: StorageEvent) => void;
+        }
+
+    }
+}
+
+export default Dexie.Observable;