mongodb-livedata-server 0.1.2 → 0.1.4

package/dist/meteor/ddp/method-invocation.d.ts

@@ -1,35 +1,35 @@
-import { SessionConnectionHandle } from "./session";
-interface MethodInvocationOptions {
-    isSimulation: boolean;
-    isFromCallAsync?: boolean;
-    userId: string;
-    setUserId: (userId: string) => void;
-    connection: SessionConnectionHandle;
-    randomSeed: number;
-}
-/**
- * @summary The state for a single invocation of a method, referenced by this
- * inside a method definition.
- * @param {Object} options
- * @instanceName this
- * @showInstanceName true
- */
-export declare class MethodInvocation {
-    userId: string;
-    connection: SessionConnectionHandle;
-    private isSimulation;
-    private _isFromCallAsync;
-    private _setUserId;
-    private randomSeed;
-    private randomStream;
-    constructor(options: MethodInvocationOptions);
-    /**
-     * @summary Set the logged in user.
-     * @locus Server
-     * @memberOf DDPCommon.MethodInvocation
-     * @instance
-     * @param {String | null} userId The value that should be returned by `userId` on this connection.
-     */
-    setUserId(userId: string | null): void;
-}
-export {};
+import { SessionConnectionHandle } from "./session";
+interface MethodInvocationOptions {
+    isSimulation: boolean;
+    isFromCallAsync?: boolean;
+    userId: string;
+    setUserId: (userId: string) => void;
+    connection: SessionConnectionHandle;
+    randomSeed: number;
+}
+/**
+ * @summary The state for a single invocation of a method, referenced by this
+ * inside a method definition.
+ * @param {Object} options
+ * @instanceName this
+ * @showInstanceName true
+ */
+export declare class MethodInvocation {
+    userId: string;
+    connection: SessionConnectionHandle;
+    private isSimulation;
+    private _isFromCallAsync;
+    private _setUserId;
+    private randomSeed;
+    private randomStream;
+    constructor(options: MethodInvocationOptions);
+    /**
+     * @summary Set the logged in user.
+     * @locus Server
+     * @memberOf DDPCommon.MethodInvocation
+     * @instance
+     * @param {String | null} userId The value that should be returned by `userId` on this connection.
+     */
+    setUserId(userId: string | null): void;
+}
+export {};

package/dist/meteor/ddp/method-invocation.js

