mongodb-livedata-server 0.1.3 → 0.1.4

package/dist/meteor/mongo/synchronous-queue.js

@@ -1,110 +1,110 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._SynchronousQueue = void 0;
-const double_ended_queue_1 = __importDefault(require("double-ended-queue"));
-class _SynchronousQueue {
-    constructor() {
-        // List of tasks to run (not including a currently-running task if any). Each
-        // is an object with field 'task' (the task function to run) and 'future' (the
-        // Future associated with the blocking runTask call that queued it, or null if
-        // called from queueTask).
-        this._taskHandles = new double_ended_queue_1.default();
-        // This is true if self._run() is either currently executing or scheduled to
-        // do so soon.
-        this._runningOrRunScheduled = false;
-        // This is true if we're currently draining.  While we're draining, a further
-        // drain is a noop, to prevent infinite loops.  "drain" is a heuristic type
-        // operation, that has a meaning like unto "what a naive person would expect
-        // when modifying a table from an observe"
-        this._draining = false;
-    }
-    async runTask(task) {
-        return new Promise((resolve, reject) => {
-            var handle = {
-                task: task,
-                name: task.name,
-                runTaskResolve: resolve,
-                runTaskReject: reject
-            };
-            this._taskHandles.push(handle);
-            this._scheduleRun();
-            // Yield. We'll get back here after the task is run (and will throw if the
-            // task throws).
-        });
-    }
-    queueTask(task) {
-        var self = this;
-        self._taskHandles.push({
-            task: task,
-            name: task.name
-        });
-        self._scheduleRun();
-        // No need to block.
-    }
-    async flush() {
-        var self = this;
-        await self.runTask(async () => { });
-    }
-    async drain() {
-        var self = this;
-        if (self._draining)
-            return;
-        self._draining = true;
-        while (!self._taskHandles.isEmpty()) {
-            await self.flush();
-        }
-        self._draining = false;
-    }
-    ;
-    _scheduleRun() {
-        // Already running or scheduled? Do nothing.
-        if (this._runningOrRunScheduled)
-            return;
-        this._runningOrRunScheduled = true;
-        setImmediate(async () => {
-            await this._run();
-        });
-    }
-    ;
-    async _run() {
-        var self = this;
-        if (!self._runningOrRunScheduled)
-            throw new Error("expected to be _runningOrRunScheduled");
-        if (self._taskHandles.isEmpty()) {
-            // Done running tasks! Don't immediately schedule another run, but
-            // allow future tasks to do so.
-            self._runningOrRunScheduled = false;
-            return;
-        }
-        var taskHandle = self._taskHandles.shift();
-        // Run the task.
-        var exception = undefined;
-        try {
-            await taskHandle.task();
-        }
-        catch (err) {
-            if (taskHandle.runTaskReject) {
-                // We'll throw this exception through runTask.
-                exception = err;
-            }
-            else {
-                console.error("Exception in queued task", err);
-            }
-        }
-        // Soon, run the next task, if there is any.
-        self._runningOrRunScheduled = false;
-        self._scheduleRun();
-        // If this was queued with runTask, let the runTask call return (throwing if
-        // the task threw).
-        if (taskHandle.runTaskReject) {
-            if (exception)
-                taskHandle.runTaskReject(exception);
-            else
-                taskHandle.runTaskResolve();
-        }
-    }
-}
-exports._SynchronousQueue = _SynchronousQueue;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._SynchronousQueue = void 0;
+const double_ended_queue_1 = __importDefault(require("double-ended-queue"));
+class _SynchronousQueue {
+    constructor() {
+        // List of tasks to run (not including a currently-running task if any). Each
+        // is an object with field 'task' (the task function to run) and 'future' (the
+        // Future associated with the blocking runTask call that queued it, or null if
+        // called from queueTask).
+        this._taskHandles = new double_ended_queue_1.default();
+        // This is true if self._run() is either currently executing or scheduled to
+        // do so soon.
+        this._runningOrRunScheduled = false;
+        // This is true if we're currently draining.  While we're draining, a further
+        // drain is a noop, to prevent infinite loops.  "drain" is a heuristic type
+        // operation, that has a meaning like unto "what a naive person would expect
+        // when modifying a table from an observe"
+        this._draining = false;
+    }
+    async runTask(task) {
+        return new Promise((resolve, reject) => {
+            var handle = {
+                task: task,
+                name: task.name,
+                runTaskResolve: resolve,
+                runTaskReject: reject
+            };
+            this._taskHandles.push(handle);
+            this._scheduleRun();
+            // Yield. We'll get back here after the task is run (and will throw if the
+            // task throws).
+        });
+    }
+    queueTask(task) {
+        var self = this;
+        self._taskHandles.push({
+            task: task,
+            name: task.name
+        });
+        self._scheduleRun();
+        // No need to block.
+    }
+    async flush() {
+        var self = this;
+        await self.runTask(async () => { });
+    }
+    async drain() {
+        var self = this;
+        if (self._draining)
+            return;
+        self._draining = true;
+        while (!self._taskHandles.isEmpty()) {
+            await self.flush();
+        }
+        self._draining = false;
+    }
+    ;
+    _scheduleRun() {
+        // Already running or scheduled? Do nothing.
+        if (this._runningOrRunScheduled)
+            return;
+        this._runningOrRunScheduled = true;
+        setImmediate(async () => {
+            await this._run();
+        });
+    }
+    ;
+    async _run() {
+        var self = this;
+        if (!self._runningOrRunScheduled)
+            throw new Error("expected to be _runningOrRunScheduled");
+        if (self._taskHandles.isEmpty()) {
+            // Done running tasks! Don't immediately schedule another run, but
+            // allow future tasks to do so.
+            self._runningOrRunScheduled = false;
+            return;
+        }
+        var taskHandle = self._taskHandles.shift();
+        // Run the task.
+        var exception = undefined;
+        try {
+            await taskHandle.task();
+        }
+        catch (err) {
+            if (taskHandle.runTaskReject) {
+                // We'll throw this exception through runTask.
+                exception = err;
+            }
+            else {
+                console.error("Exception in queued task", err);
+            }
+        }
+        // Soon, run the next task, if there is any.
+        self._runningOrRunScheduled = false;
+        self._scheduleRun();
+        // If this was queued with runTask, let the runTask call return (throwing if
+        // the task threw).
+        if (taskHandle.runTaskReject) {
+            if (exception)
+                taskHandle.runTaskReject(exception);
+            else
+                taskHandle.runTaskResolve();
+        }
+    }
+}
+exports._SynchronousQueue = _SynchronousQueue;

