mongodb-livedata-server 0.1.2 → 0.1.4

package/dist/meteor/ddp/utils.d.ts

@@ -1,8 +1,8 @@
-export declare const hasOwn: (v: PropertyKey) => boolean;
-export declare const slice: (start?: number, end?: number) => any[];
-export declare function keys(obj: any): string[];
-export declare function isEmpty(obj: any): boolean;
-export declare function last(array: any, n: any, guard: any): any;
-export declare const SUPPORTED_DDP_VERSIONS: string[];
-export declare function parseDDP(stringMessage: string): any;
-export declare function stringifyDDP(msg: any): string;
+export declare const hasOwn: (v: PropertyKey) => boolean;
+export declare const slice: (start?: number, end?: number) => any[];
+export declare function keys(obj: any): string[];
+export declare function isEmpty(obj: any): boolean;
+export declare function last(array: any, n: any, guard: any): any;
+export declare const SUPPORTED_DDP_VERSIONS: string[];
+export declare function parseDDP(stringMessage: string): any;
+export declare function stringifyDDP(msg: any): string;

package/dist/meteor/ddp/utils.js

@@ -1,104 +1,104 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringifyDDP = exports.parseDDP = exports.SUPPORTED_DDP_VERSIONS = exports.last = exports.isEmpty = exports.keys = exports.slice = exports.hasOwn = void 0;
-const ejson_1 = require("../ejson/ejson");
-exports.hasOwn = Object.prototype.hasOwnProperty;
-exports.slice = Array.prototype.slice;
-function keys(obj) {
-    return Object.keys(Object(obj));
-}
-exports.keys = keys;
-function isEmpty(obj) {
-    if (obj == null) {
-        return true;
-    }
-    if (Array.isArray(obj) ||
-        typeof obj === "string") {
-        return obj.length === 0;
-    }
-    for (const key in obj) {
-        if (exports.hasOwn.call(obj, key)) {
-            return false;
-        }
-    }
-    return true;
-}
-exports.isEmpty = isEmpty;
-function last(array, n, guard) {
-    if (array == null) {
-        return;
-    }
-    if ((n == null) || guard) {
-        return array[array.length - 1];
-    }
-    return exports.slice.call(array, Math.max(array.length - n, 0));
-}
-exports.last = last;
-exports.SUPPORTED_DDP_VERSIONS = ['1a', '1', 'pre2', 'pre1'];
-function parseDDP(stringMessage) {
-    try {
-        var msg = JSON.parse(stringMessage);
-    }
-    catch (e) {
-        console.log("Discarding message with invalid JSON", stringMessage);
-        return null;
-    }
-    // DDP messages must be objects.
-    if (msg === null || typeof msg !== 'object') {
-        console.log("Discarding non-object DDP message", stringMessage);
-        return null;
-    }
-    // massage msg to get it into "abstract ddp" rather than "wire ddp" format.
-    // switch between "cleared" rep of unsetting fields and "undefined"
-    // rep of same
-    if (exports.hasOwn.call(msg, 'cleared')) {
-        if (!exports.hasOwn.call(msg, 'fields')) {
-            msg.fields = {};
-        }
-        msg.cleared.forEach(clearKey => {
-            msg.fields[clearKey] = undefined;
-        });
-        delete msg.cleared;
-    }
-    ['fields', 'params', 'result'].forEach(field => {
-        if (exports.hasOwn.call(msg, field)) {
-            msg[field] = (0, ejson_1._adjustTypesFromJSONValue)(msg[field]);
-        }
-    });
-    return msg;
-}
-exports.parseDDP = parseDDP;
-;
-function stringifyDDP(msg) {
-    const copy = (0, ejson_1.clone)(msg);
-    // swizzle 'changed' messages from 'fields undefined' rep to 'fields
-    // and cleared' rep
-    if (exports.hasOwn.call(msg, 'fields')) {
-        const cleared = [];
-        Object.keys(msg.fields).forEach(key => {
-            const value = msg.fields[key];
-            if (typeof value === "undefined") {
-                cleared.push(key);
-                delete copy.fields[key];
-            }
-        });
-        if (!isEmpty(cleared)) {
-            copy.cleared = cleared;
-        }
-        if (isEmpty(copy.fields)) {
-            delete copy.fields;
-        }
-    }
-    // adjust types to basic
-    ['fields', 'params', 'result'].forEach(field => {
-        if (exports.hasOwn.call(copy, field)) {
-            copy[field] = (0, ejson_1._adjustTypesToJSONValue)(copy[field]);
-        }
-    });
-    if (msg.id && typeof msg.id !== 'string') {
-        throw new Error("Message id is not a string");
-    }
-    return JSON.stringify(copy);
-}
-exports.stringifyDDP = stringifyDDP;
-;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUPPORTED_DDP_VERSIONS = exports.slice = exports.hasOwn = void 0;
+exports.keys = keys;
+exports.isEmpty = isEmpty;
+exports.last = last;
+exports.parseDDP = parseDDP;
+exports.stringifyDDP = stringifyDDP;
+const ejson_1 = require("../ejson/ejson");
+exports.hasOwn = Object.prototype.hasOwnProperty;
+exports.slice = Array.prototype.slice;
+function keys(obj) {
+    return Object.keys(Object(obj));
+}
+function isEmpty(obj) {
+    if (obj == null) {
+        return true;
+    }
+    if (Array.isArray(obj) ||
+        typeof obj === "string") {
+        return obj.length === 0;
+    }
+    for (const key in obj) {
+        if (exports.hasOwn.call(obj, key)) {
+            return false;
+        }
+    }
+    return true;
+}
+function last(array, n, guard) {
+    if (array == null) {
+        return;
+    }
+    if ((n == null) || guard) {
+        return array[array.length - 1];
+    }
+    return exports.slice.call(array, Math.max(array.length - n, 0));
+}
+exports.SUPPORTED_DDP_VERSIONS = ['1a', '1', 'pre2', 'pre1'];
+function parseDDP(stringMessage) {
+    try {
+        var msg = JSON.parse(stringMessage);
+    }
+    catch (e) {
+        console.log("Discarding message with invalid JSON", stringMessage, '\r\n' + e.toString());
+        return null;
+    }
+    // DDP messages must be objects.
+    if (msg === null || typeof msg !== 'object') {
+        console.log("Discarding non-object DDP message", stringMessage);
+        return null;
+    }
+    // massage msg to get it into "abstract ddp" rather than "wire ddp" format.
+    // switch between "cleared" rep of unsetting fields and "undefined"
+    // rep of same
+    if (exports.hasOwn.call(msg, 'cleared')) {
+        if (!exports.hasOwn.call(msg, 'fields')) {
+            msg.fields = {};
+        }
+        msg.cleared.forEach(clearKey => {
+            msg.fields[clearKey] = undefined;
+        });
+        delete msg.cleared;
+    }
+    ['fields', 'params', 'result'].forEach(field => {
+        if (exports.hasOwn.call(msg, field)) {
+            msg[field] = (0, ejson_1._adjustTypesFromJSONValue)(msg[field]);
+        }
+    });
+    return msg;
+}
+;
+function stringifyDDP(msg) {
+    const copy = (0, ejson_1.clone)(msg);
+    // swizzle 'changed' messages from 'fields undefined' rep to 'fields
+    // and cleared' rep
+    if (exports.hasOwn.call(msg, 'fields')) {
+        const cleared = [];
+        Object.keys(msg.fields).forEach(key => {
+            const value = msg.fields[key];
+            if (typeof value === "undefined") {
+                cleared.push(key);
+                delete copy.fields[key];
+            }
+        });
+        if (!isEmpty(cleared)) {
+            copy.cleared = cleared;
+        }
+        if (isEmpty(copy.fields)) {
+            delete copy.fields;
+        }
+    }
+    // adjust types to basic
+    ['fields', 'params', 'result'].forEach(field => {
+        if (exports.hasOwn.call(copy, field)) {
+            copy[field] = (0, ejson_1._adjustTypesToJSONValue)(copy[field]);
+        }
+    });
+    if (msg.id && typeof msg.id !== 'string') {
+        throw new Error("Message id is not a string");
+    }
+    return JSON.stringify(copy);
+}
+;

