mongodb-livedata-server 0.1.3 → 0.1.4

package/dist/livedata_server.d.ts

@@ -1,4 +1,4 @@
-export { DDPServer } from "./meteor/ddp/livedata_server";
-export { ddpError } from "./meteor/ddp/livedata_server";
-export { LiveMongoConnection } from "./meteor/mongo/live_connection";
-export { LiveCursor } from "./meteor/mongo/live_cursor";
+export { DDPServer } from "./meteor/ddp/livedata_server";
+export { ddpError } from "./meteor/ddp/livedata_server";
+export { LiveMongoConnection } from "./meteor/mongo/live_connection";
+export { LiveCursor } from "./meteor/mongo/live_cursor";

package/dist/livedata_server.js

@@ -1,11 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LiveCursor = exports.LiveMongoConnection = exports.ddpError = exports.DDPServer = void 0;
-var livedata_server_1 = require("./meteor/ddp/livedata_server");
-Object.defineProperty(exports, "DDPServer", { enumerable: true, get: function () { return livedata_server_1.DDPServer; } });
-var livedata_server_2 = require("./meteor/ddp/livedata_server");
-Object.defineProperty(exports, "ddpError", { enumerable: true, get: function () { return livedata_server_2.ddpError; } });
-var live_connection_1 = require("./meteor/mongo/live_connection");
-Object.defineProperty(exports, "LiveMongoConnection", { enumerable: true, get: function () { return live_connection_1.LiveMongoConnection; } });
-var live_cursor_1 = require("./meteor/mongo/live_cursor");
-Object.defineProperty(exports, "LiveCursor", { enumerable: true, get: function () { return live_cursor_1.LiveCursor; } });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveCursor = exports.LiveMongoConnection = exports.ddpError = exports.DDPServer = void 0;
+var livedata_server_1 = require("./meteor/ddp/livedata_server");
+Object.defineProperty(exports, "DDPServer", { enumerable: true, get: function () { return livedata_server_1.DDPServer; } });
+var livedata_server_2 = require("./meteor/ddp/livedata_server");
+Object.defineProperty(exports, "ddpError", { enumerable: true, get: function () { return livedata_server_2.ddpError; } });
+var live_connection_1 = require("./meteor/mongo/live_connection");
+Object.defineProperty(exports, "LiveMongoConnection", { enumerable: true, get: function () { return live_connection_1.LiveMongoConnection; } });
+var live_cursor_1 = require("./meteor/mongo/live_cursor");
+Object.defineProperty(exports, "LiveCursor", { enumerable: true, get: function () { return live_cursor_1.LiveCursor; } });

package/dist/meteor/binary-heap/max_heap.d.ts

@@ -1,31 +1,31 @@
-export interface MaxHeapOptions {
-    initData?: {
-        id: string;
-        value: any;
-    }[];
-    IdMap?: any;
-}
-export declare class MaxHeap {
-    protected _comparator: (a: any, b: any) => number;
-    protected _heap: any[];
-    private _heapIdx;
-    constructor(comparator: (a: any, b: any) => number, options?: MaxHeapOptions);
-    _initFromData(data: any): void;
-    _downHeap(idx: any): void;
-    _upHeap(idx: any): void;
-    _maxIndex(idxA: any, idxB: any): any;
-    _get(idx: any): any;
-    _swap(idxA: any, idxB: any): void;
-    get(id: any): any;
-    set(id: any, value: any): void;
-    delete(id: any): void;
-    has(id: any): any;
-    empty(): boolean;
-    clear(): void;
-    forEach(iterator: any): void;
-    get size(): number;
-    setDefault(id: any, def: any): any;
-    clone(): MaxHeap;
-    maxElementId(): any;
-    _selfCheck(): void;
-}
+export interface MaxHeapOptions {
+    initData?: {
+        id: string;
+        value: any;
+    }[];
+    IdMap?: any;
+}
+export declare class MaxHeap {
+    protected _comparator: (a: any, b: any) => number;
+    protected _heap: any[];
+    private _heapIdx;
+    constructor(comparator: (a: any, b: any) => number, options?: MaxHeapOptions);
+    _initFromData(data: any): void;
+    _downHeap(idx: any): void;
+    _upHeap(idx: any): void;
+    _maxIndex(idxA: any, idxB: any): any;
+    _get(idx: any): any;
+    _swap(idxA: any, idxB: any): void;
+    get(id: any): any;
+    set(id: any, value: any): void;
+    delete(id: any): void;
+    has(id: any): any;
+    empty(): boolean;
+    clear(): void;
+    forEach(iterator: any): void;
+    get size(): number;
+    setDefault(id: any, def: any): any;
+    clone(): MaxHeap;
+    maxElementId(): any;
+    _selfCheck(): void;
+}