package/dist/meteor/ordered-dict/ordered_dict.d.ts

@@ -1,31 +1,31 @@
-export declare class OrderedDict {
-    static BREAK: {
-        break: boolean;
-    };
-    private _dict;
-    private _first;
-    private _last;
-    private _size;
-    private _stringify;
-    constructor(...args: any[]);
-    _k(key: any): string;
-    empty(): boolean;
-    get size(): number;
-    _linkEltIn(elt: any): void;
-    _linkEltOut(elt: any): void;
-    putBefore(key: any, item: any, before: any): void;
-    append(key: any, item: any): void;
-    delete(key: any): any;
-    get(key: any): any;
-    has(key: any): any;
-    forEach(iter: (doc: any, key: string, index: number) => any, context?: any): void;
-    first(): any;
-    firstValue(): any;
-    last(): any;
-    lastValue(): any;
-    prev(key: any): any;
-    next(key: any): any;
-    moveBefore(key: any, before: any): void;
-    indexOf(key: any): any;
-    _checkRep(): void;
-}
+export declare class OrderedDict {
+    static BREAK: {
+        break: boolean;
+    };
+    private _dict;
+    private _first;
+    private _last;
+    private _size;
+    private _stringify;
+    constructor(...args: any[]);
+    _k(key: any): string;
+    empty(): boolean;
+    get size(): number;
+    _linkEltIn(elt: any): void;
+    _linkEltOut(elt: any): void;
+    putBefore(key: any, item: any, before: any): void;
+    append(key: any, item: any): void;
+    delete(key: any): any;
+    get(key: any): any;
+    has(key: any): any;
+    forEach(iter: (doc: any, key: string, index: number) => any, context?: any): void;
+    first(): any;
+    firstValue(): any;
+    last(): any;
+    lastValue(): any;
+    prev(key: any): any;
+    next(key: any): any;
+    moveBefore(key: any, before: any): void;
+    indexOf(key: any): any;
+    _checkRep(): void;
+}