package/dist/meteor/ddp/writefence.d.ts

@@ -1,20 +1,20 @@
-import { OplogObserveDriver } from "../mongo/oplog-observe-driver";
-export declare class _WriteFence {
-    fired: boolean;
-    _oplogObserveDrivers: Record<string, OplogObserveDriver>;
-    private armed;
-    private retired;
-    private outstanding_writes;
-    private before_fire_callbacks;
-    private completion_callbacks;
-    constructor();
-    static _CurrentWriteFence: _WriteFence;
-    beginWrite(): {
-        committed: () => void;
-    };
-    arm(): void;
-    onBeforeFire(func: any): void;
-    onAllCommitted(func: any): void;
-    _maybeFire(): void;
-    retire(): void;
-}
+import { OplogObserveDriver } from "../mongo/oplog-observe-driver";
+export declare class _WriteFence {
+    fired: boolean;
+    _oplogObserveDrivers: Record<string, OplogObserveDriver>;
+    private armed;
+    private retired;
+    private outstanding_writes;
+    private before_fire_callbacks;
+    private completion_callbacks;
+    constructor();
+    static _CurrentWriteFence: _WriteFence;
+    beginWrite(): {
+        committed: () => void;
+    };
+    arm(): void;
+    onBeforeFire(func: any): void;
+    onAllCommitted(func: any): void;
+    _maybeFire(): void;
+    retire(): void;
+}