package/dist/meteor/binary-heap/max_heap.js

@@ -1,186 +1,186 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MaxHeap = void 0;
-// Constructor of Heap
-// - comparator - Function - given two items returns a number
-// - options:
-//   - initData - Array - Optional - the initial data in a format:
-//        Object:
-//          - id - String - unique id of the item
-//          - value - Any - the data value
-//      each value is retained
-//   - IdMap - Constructor - Optional - custom IdMap class to store id->index
-//       mappings internally. Standard IdMap is used by default.
-class MaxHeap {
-    constructor(comparator, options = {}) {
-        if (typeof comparator !== 'function') {
-            throw new Error('Passed comparator is invalid, should be a comparison function');
-        }
-        // a C-style comparator that is given two values and returns a number,
-        // negative if the first value is less than the second, positive if the second
-        // value is greater than the first and zero if they are equal.
-        this._comparator = comparator;
-        if (!options.IdMap) {
-            options.IdMap = Map;
-        }
-        // _heapIdx maps an id to an index in the Heap array the corresponding value
-        // is located on.
-        this._heapIdx = new options.IdMap;
-        // The Heap data-structure implemented as a 0-based contiguous array where
-        // every item on index idx is a node in a complete binary tree. Every node can
-        // have children on indexes idx*2+1 and idx*2+2, except for the leaves. Every
-        // node has a parent on index (idx-1)/2;
-        this._heap = [];
-        // If the initial array is passed, we can build the heap in linear time
-        // complexity (O(N)) compared to linearithmic time complexity (O(nlogn)) if
-        // we push elements one by one.
-        if (Array.isArray(options.initData)) {
-            this._initFromData(options.initData);
-        }
-    }
-    // Builds a new heap in-place in linear time based on passed data
-    _initFromData(data) {
-        this._heap = data.map(({ id, value }) => ({ id, value }));
-        data.forEach(({ id }, i) => this._heapIdx.set(id, i));
-        if (!data.length) {
-            return;
-        }
-        // start from the first non-leaf - the parent of the last leaf
-        for (let i = parentIdx(data.length - 1); i >= 0; i--) {
-            this._downHeap(i);
-        }
-    }
-    _downHeap(idx) {
-        while (leftChildIdx(idx) < this.size) {
-            const left = leftChildIdx(idx);
-            const right = rightChildIdx(idx);
-            let largest = idx;
-            if (left < this.size) {
-                largest = this._maxIndex(largest, left);
-            }
-            if (right < this.size) {
-                largest = this._maxIndex(largest, right);
-            }
-            if (largest === idx) {
-                break;
-            }
-            this._swap(largest, idx);
-            idx = largest;
-        }
-    }
-    _upHeap(idx) {
-        while (idx > 0) {
-            const parent = parentIdx(idx);
-            if (this._maxIndex(parent, idx) === idx) {
-                this._swap(parent, idx);
-                idx = parent;
-            }
-            else {
-                break;
-            }
-        }
-    }
-    _maxIndex(idxA, idxB) {
-        const valueA = this._get(idxA);
-        const valueB = this._get(idxB);
-        return this._comparator(valueA, valueB) >= 0 ? idxA : idxB;
-    }
-    // Internal: gets raw data object placed on idxth place in heap
-    _get(idx) {
-        return this._heap[idx].value;
-    }
-    _swap(idxA, idxB) {
-        const recA = this._heap[idxA];
-        const recB = this._heap[idxB];
-        this._heapIdx.set(recA.id, idxB);
-        this._heapIdx.set(recB.id, idxA);
-        this._heap[idxA] = recB;
-        this._heap[idxB] = recA;
-    }
-    get(id) {
-        return this.has(id) ?
-            this._get(this._heapIdx.get(id)) :
-            null;
-    }
-    set(id, value) {
-        if (this.has(id)) {
-            if (this.get(id) === value) {
-                return;
-            }
-            const idx = this._heapIdx.get(id);
-            this._heap[idx].value = value;
-            // Fix the new value's position
-            // Either bubble new value up if it is greater than its parent
-            this._upHeap(idx);
-            // or bubble it down if it is smaller than one of its children
-            this._downHeap(idx);
-        }
-        else {
-            this._heapIdx.set(id, this._heap.length);
-            this._heap.push({ id, value });
-            this._upHeap(this._heap.length - 1);
-        }
-    }
-    delete(id) {
-        if (this.has(id)) {
-            const last = this._heap.length - 1;
-            const idx = this._heapIdx.get(id);
-            if (idx !== last) {
-                this._swap(idx, last);
-                this._heap.pop();
-                this._heapIdx.remove(id);
-                // Fix the swapped value's position
-                this._upHeap(idx);
-                this._downHeap(idx);
-            }
-            else {
-                this._heap.pop();
-                this._heapIdx.remove(id);
-            }
-        }
-    }
-    has(id) {
-        return this._heapIdx.has(id);
-    }
-    empty() {
-        return this.size === 0;
-    }
-    clear() {
-        this._heap = [];
-        this._heapIdx.clear();
-    }
-    // iterate over values in no particular order
-    forEach(iterator) {
-        this._heap.forEach(obj => iterator(obj.value, obj.id));
-    }
-    get size() {
-        return this._heap.length;
-    }
-    setDefault(id, def) {
-        if (this.has(id)) {
-            return this.get(id);
-        }
-        this.set(id, def);
-        return def;
-    }
-    clone() {
-        const clone = new MaxHeap(this._comparator, { initData: this._heap });
-        return clone;
-    }
-    maxElementId() {
-        return this.size > 0 ? this._heap[0].id : null;
-    }
-    _selfCheck() {
-        for (let i = 1; i < this._heap.length; i++) {
-            if (this._maxIndex(parentIdx(i), i) !== parentIdx(i)) {
-                throw new Error(`An item with id ${this._heap[i].id}` +
-                    " has a parent younger than it: " +
-                    this._heap[parentIdx(i)].id);
-            }
-        }
-    }
-}
-exports.MaxHeap = MaxHeap;
-const leftChildIdx = i => i * 2 + 1;
-const rightChildIdx = i => i * 2 + 2;
-const parentIdx = i => (i - 1) >> 1;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaxHeap = void 0;
+// Constructor of Heap
+// - comparator - Function - given two items returns a number
+// - options:
+//   - initData - Array - Optional - the initial data in a format:
+//        Object:
+//          - id - String - unique id of the item
+//          - value - Any - the data value
+//      each value is retained
+//   - IdMap - Constructor - Optional - custom IdMap class to store id->index
+//       mappings internally. Standard IdMap is used by default.
+class MaxHeap {
+    constructor(comparator, options = {}) {
+        if (typeof comparator !== 'function') {
+            throw new Error('Passed comparator is invalid, should be a comparison function');
+        }
+        // a C-style comparator that is given two values and returns a number,
+        // negative if the first value is less than the second, positive if the second
+        // value is greater than the first and zero if they are equal.
+        this._comparator = comparator;
+        if (!options.IdMap) {
+            options.IdMap = Map;
+        }
+        // _heapIdx maps an id to an index in the Heap array the corresponding value
+        // is located on.
+        this._heapIdx = new options.IdMap;
+        // The Heap data-structure implemented as a 0-based contiguous array where
+        // every item on index idx is a node in a complete binary tree. Every node can
+        // have children on indexes idx*2+1 and idx*2+2, except for the leaves. Every
+        // node has a parent on index (idx-1)/2;
+        this._heap = [];
+        // If the initial array is passed, we can build the heap in linear time
+        // complexity (O(N)) compared to linearithmic time complexity (O(nlogn)) if
+        // we push elements one by one.
+        if (Array.isArray(options.initData)) {
+            this._initFromData(options.initData);
+        }
+    }
+    // Builds a new heap in-place in linear time based on passed data
+    _initFromData(data) {
+        this._heap = data.map(({ id, value }) => ({ id, value }));
+        data.forEach(({ id }, i) => this._heapIdx.set(id, i));
+        if (!data.length) {
+            return;
+        }
+        // start from the first non-leaf - the parent of the last leaf
+        for (let i = parentIdx(data.length - 1); i >= 0; i--) {
+            this._downHeap(i);
+        }
+    }
+    _downHeap(idx) {
+        while (leftChildIdx(idx) < this.size) {
+            const left = leftChildIdx(idx);
+            const right = rightChildIdx(idx);
+            let largest = idx;
+            if (left < this.size) {
+                largest = this._maxIndex(largest, left);
+            }
+            if (right < this.size) {
+                largest = this._maxIndex(largest, right);
+            }
+            if (largest === idx) {
+                break;
+            }
+            this._swap(largest, idx);
+            idx = largest;
+        }
+    }
+    _upHeap(idx) {
+        while (idx > 0) {
+            const parent = parentIdx(idx);
+            if (this._maxIndex(parent, idx) === idx) {
+                this._swap(parent, idx);
+                idx = parent;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    _maxIndex(idxA, idxB) {
+        const valueA = this._get(idxA);
+        const valueB = this._get(idxB);
+        return this._comparator(valueA, valueB) >= 0 ? idxA : idxB;
+    }
+    // Internal: gets raw data object placed on idxth place in heap
+    _get(idx) {
+        return this._heap[idx].value;
+    }
+    _swap(idxA, idxB) {
+        const recA = this._heap[idxA];
+        const recB = this._heap[idxB];
+        this._heapIdx.set(recA.id, idxB);
+        this._heapIdx.set(recB.id, idxA);
+        this._heap[idxA] = recB;
+        this._heap[idxB] = recA;
+    }
+    get(id) {
+        return this.has(id) ?
+            this._get(this._heapIdx.get(id)) :
+            null;
+    }
+    set(id, value) {
+        if (this.has(id)) {
+            if (this.get(id) === value) {
+                return;
+            }
+            const idx = this._heapIdx.get(id);
+            this._heap[idx].value = value;
+            // Fix the new value's position
+            // Either bubble new value up if it is greater than its parent
+            this._upHeap(idx);
+            // or bubble it down if it is smaller than one of its children
+            this._downHeap(idx);
+        }
+        else {
+            this._heapIdx.set(id, this._heap.length);
+            this._heap.push({ id, value });
+            this._upHeap(this._heap.length - 1);
+        }
+    }
+    delete(id) {
+        if (this.has(id)) {
+            const last = this._heap.length - 1;
+            const idx = this._heapIdx.get(id);
+            if (idx !== last) {
+                this._swap(idx, last);
+                this._heap.pop();
+                this._heapIdx.remove(id);
+                // Fix the swapped value's position
+                this._upHeap(idx);
+                this._downHeap(idx);
+            }
+            else {
+                this._heap.pop();
+                this._heapIdx.remove(id);
+            }
+        }
+    }
+    has(id) {
+        return this._heapIdx.has(id);
+    }
+    empty() {
+        return this.size === 0;
+    }
+    clear() {
+        this._heap = [];
+        this._heapIdx.clear();
+    }
+    // iterate over values in no particular order
+    forEach(iterator) {
+        this._heap.forEach(obj => iterator(obj.value, obj.id));
+    }
+    get size() {
+        return this._heap.length;
+    }
+    setDefault(id, def) {
+        if (this.has(id)) {
+            return this.get(id);
+        }
+        this.set(id, def);
+        return def;
+    }
+    clone() {
+        const clone = new MaxHeap(this._comparator, { initData: this._heap });
+        return clone;
+    }
+    maxElementId() {
+        return this.size > 0 ? this._heap[0].id : null;
+    }
+    _selfCheck() {
+        for (let i = 1; i < this._heap.length; i++) {
+            if (this._maxIndex(parentIdx(i), i) !== parentIdx(i)) {
+                throw new Error(`An item with id ${this._heap[i].id}` +
+                    " has a parent younger than it: " +
+                    this._heap[parentIdx(i)].id);
+            }
+        }
+    }
+}
+exports.MaxHeap = MaxHeap;
+const leftChildIdx = i => i * 2 + 1;
+const rightChildIdx = i => i * 2 + 2;
+const parentIdx = i => (i - 1) >> 1;

package/dist/meteor/binary-heap/min_heap.d.ts

@@ -1,6 +1,6 @@
-import { MaxHeap, MaxHeapOptions } from './max_heap';
-export declare class MinHeap extends MaxHeap {
-    constructor(comparator: any, options?: MaxHeapOptions);
-    maxElementId(): void;
-    minElementId(): any;
-}
+import { MaxHeap, MaxHeapOptions } from './max_heap';
+export declare class MinHeap extends MaxHeap {
+    constructor(comparator: any, options?: MaxHeapOptions);
+    maxElementId(): void;
+    minElementId(): any;
+}

package/dist/meteor/binary-heap/min_heap.js

@@ -1,17 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MinHeap = void 0;
-const max_heap_1 = require("./max_heap");
-class MinHeap extends max_heap_1.MaxHeap {
-    constructor(comparator, options) {
-        super((a, b) => -comparator(a, b), options);
-    }
-    maxElementId() {
-        throw new Error("Cannot call maxElementId on MinHeap");
-    }
-    minElementId() {
-        return super.maxElementId();
-    }
-}
-exports.MinHeap = MinHeap;
-;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MinHeap = void 0;
+const max_heap_1 = require("./max_heap");
+class MinHeap extends max_heap_1.MaxHeap {
+    constructor(comparator, options) {
+        super((a, b) => -comparator(a, b), options);
+    }
+    maxElementId() {
+        throw new Error("Cannot call maxElementId on MinHeap");
+    }
+    minElementId() {
+        return super.maxElementId();
+    }
+}
+exports.MinHeap = MinHeap;
+;

package/dist/meteor/binary-heap/min_max_heap.d.ts

@@ -1,11 +1,11 @@
-import { MaxHeap, MaxHeapOptions } from './max_heap';
-export declare class MinMaxHeap extends MaxHeap {
-    private _minHeap;
-    constructor(comparator: any, options?: MaxHeapOptions);
-    set(id: string, value: any): void;
-    delete(id: string): void;
-    clear(): void;
-    setDefault(id: string, def: any): any;
-    clone(): MinMaxHeap;
-    minElementId(): any;
-}
+import { MaxHeap, MaxHeapOptions } from './max_heap';
+export declare class MinMaxHeap extends MaxHeap {
+    private _minHeap;
+    constructor(comparator: any, options?: MaxHeapOptions);
+    set(id: string, value: any): void;
+    delete(id: string): void;
+    clear(): void;
+    setDefault(id: string, def: any): any;
+    clone(): MinMaxHeap;
+    minElementId(): any;
+}

package/dist/meteor/binary-heap/min_max_heap.js

@@ -1,48 +1,48 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MinMaxHeap = void 0;
-const max_heap_1 = require("./max_heap");
-const min_heap_1 = require("./min_heap");
-// This implementation of Min/Max-Heap is just a subclass of Max-Heap
-// with a Min-Heap as an encapsulated property.
-//
-// Most of the operations are just proxy methods to call the same method on both
-// heaps.
-//
-// This implementation takes 2*N memory but is fairly simple to write and
-// understand. And the constant factor of a simple Heap is usually smaller
-// compared to other two-way priority queues like Min/Max Heaps
-// (http://www.cs.otago.ac.nz/staffpriv/mike/Papers/MinMaxHeaps/MinMaxHeaps.pdf)
-// and Interval Heaps
-// (http://www.cise.ufl.edu/~sahni/dsaac/enrich/c13/double.htm)
-class MinMaxHeap extends max_heap_1.MaxHeap {
-    constructor(comparator, options) {
-        super(comparator, options);
-        this._minHeap = new min_heap_1.MinHeap(comparator, options);
-    }
-    set(id, value) {
-        super.set(id, value);
-        this._minHeap.set(id, value);
-    }
-    delete(id) {
-        super.delete(id);
-        this._minHeap.delete(id);
-    }
-    clear() {
-        super.clear();
-        this._minHeap.clear();
-    }
-    setDefault(id, def) {
-        super.setDefault(id, def);
-        return this._minHeap.setDefault(id, def);
-    }
-    clone() {
-        const clone = new MinMaxHeap(this._comparator, { initData: this._heap });
-        return clone;
-    }
-    minElementId() {
-        return this._minHeap.minElementId();
-    }
-}
-exports.MinMaxHeap = MinMaxHeap;
-;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MinMaxHeap = void 0;
+const max_heap_1 = require("./max_heap");
+const min_heap_1 = require("./min_heap");
+// This implementation of Min/Max-Heap is just a subclass of Max-Heap
+// with a Min-Heap as an encapsulated property.
+//
+// Most of the operations are just proxy methods to call the same method on both
+// heaps.
+//
+// This implementation takes 2*N memory but is fairly simple to write and
+// understand. And the constant factor of a simple Heap is usually smaller
+// compared to other two-way priority queues like Min/Max Heaps
+// (http://www.cs.otago.ac.nz/staffpriv/mike/Papers/MinMaxHeaps/MinMaxHeaps.pdf)
+// and Interval Heaps
+// (http://www.cise.ufl.edu/~sahni/dsaac/enrich/c13/double.htm)
+class MinMaxHeap extends max_heap_1.MaxHeap {
+    constructor(comparator, options) {
+        super(comparator, options);
+        this._minHeap = new min_heap_1.MinHeap(comparator, options);
+    }
+    set(id, value) {
+        super.set(id, value);
+        this._minHeap.set(id, value);
+    }
+    delete(id) {
+        super.delete(id);
+        this._minHeap.delete(id);
+    }
+    clear() {
+        super.clear();
+        this._minHeap.clear();
+    }
+    setDefault(id, def) {
+        super.setDefault(id, def);
+        return this._minHeap.setDefault(id, def);
+    }
+    clone() {
+        const clone = new MinMaxHeap(this._comparator, { initData: this._heap });
+        return clone;
+    }
+    minElementId() {
+        return this._minHeap.minElementId();
+    }
+}
+exports.MinMaxHeap = MinMaxHeap;
+;

package/dist/meteor/callback-hook/hook.d.ts

@@ -1,11 +1,11 @@
-export declare class Hook {
-    private nextCallbackId;
-    private callbacks;
-    private exceptionHandler;
-    constructor(options?: any);
-    register(callback: any): {
-        callback: any;
-        stop: () => void;
-    };
-    each(iterator: (callback: Function) => boolean): void;
-}
+export declare class Hook {
+    private nextCallbackId;
+    private callbacks;
+    private exceptionHandler;
+    constructor(options?: any);
+    register(callback: any): {
+        callback: any;
+        stop: () => void;
+    };
+    each(iterator: (callback: Function) => boolean): void;
+}