0.6.13: Removing ugly dependencies.d.ts and sprinkling the interface dependencies at the local module level, where they belong.

Author: David de Regt

package.json

@@ -1,6 +1,6 @@
 {
   "name": "nosqlprovider",
-  "version": "0.6.12",
+  "version": "0.6.13",
   "description": "A cross-browser/platform indexeddb-like client library",
   "author": "David de Regt <David.de.Regt@microsoft.com>",
   "scripts": {

src/CordovaNativeSqliteProvider.ts

@@ -15,6 +15,41 @@ import NoSqlProvider = require('./NoSqlProvider');
 import SqlProviderBase = require('./SqlProviderBase');
 import TransactionLockHelper, { TransactionToken } from './TransactionLockHelper';
 
+// Extending interfaces that should be in lib.d.ts but aren't for some reason.
+declare global {
+    interface Window {
+        sqlitePlugin: any;
+    }
+}
+
+// declare enum SQLErrors {
+//     UNKNOWN_ERR = 0,
+//     DATABASE_ERR = 1,
+//     VERSION_ERR = 2,
+//     TOO_LARGE_ERR = 3,
+//     QUOTA_ERR = 4,
+//     SYNTAX_ERR = 5,
+//     CONSTRAINT_ERR = 6,
+//     TIMEOUT_ERR = 7
+// }
+
+interface SQLError {
+    code: number;
+    message: string;
+}
+
+interface SQLStatementCallback {
+    (transaction: SQLTransaction, resultSet: SqlProviderBase.SQLResultSet): void;
+}
+
+interface SQLStatementErrorCallback {
+    (transaction: SQLTransaction, error: SQLError): void;
+}
+
+interface SQLTransaction {
+    executeSql(sqlStatement: string, args?: any[], callback?: SQLStatementCallback, errorCallback?: SQLStatementErrorCallback): void;
+}
+
 export type SqliteSuccessCallback = () => void;
 export type SqliteErrorCallback = (e: Error) => void;
 
@@ -32,11 +67,14 @@ export interface SqlitePluginDbParams extends SqlitePluginDbOptionalParams {
 
 export interface SqliteDatabase {
     openDBs: string[];
-    transaction(transaction: CordovaTransaction, error: SQLTransactionErrorCallback, success: SQLTransactionCallback): void;
-    readTransaction(transaction: CordovaTransaction, error: SQLTransactionErrorCallback, success: SQLTransactionCallback): void;
+    transaction(transaction: CordovaTransaction, error: SqlProviderBase.SQLTransactionErrorCallback,
+        success: SqlProviderBase.SQLTransactionCallback): void;
+    readTransaction(transaction: CordovaTransaction, error: SqlProviderBase.SQLTransactionErrorCallback,
+        success: SqlProviderBase.SQLTransactionCallback): void;
     open(success: SqliteSuccessCallback, error: SqliteErrorCallback): void;
     close(success: SqliteSuccessCallback, error: SqliteErrorCallback): void;
-    executeSql(statement: string, params?: any[], success?: SQLStatementCallback, error?: SQLStatementErrorCallback): void;
+    executeSql(statement: string, params?: any[], success?: SqlProviderBase.SQLStatementCallback,
+        error?: SqlProviderBase.SQLStatementErrorCallback): void;
 }
 
 export interface SqlitePlugin {
@@ -45,7 +83,7 @@ export interface SqlitePlugin {
     sqliteFeatures: { isSQLitePlugin: boolean };
 }
 
-export interface CordovaTransaction extends SQLTransaction {
+export interface CordovaTransaction extends SqlProviderBase.SQLTransaction {
     abort(err?: any): void;
 }
 

src/IndexedDbProvider.ts

@@ -17,6 +17,16 @@ import TransactionLockHelper, { TransactionToken } from './TransactionLockHelper
 
 const IndexPrefix = 'nsp_i_';
 
+// Extending interfaces that should be in lib.d.ts but aren't for some reason.
+declare global {
+    interface Window {
+        _indexedDB: IDBFactory;
+        mozIndexedDB: IDBFactory;
+        webkitIndexedDB: IDBFactory;
+        msIndexedDB: IDBFactory;
+    }
+}
+
 // The DbProvider implementation for IndexedDB.  This one is fairly straightforward since the library's access patterns pretty
 // closely mirror IndexedDB's.  We mostly do a lot of wrapping of the APIs into JQuery promises and have some fancy footwork to
 // do semi-automatic schema upgrades.

src/NoSqlProviderUtils.ts

@@ -10,6 +10,13 @@ import _ = require('lodash');
 
 import { KeyComponentType, KeyPathType, KeyType } from './NoSqlProvider';
 
+// Extending interfaces that should be in lib.d.ts but aren't for some reason.
+declare global {
+    interface Document {
+        documentMode: number;
+    }
+}
+
 export function isIE() {
     return (typeof (document) !== 'undefined' && document.all !== null && document.documentMode <= 11) ||
         (typeof (navigator) !== 'undefined' && !!navigator.userAgent && navigator.userAgent.indexOf('Edge/') !== -1);

src/SqlProviderBase.ts

@@ -14,6 +14,30 @@ import NoSqlProvider = require('./NoSqlProvider');
 import { ItemType } from './NoSqlProvider';
 import NoSqlProviderUtils = require('./NoSqlProviderUtils');
 
+// Extending interfaces that should be in lib.d.ts but aren't for some reason.
+export interface SQLVoidCallback {
+    (): void;
+}
+
+export interface SQLTransactionCallback {
+    (transaction: SQLTransaction): void;
+}
+
+export interface SQLTransactionErrorCallback {
+    (error: SQLError): void;
+}
+
+export interface SQLDatabase {
+    version: string;
+
+    changeVersion(oldVersion: string, newVersion: string, callback?: SQLTransactionCallback,
+        errorCallback?: SQLTransactionErrorCallback, successCallback?: SQLVoidCallback): void;
+    transaction(callback?: SQLTransactionCallback, errorCallback?: SQLTransactionErrorCallback,
+        successCallback?: SQLVoidCallback): void;
+    readTransaction(callback?: SQLTransactionCallback, errorCallback?: SQLTransactionErrorCallback,
+        successCallback?: SQLVoidCallback): void;
+}
+
 const schemaVersionKey = 'schemaVersion';
 
 // This was taked from the sqlite documentation

src/WebSqlProvider.ts

@@ -12,11 +12,23 @@ import SyncTasks = require('synctasks');
 import NoSqlProvider = require('./NoSqlProvider');
 import SqlProviderBase = require('./SqlProviderBase');
 
+// Extending interfaces that should be in lib.d.ts but aren't for some reason.
+export interface SQLDatabaseCallback {
+    (database: SqlProviderBase.SQLDatabase): void;
+}
+
+declare global {
+    interface Window {
+        openDatabase(database_name: string, database_version: string, database_displayname: string,
+            database_size?: number, creationCallback?: SQLDatabaseCallback): SqlProviderBase.SQLDatabase;
+    }
+}
+
 // The DbProvider implementation for WebSQL.  This provider does a bunch of awkward stuff to pretend that a relational SQL store
 // is actually a NoSQL store.  We store the raw object as a JSON.encoded string in the nsp_data column, and have an nsp_pk column
 // for the primary keypath value, then nsp_i_[index name] columns for each of the indexes.
 export class WebSqlProvider extends SqlProviderBase.SqlProviderBase {
-    private _db: Database|undefined;
+    private _db: SqlProviderBase.SQLDatabase|undefined;
 
     constructor(supportsFTS3 = true) {
         super(supportsFTS3);
@@ -104,11 +116,11 @@ export class WebSqlProvider extends SqlProviderBase.SqlProviderBase {
         let ourTrans: SqlProviderBase.SqliteSqlTransaction|undefined;
         let finishDefer: SyncTasks.Deferred<void>|undefined = SyncTasks.Defer<void>();
         (writeNeeded ? this._db.transaction : this._db.readTransaction).call(this._db,
-            (trans: SQLTransaction) => {
+            (trans: SqlProviderBase.SQLTransaction) => {
                 ourTrans = new WebSqlTransaction(trans, finishDefer!!!.promise(), this._schema!!!, this._verbose!!!, 999,
                     this._supportsFTS3);
                 deferred.resolve(ourTrans);
-            }, (err: SQLError) => {
+            }, (err: SqlProviderBase.SQLError) => {
                 if (ourTrans) {
                     // Got an error from inside the transaction.  Error out all pending queries on the 
                     // transaction since they won't exit out gracefully for whatever reason.
@@ -134,7 +146,7 @@ export class WebSqlProvider extends SqlProviderBase.SqlProviderBase {
 }
 
 class WebSqlTransaction extends SqlProviderBase.SqliteSqlTransaction {
-    constructor(protected trans: SQLTransaction,
+    constructor(protected trans: SqlProviderBase.SQLTransaction,
                 private _completionPromise: SyncTasks.Promise<void>, 
                 schema: NoSqlProvider.DbSchema,
                 verbose: boolean,