package/dist/meteor/ddp/writefence.js

@@ -1,111 +1,111 @@
-"use strict";
-// A write fence collects a group of writes, and provides a callback
-// when all of the writes are fully committed and propagated (all
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._WriteFence = void 0;
-// observers have been notified of the write and acknowledged it.)
-class _WriteFence {
-    constructor() {
-        this.armed = false;
-        this.fired = false;
-        this.retired = false;
-        this.outstanding_writes = 0;
-        this.before_fire_callbacks = [];
-        this.completion_callbacks = [];
-    }
-    ;
-    // Start tracking a write, and return an object to represent it. The
-    // object has a single method, committed(). This method should be
-    // called when the write is fully committed and propagated. You can
-    // continue to add writes to the WriteFence up until it is triggered
-    // (calls its callbacks because all writes have committed.)
-    beginWrite() {
-        var self = this;
-        if (self.retired)
-            return { committed: function () { } };
-        if (self.fired)
-            throw new Error("fence has already activated -- too late to add writes");
-        self.outstanding_writes++;
-        var committed = false;
-        return {
-            committed: function () {
-                if (committed)
-                    throw new Error("committed called twice on the same write");
-                committed = true;
-                self.outstanding_writes--;
-                self._maybeFire();
-            }
-        };
-    }
-    // Arm the fence. Once the fence is armed, and there are no more
-    // uncommitted writes, it will activate.
-    arm() {
-        var self = this;
-        if (self === _WriteFence._CurrentWriteFence)
-            throw Error("Can't arm the current fence");
-        self.armed = true;
-        self._maybeFire();
-    }
-    // Register a function to be called once before firing the fence.
-    // Callback function can add new writes to the fence, in which case
-    // it won't fire until those writes are done as well.
-    onBeforeFire(func) {
-        var self = this;
-        if (self.fired)
-            throw new Error("fence has already activated -- too late to " +
-                "add a callback");
-        self.before_fire_callbacks.push(func);
-    }
-    // Register a function to be called when the fence fires.
-    onAllCommitted(func) {
-        var self = this;
-        if (self.fired)
-            throw new Error("fence has already activated -- too late to " +
-                "add a callback");
-        self.completion_callbacks.push(func);
-    }
-    _maybeFire() {
-        var self = this;
-        if (self.fired)
-            throw new Error("write fence already activated?");
-        if (self.armed && !self.outstanding_writes) {
-            self.outstanding_writes++;
-            while (self.before_fire_callbacks.length > 0) {
-                var callbacks = self.before_fire_callbacks;
-                self.before_fire_callbacks = [];
-                for (const callback of callbacks)
-                    invokeCallback(callback, self);
-            }
-            self.outstanding_writes--;
-            if (!self.outstanding_writes) {
-                self.fired = true;
-                var callbacks = self.completion_callbacks;
-                self.completion_callbacks = [];
-                for (const callback of callbacks)
-                    invokeCallback(callback, self);
-            }
-        }
-    }
-    // Deactivate this fence so that adding more writes has no effect.
-    // The fence must have already fired.
-    retire() {
-        var self = this;
-        if (!self.fired)
-            throw new Error("Can't retire a fence that hasn't fired.");
-        self.retired = true;
-    }
-}
-exports._WriteFence = _WriteFence;
-// The current write fence. When there is a current write fence, code
-// that writes to databases should register their writes with it using
-// beginWrite().
-//
-_WriteFence._CurrentWriteFence = new _WriteFence();
-function invokeCallback(func, self) {
-    try {
-        func(self);
-    }
-    catch (err) {
-        console.error("exception in write fence callback", err);
-    }
-}
+"use strict";
+// A write fence collects a group of writes, and provides a callback
+// when all of the writes are fully committed and propagated (all
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._WriteFence = void 0;
+// observers have been notified of the write and acknowledged it.)
+class _WriteFence {
+    constructor() {
+        this.armed = false;
+        this.fired = false;
+        this.retired = false;
+        this.outstanding_writes = 0;
+        this.before_fire_callbacks = [];
+        this.completion_callbacks = [];
+    }
+    ;
+    // Start tracking a write, and return an object to represent it. The
+    // object has a single method, committed(). This method should be
+    // called when the write is fully committed and propagated. You can
+    // continue to add writes to the WriteFence up until it is triggered
+    // (calls its callbacks because all writes have committed.)
+    beginWrite() {
+        var self = this;
+        if (self.retired)
+            return { committed: function () { } };
+        if (self.fired)
+            throw new Error("fence has already activated -- too late to add writes");
+        self.outstanding_writes++;
+        var committed = false;
+        return {
+            committed: function () {
+                if (committed)
+                    throw new Error("committed called twice on the same write");
+                committed = true;
+                self.outstanding_writes--;
+                self._maybeFire();
+            }
+        };
+    }
+    // Arm the fence. Once the fence is armed, and there are no more
+    // uncommitted writes, it will activate.
+    arm() {
+        var self = this;
+        if (self === _WriteFence._CurrentWriteFence)
+            throw Error("Can't arm the current fence");
+        self.armed = true;
+        self._maybeFire();
+    }
+    // Register a function to be called once before firing the fence.
+    // Callback function can add new writes to the fence, in which case
+    // it won't fire until those writes are done as well.
+    onBeforeFire(func) {
+        var self = this;
+        if (self.fired)
+            throw new Error("fence has already activated -- too late to " +
+                "add a callback");
+        self.before_fire_callbacks.push(func);
+    }
+    // Register a function to be called when the fence fires.
+    onAllCommitted(func) {
+        var self = this;
+        if (self.fired)
+            throw new Error("fence has already activated -- too late to " +
+                "add a callback");
+        self.completion_callbacks.push(func);
+    }
+    _maybeFire() {
+        var self = this;
+        if (self.fired)
+            throw new Error("write fence already activated?");
+        if (self.armed && !self.outstanding_writes) {
+            self.outstanding_writes++;
+            while (self.before_fire_callbacks.length > 0) {
+                var callbacks = self.before_fire_callbacks;
+                self.before_fire_callbacks = [];
+                for (const callback of callbacks)
+                    invokeCallback(callback, self);
+            }
+            self.outstanding_writes--;
+            if (!self.outstanding_writes) {
+                self.fired = true;
+                var callbacks = self.completion_callbacks;
+                self.completion_callbacks = [];
+                for (const callback of callbacks)
+                    invokeCallback(callback, self);
+            }
+        }
+    }
+    // Deactivate this fence so that adding more writes has no effect.
+    // The fence must have already fired.
+    retire() {
+        var self = this;
+        if (!self.fired)
+            throw new Error("Can't retire a fence that hasn't fired.");
+        self.retired = true;
+    }
+}
+exports._WriteFence = _WriteFence;
+// The current write fence. When there is a current write fence, code
+// that writes to databases should register their writes with it using
+// beginWrite().
+//
+_WriteFence._CurrentWriteFence = new _WriteFence();
+function invokeCallback(func, self) {
+    try {
+        func(self);
+    }
+    catch (err) {
+        console.error("exception in write fence callback", err);
+    }
+}