@@ -1,72 +1,72 @@
-"use strict";
-// Instance name is this because it is usually referred to as this inside a
-// method definition
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MethodInvocation = void 0;
-/**
- * @summary The state for a single invocation of a method, referenced by this
- * inside a method definition.
- * @param {Object} options
- * @instanceName this
- * @showInstanceName true
- */
-class MethodInvocation {
-    constructor(options) {
-        // true if we're running not the actual method, but a stub (that is,
-        // if we're on a client (which may be a browser, or in the future a
-        // server connecting to another server) and presently running a
-        // simulation of a server-side method for latency compensation
-        // purposes). not currently true except in a client such as a browser,
-        // since there's usually no point in running stubs unless you have a
-        // zero-latency connection to the user.
-        /**
-         * @summary Access inside a method invocation.  Boolean value, true if this invocation is a stub.
-         * @locus Anywhere
-         * @name  isSimulation
-         * @memberOf DDPCommon.MethodInvocation
-         * @instance
-         * @type {Boolean}
-         */
-        this.isSimulation = options.isSimulation;
-        // used to know when the function apply was called by callAsync
-        this._isFromCallAsync = options.isFromCallAsync;
-        // current user id
-        /**
-         * @summary The id of the user that made this method call, or `null` if no user was logged in.
-         * @locus Anywhere
-         * @name  userId
-         * @memberOf DDPCommon.MethodInvocation
-         * @instance
-         */
-        this.userId = options.userId;
-        // sets current user id in all appropriate server contexts and
-        // reruns subscriptions
-        this._setUserId = options.setUserId || function () { };
-        // On the server, the connection this method call came in on.
-        /**
-         * @summary Access inside a method invocation. The [connection](#meteor_onconnection) that this method was received on. `null` if the method is not associated with a connection, eg. a server initiated method call. Calls to methods made from a server method which was in turn initiated from the client share the same `connection`.
-         * @locus Server
-         * @name  connection
-         * @memberOf DDPCommon.MethodInvocation
-         * @instance
-         */
-        this.connection = options.connection;
-        // The seed for randomStream value generation
-        this.randomSeed = options.randomSeed;
-        // This is set by RandomStream.get; and holds the random stream state
-        this.randomStream = null;
-    }
-    /**
-     * @summary Set the logged in user.
-     * @locus Server
-     * @memberOf DDPCommon.MethodInvocation
-     * @instance
-     * @param {String | null} userId The value that should be returned by `userId` on this connection.
-     */
-    setUserId(userId) {
-        this.userId = userId;
-        this._setUserId(userId);
-    }
-}
-exports.MethodInvocation = MethodInvocation;
-;
+"use strict";
+// Instance name is this because it is usually referred to as this inside a
+// method definition
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MethodInvocation = void 0;
+/**
+ * @summary The state for a single invocation of a method, referenced by this
+ * inside a method definition.
+ * @param {Object} options
+ * @instanceName this
+ * @showInstanceName true
+ */
+class MethodInvocation {
+    constructor(options) {
+        // true if we're running not the actual method, but a stub (that is,
+        // if we're on a client (which may be a browser, or in the future a
+        // server connecting to another server) and presently running a
+        // simulation of a server-side method for latency compensation
+        // purposes). not currently true except in a client such as a browser,
+        // since there's usually no point in running stubs unless you have a
+        // zero-latency connection to the user.
+        /**
+         * @summary Access inside a method invocation.  Boolean value, true if this invocation is a stub.
+         * @locus Anywhere
+         * @name  isSimulation
+         * @memberOf DDPCommon.MethodInvocation
+         * @instance
+         * @type {Boolean}
+         */
+        this.isSimulation = options.isSimulation;
+        // used to know when the function apply was called by callAsync
+        this._isFromCallAsync = options.isFromCallAsync;
+        // current user id
+        /**
+         * @summary The id of the user that made this method call, or `null` if no user was logged in.
+         * @locus Anywhere
+         * @name  userId
+         * @memberOf DDPCommon.MethodInvocation
+         * @instance
+         */
+        this.userId = options.userId;
+        // sets current user id in all appropriate server contexts and
+        // reruns subscriptions
+        this._setUserId = options.setUserId || function () { };
+        // On the server, the connection this method call came in on.
+        /**
+         * @summary Access inside a method invocation. The [connection](#meteor_onconnection) that this method was received on. `null` if the method is not associated with a connection, eg. a server initiated method call. Calls to methods made from a server method which was in turn initiated from the client share the same `connection`.
+         * @locus Server
+         * @name  connection
+         * @memberOf DDPCommon.MethodInvocation
+         * @instance
+         */
+        this.connection = options.connection;
+        // The seed for randomStream value generation
+        this.randomSeed = options.randomSeed;
+        // This is set by RandomStream.get; and holds the random stream state
+        this.randomStream = null;
+    }
+    /**
+     * @summary Set the logged in user.
+     * @locus Server
+     * @memberOf DDPCommon.MethodInvocation
+     * @instance
+     * @param {String | null} userId The value that should be returned by `userId` on this connection.
+     */
+    setUserId(userId) {
+        this.userId = userId;
+        this._setUserId(userId);
+    }
+}
+exports.MethodInvocation = MethodInvocation;
+;

package/dist/meteor/ddp/random-stream.d.ts

@@ -1,8 +1,8 @@
-export declare class RandomStream {
-    private seed;
-    private sequences;
-    constructor(options: any);
-    _sequence(name: any): any;
-    static get(scope: any, name: any): any;
-}
-export declare function makeRpcSeed(enclosing: any, methodName: any): any;
+export declare class RandomStream {
+    private seed;
+    private sequences;
+    constructor(options: any);
+    _sequence(name: any): any;
+    static get(scope: any, name: any): any;
+}
+export declare function makeRpcSeed(enclosing: any, methodName: any): any;

package/dist/meteor/ddp/random-stream.js