package/dist/meteor/diff-sequence/diff.d.ts

@@ -1,17 +1,17 @@
-interface DiffCallbacks {
-    both: (key: string, left: any, right: any) => void;
-    leftOnly: (key: string, value: any) => void;
-    rightOnly: (key: string, value: any) => void;
-}
-interface DiffSequence {
-    diffQueryChanges(ordered: boolean, oldResults: any[], newResults: any[], observer: any, options?: any): any;
-    diffQueryChanges(ordered: boolean, oldResults: Map<string, any>, newResults: Map<string, any>, observer: any, options?: any): any;
-    diffQueryUnorderedChanges(oldResults: any, newResults: any, observer: any, options?: any): any;
-    diffQueryOrderedChanges(old_results: any, new_results: any, observer: any, options?: any): any;
-    diffObjects(left: Record<string, any>, right: Record<string, any>, callbacks: DiffCallbacks): any;
-    diffMaps(left: Map<string, any>, right: Map<string, any>, callbacks: DiffCallbacks): any;
-    makeChangedFields(newDoc: Record<string, any>, oldDoc: Record<string, any>): any;
-    applyChanges(doc: Record<string, any>, changeFields: Record<string, any>): void;
-}
-export declare const DiffSequence: DiffSequence;
-export {};
+interface DiffCallbacks {
+    both: (key: string, left: any, right: any) => void;
+    leftOnly: (key: string, value: any) => void;
+    rightOnly: (key: string, value: any) => void;
+}
+interface DiffSequence {
+    diffQueryChanges(ordered: boolean, oldResults: any[], newResults: any[], observer: any, options?: any): any;
+    diffQueryChanges(ordered: boolean, oldResults: Map<string, any>, newResults: Map<string, any>, observer: any, options?: any): any;
+    diffQueryUnorderedChanges(oldResults: any, newResults: any, observer: any, options?: any): any;
+    diffQueryOrderedChanges(old_results: any, new_results: any, observer: any, options?: any): any;
+    diffObjects(left: Record<string, any>, right: Record<string, any>, callbacks: DiffCallbacks): any;
+    diffMaps(left: Map<string, any>, right: Map<string, any>, callbacks: DiffCallbacks): any;
+    makeChangedFields(newDoc: Record<string, any>, oldDoc: Record<string, any>): any;
+    applyChanges(doc: Record<string, any>, changeFields: Record<string, any>): void;
+}
+export declare const DiffSequence: DiffSequence;
+export {};