@@ -1,100 +1,100 @@
-"use strict";
-// RandomStream allows for generation of pseudo-random values, from a seed.
-//
-// We use this for consistent 'random' numbers across the client and server.
-// We want to generate probably-unique IDs on the client, and we ideally want
-// the server to generate the same IDs when it executes the method.
-//
-// For generated values to be the same, we must seed ourselves the same way,
-// and we must keep track of the current state of our pseudo-random generators.
-// We call this state the scope. By default, we use the current DDP method
-// invocation as our scope.  DDP now allows the client to specify a randomSeed.
-// If a randomSeed is provided it will be used to seed our random sequences.
-// In this way, client and server method calls will generate the same values.
-//
-// We expose multiple named streams; each stream is independent
-// and is seeded differently (but predictably from the name).
-// By using multiple streams, we support reordering of requests,
-// as long as they occur on different streams.
-//
-// @param options {Optional Object}
-//   seed: Array or value - Seed value(s) for the generator.
-//                          If an array, will be used as-is
-//                          If a value, will be converted to a single-value array
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeRpcSeed = exports.RandomStream = void 0;
-const main_1 = require("../random/main");
-//                          If omitted, a random array will be used as the seed.
-class RandomStream {
-    constructor(options) {
-        this.seed = [].concat(options.seed || randomToken());
-        this.sequences = Object.create(null);
-    }
-    // Get a random sequence with the specified name, creating it if does not exist.
-    // New sequences are seeded with the seed concatenated with the name.
-    // By passing a seed into Random.create, we use the Alea generator.
-    _sequence(name) {
-        var self = this;
-        var sequence = self.sequences[name] || null;
-        if (sequence === null) {
-            var sequenceSeed = self.seed.concat(name);
-            for (var i = 0; i < sequenceSeed.length; i++) {
-                if (typeof sequenceSeed[i] === "function") {
-                    sequenceSeed[i] = sequenceSeed[i]();
-                }
-            }
-            self.sequences[name] = sequence = main_1.Random.createWithSeeds.apply(null, sequenceSeed);
-        }
-        return sequence;
-    }
-    // Returns the random stream with the specified name, in the specified
-    // scope. If a scope is passed, then we use that to seed a (not
-    // cryptographically secure) PRNG using the fast Alea algorithm.  If
-    // scope is null (or otherwise falsey) then we use a generated seed.
-    //
-    // However, scope will normally be the current DDP method invocation,
-    // so we'll use the stream with the specified name, and we should get
-    // consistent values on the client and server sides of a method call.
-    static get(scope, name) {
-        if (!name) {
-            name = "default";
-        }
-        if (!scope) {
-            // There was no scope passed in; the sequence won't actually be
-            // reproducible. but make it fast (and not cryptographically
-            // secure) anyways, so that the behavior is similar to what you'd
-            // get by passing in a scope.
-            return main_1.Random.insecure;
-        }
-        var randomStream = scope.randomStream;
-        if (!randomStream) {
-            scope.randomStream = randomStream = new RandomStream({
-                seed: scope.randomSeed
-            });
-        }
-        return randomStream._sequence(name);
-    }
-    ;
-}
-exports.RandomStream = RandomStream;
-;
-// Returns a random string of sufficient length for a random seed.
-// This is a placeholder function; a similar function is planned
-// for Random itself; when that is added we should remove this function,
-// and call Random's randomToken instead.
-function randomToken() {
-    return main_1.Random.hexString(20);
-}
-;
-// Creates a randomSeed for passing to a method call.
-// Note that we take enclosing as an argument,
-// though we expect it to be DDP._CurrentMethodInvocation.get()
-// However, we often evaluate makeRpcSeed lazily, and thus the relevant
-// invocation may not be the one currently in scope.
-// If enclosing is null, we'll use Random and values won't be repeatable.
-function makeRpcSeed(enclosing, methodName) {
-    var stream = RandomStream.get(enclosing, '/rpc/' + methodName);
-    return stream.hexString(20);
-}
-exports.makeRpcSeed = makeRpcSeed;
-;
+"use strict";
+// RandomStream allows for generation of pseudo-random values, from a seed.
+//
+// We use this for consistent 'random' numbers across the client and server.
+// We want to generate probably-unique IDs on the client, and we ideally want
+// the server to generate the same IDs when it executes the method.
+//
+// For generated values to be the same, we must seed ourselves the same way,
+// and we must keep track of the current state of our pseudo-random generators.
+// We call this state the scope. By default, we use the current DDP method
+// invocation as our scope.  DDP now allows the client to specify a randomSeed.
+// If a randomSeed is provided it will be used to seed our random sequences.
+// In this way, client and server method calls will generate the same values.
+//
+// We expose multiple named streams; each stream is independent
+// and is seeded differently (but predictably from the name).
+// By using multiple streams, we support reordering of requests,
+// as long as they occur on different streams.
+//
+// @param options {Optional Object}
+//   seed: Array or value - Seed value(s) for the generator.
+//                          If an array, will be used as-is
+//                          If a value, will be converted to a single-value array
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RandomStream = void 0;
+exports.makeRpcSeed = makeRpcSeed;
+const main_1 = require("../random/main");
+//                          If omitted, a random array will be used as the seed.
+class RandomStream {
+    constructor(options) {
+        this.seed = [].concat(options.seed || randomToken());
+        this.sequences = Object.create(null);
+    }
+    // Get a random sequence with the specified name, creating it if does not exist.
+    // New sequences are seeded with the seed concatenated with the name.
+    // By passing a seed into Random.create, we use the Alea generator.
+    _sequence(name) {
+        var self = this;
+        var sequence = self.sequences[name] || null;
+        if (sequence === null) {
+            var sequenceSeed = self.seed.concat(name);
+            for (var i = 0; i < sequenceSeed.length; i++) {
+                if (typeof sequenceSeed[i] === "function") {
+                    sequenceSeed[i] = sequenceSeed[i]();
+                }
+            }
+            self.sequences[name] = sequence = main_1.Random.createWithSeeds.apply(null, sequenceSeed);
+        }
+        return sequence;
+    }
+    // Returns the random stream with the specified name, in the specified
+    // scope. If a scope is passed, then we use that to seed a (not
+    // cryptographically secure) PRNG using the fast Alea algorithm.  If
+    // scope is null (or otherwise falsey) then we use a generated seed.
+    //
+    // However, scope will normally be the current DDP method invocation,
+    // so we'll use the stream with the specified name, and we should get
+    // consistent values on the client and server sides of a method call.
+    static get(scope, name) {
+        if (!name) {
+            name = "default";
+        }
+        if (!scope) {
+            // There was no scope passed in; the sequence won't actually be
+            // reproducible. but make it fast (and not cryptographically
+            // secure) anyways, so that the behavior is similar to what you'd
+            // get by passing in a scope.
+            return main_1.Random.insecure;
+        }
+        var randomStream = scope.randomStream;
+        if (!randomStream) {
+            scope.randomStream = randomStream = new RandomStream({
+                seed: scope.randomSeed
+            });
+        }
+        return randomStream._sequence(name);
+    }
+    ;
+}
+exports.RandomStream = RandomStream;
+;
+// Returns a random string of sufficient length for a random seed.
+// This is a placeholder function; a similar function is planned
+// for Random itself; when that is added we should remove this function,
+// and call Random's randomToken instead.
+function randomToken() {
+    return main_1.Random.hexString(20);
+}
+;
+// Creates a randomSeed for passing to a method call.
+// Note that we take enclosing as an argument,
+// though we expect it to be DDP._CurrentMethodInvocation.get()
+// However, we often evaluate makeRpcSeed lazily, and thus the relevant
+// invocation may not be the one currently in scope.
+// If enclosing is null, we'll use Random and values won't be repeatable.
+function makeRpcSeed(enclosing, methodName) {
+    var stream = RandomStream.get(enclosing, '/rpc/' + methodName);
+    return stream.hexString(20);
+}
+;

package/dist/meteor/ddp/session-collection-view.d.ts

@@ -1,20 +1,20 @@
-import { SessionDocumentView } from "./session-document-view";
-import { SubscriptionCallbacks, SubscriptionHandle } from "./subscription";
-/**
- * Represents a client's view of a single collection
- * @param {String} collectionName Name of the collection it represents
- * @param {Object.<String, Function>} sessionCallbacks The callbacks for added, changed, removed
- * @class SessionCollectionView
- */
-export declare class SessionCollectionView {
-    private collectionName;
-    private callbacks;
-    private documents;
-    constructor(collectionName: string, callbacks: SubscriptionCallbacks);
-    isEmpty(): boolean;
-    diff(previous: SessionCollectionView): void;
-    diffDocument(id: string, prevDV: SessionDocumentView, nowDV: SessionDocumentView): void;
-    added(subscriptionHandle: SubscriptionHandle, id: string, fields: Record<string, any>): void;
-    changed(subscriptionHandle: SubscriptionHandle, id: string, changed: Record<string, any>): void;
-    removed(subscriptionHandle: SubscriptionHandle, id: string): void;
-}
+import { SessionDocumentView } from "./session-document-view";
+import { SubscriptionCallbacks, SubscriptionHandle } from "./subscription";
+/**
+ * Represents a client's view of a single collection
+ * @param {String} collectionName Name of the collection it represents
+ * @param {Object.<String, Function>} sessionCallbacks The callbacks for added, changed, removed
+ * @class SessionCollectionView
+ */
+export declare class SessionCollectionView {
+    private collectionName;
+    private callbacks;
+    private documents;
+    constructor(collectionName: string, callbacks: SubscriptionCallbacks);
+    isEmpty(): boolean;
+    diff(previous: SessionCollectionView): void;
+    diffDocument(id: string, prevDV: SessionDocumentView, nowDV: SessionDocumentView): void;
+    added(subscriptionHandle: SubscriptionHandle, id: string, fields: Record<string, any>): void;
+    changed(subscriptionHandle: SubscriptionHandle, id: string, changed: Record<string, any>): void;
+    removed(subscriptionHandle: SubscriptionHandle, id: string): void;
+}