607 lines
21 KiB
JavaScript
607 lines
21 KiB
JavaScript
//////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// This is a generated file. You can view the original //
|
|
// source in your browser if your browser supports source maps. //
|
|
// Source maps are supported by all recent versions of Chrome, Safari, //
|
|
// and Firefox, and by Internet Explorer 11. //
|
|
// //
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
(function () {
|
|
|
|
/* Imports */
|
|
var Meteor = Package.meteor.Meteor;
|
|
var global = Package.meteor.global;
|
|
var meteorEnv = Package.meteor.meteorEnv;
|
|
var check = Package.check.check;
|
|
var Match = Package.check.Match;
|
|
var Random = Package.random.Random;
|
|
var EJSON = Package.ejson.EJSON;
|
|
var Tracker = Package.tracker.Tracker;
|
|
var Deps = Package.tracker.Deps;
|
|
var Retry = Package.retry.Retry;
|
|
var meteorInstall = Package.modules.meteorInstall;
|
|
var meteorBabelHelpers = Package['babel-runtime'].meteorBabelHelpers;
|
|
var Promise = Package.promise.Promise;
|
|
var Symbol = Package['ecmascript-runtime-client'].Symbol;
|
|
var Map = Package['ecmascript-runtime-client'].Map;
|
|
var Set = Package['ecmascript-runtime-client'].Set;
|
|
|
|
/* Package-scope variables */
|
|
var DDPCommon;
|
|
|
|
var require = meteorInstall({"node_modules":{"meteor":{"ddp-common":{"namespace.js":function(){
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/ddp-common/namespace.js //
|
|
// //
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
/**
|
|
* @namespace DDPCommon
|
|
* @summary Namespace for DDPCommon-related methods/classes. Shared between
|
|
* `ddp-client` and `ddp-server`, where the ddp-client is the implementation
|
|
* of a ddp client for both client AND server; and the ddp server is the
|
|
* implementation of the livedata server and stream server. Common
|
|
* functionality shared between both can be shared under this namespace
|
|
*/
|
|
DDPCommon = {};
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
},"heartbeat.js":function(){
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/ddp-common/heartbeat.js //
|
|
// //
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Heartbeat options:
|
|
// heartbeatInterval: interval to send pings, in milliseconds.
|
|
// heartbeatTimeout: timeout to close the connection if a reply isn't
|
|
// received, in milliseconds.
|
|
// sendPing: function to call to send a ping on the connection.
|
|
// onTimeout: function to call to close the connection.
|
|
DDPCommon.Heartbeat =
|
|
/*#__PURE__*/
|
|
function () {
|
|
function Heartbeat(options) {
|
|
this.heartbeatInterval = options.heartbeatInterval;
|
|
this.heartbeatTimeout = options.heartbeatTimeout;
|
|
this._sendPing = options.sendPing;
|
|
this._onTimeout = options.onTimeout;
|
|
this._seenPacket = false;
|
|
this._heartbeatIntervalHandle = null;
|
|
this._heartbeatTimeoutHandle = null;
|
|
}
|
|
|
|
var _proto = Heartbeat.prototype;
|
|
|
|
_proto.stop = function () {
|
|
function stop() {
|
|
this._clearHeartbeatIntervalTimer();
|
|
|
|
this._clearHeartbeatTimeoutTimer();
|
|
}
|
|
|
|
return stop;
|
|
}();
|
|
|
|
_proto.start = function () {
|
|
function start() {
|
|
this.stop();
|
|
|
|
this._startHeartbeatIntervalTimer();
|
|
}
|
|
|
|
return start;
|
|
}();
|
|
|
|
_proto._startHeartbeatIntervalTimer = function () {
|
|
function _startHeartbeatIntervalTimer() {
|
|
var _this = this;
|
|
|
|
this._heartbeatIntervalHandle = Meteor.setInterval(function () {
|
|
return _this._heartbeatIntervalFired();
|
|
}, this.heartbeatInterval);
|
|
}
|
|
|
|
return _startHeartbeatIntervalTimer;
|
|
}();
|
|
|
|
_proto._startHeartbeatTimeoutTimer = function () {
|
|
function _startHeartbeatTimeoutTimer() {
|
|
var _this2 = this;
|
|
|
|
this._heartbeatTimeoutHandle = Meteor.setTimeout(function () {
|
|
return _this2._heartbeatTimeoutFired();
|
|
}, this.heartbeatTimeout);
|
|
}
|
|
|
|
return _startHeartbeatTimeoutTimer;
|
|
}();
|
|
|
|
_proto._clearHeartbeatIntervalTimer = function () {
|
|
function _clearHeartbeatIntervalTimer() {
|
|
if (this._heartbeatIntervalHandle) {
|
|
Meteor.clearInterval(this._heartbeatIntervalHandle);
|
|
this._heartbeatIntervalHandle = null;
|
|
}
|
|
}
|
|
|
|
return _clearHeartbeatIntervalTimer;
|
|
}();
|
|
|
|
_proto._clearHeartbeatTimeoutTimer = function () {
|
|
function _clearHeartbeatTimeoutTimer() {
|
|
if (this._heartbeatTimeoutHandle) {
|
|
Meteor.clearTimeout(this._heartbeatTimeoutHandle);
|
|
this._heartbeatTimeoutHandle = null;
|
|
}
|
|
}
|
|
|
|
return _clearHeartbeatTimeoutTimer;
|
|
}(); // The heartbeat interval timer is fired when we should send a ping.
|
|
|
|
|
|
_proto._heartbeatIntervalFired = function () {
|
|
function _heartbeatIntervalFired() {
|
|
// don't send ping if we've seen a packet since we last checked,
|
|
// *or* if we have already sent a ping and are awaiting a timeout.
|
|
// That shouldn't happen, but it's possible if
|
|
// `this.heartbeatInterval` is smaller than
|
|
// `this.heartbeatTimeout`.
|
|
if (!this._seenPacket && !this._heartbeatTimeoutHandle) {
|
|
this._sendPing(); // Set up timeout, in case a pong doesn't arrive in time.
|
|
|
|
|
|
this._startHeartbeatTimeoutTimer();
|
|
}
|
|
|
|
this._seenPacket = false;
|
|
}
|
|
|
|
return _heartbeatIntervalFired;
|
|
}(); // The heartbeat timeout timer is fired when we sent a ping, but we
|
|
// timed out waiting for the pong.
|
|
|
|
|
|
_proto._heartbeatTimeoutFired = function () {
|
|
function _heartbeatTimeoutFired() {
|
|
this._heartbeatTimeoutHandle = null;
|
|
|
|
this._onTimeout();
|
|
}
|
|
|
|
return _heartbeatTimeoutFired;
|
|
}();
|
|
|
|
_proto.messageReceived = function () {
|
|
function messageReceived() {
|
|
// Tell periodic checkin that we have seen a packet, and thus it
|
|
// does not need to send a ping this cycle.
|
|
this._seenPacket = true; // If we were waiting for a pong, we got it.
|
|
|
|
if (this._heartbeatTimeoutHandle) {
|
|
this._clearHeartbeatTimeoutTimer();
|
|
}
|
|
}
|
|
|
|
return messageReceived;
|
|
}();
|
|
|
|
return Heartbeat;
|
|
}();
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
},"utils.js":function(require,exports,module){
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/ddp-common/utils.js //
|
|
// //
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
"use strict";
|
|
|
|
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
|
|
|
|
var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
|
|
|
|
module.export({
|
|
hasOwn: function () {
|
|
return hasOwn;
|
|
},
|
|
slice: function () {
|
|
return slice;
|
|
},
|
|
keys: function () {
|
|
return keys;
|
|
},
|
|
isEmpty: function () {
|
|
return isEmpty;
|
|
},
|
|
last: function () {
|
|
return last;
|
|
}
|
|
});
|
|
var hasOwn = Object.prototype.hasOwnProperty;
|
|
var 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 (var key in meteorBabelHelpers.sanitizeForInObject(obj)) {
|
|
if (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 slice.call(array, Math.max(array.length - n, 0));
|
|
}
|
|
|
|
DDPCommon.SUPPORTED_DDP_VERSIONS = ['1', 'pre2', 'pre1'];
|
|
|
|
DDPCommon.parseDDP = function (stringMessage) {
|
|
try {
|
|
var msg = JSON.parse(stringMessage);
|
|
} catch (e) {
|
|
Meteor._debug("Discarding message with invalid JSON", stringMessage);
|
|
|
|
return null;
|
|
} // DDP messages must be objects.
|
|
|
|
|
|
if (msg === null || (0, _typeof2.default)(msg) !== 'object') {
|
|
Meteor._debug("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 (hasOwn.call(msg, 'cleared')) {
|
|
if (!hasOwn.call(msg, 'fields')) {
|
|
msg.fields = {};
|
|
}
|
|
|
|
msg.cleared.forEach(function (clearKey) {
|
|
msg.fields[clearKey] = undefined;
|
|
});
|
|
delete msg.cleared;
|
|
}
|
|
|
|
['fields', 'params', 'result'].forEach(function (field) {
|
|
if (hasOwn.call(msg, field)) {
|
|
msg[field] = EJSON._adjustTypesFromJSONValue(msg[field]);
|
|
}
|
|
});
|
|
return msg;
|
|
};
|
|
|
|
DDPCommon.stringifyDDP = function (msg) {
|
|
var copy = EJSON.clone(msg); // swizzle 'changed' messages from 'fields undefined' rep to 'fields
|
|
// and cleared' rep
|
|
|
|
if (hasOwn.call(msg, 'fields')) {
|
|
var cleared = [];
|
|
Object.keys(msg.fields).forEach(function (key) {
|
|
var 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(function (field) {
|
|
if (hasOwn.call(copy, field)) {
|
|
copy[field] = EJSON._adjustTypesToJSONValue(copy[field]);
|
|
}
|
|
});
|
|
|
|
if (msg.id && typeof msg.id !== 'string') {
|
|
throw new Error("Message id is not a string");
|
|
}
|
|
|
|
return JSON.stringify(copy);
|
|
};
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
},"method_invocation.js":function(){
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/ddp-common/method_invocation.js //
|
|
// //
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Instance name is this because it is usually referred to as this inside a
|
|
// method definition
|
|
|
|
/**
|
|
* @summary The state for a single invocation of a method, referenced by this
|
|
* inside a method definition.
|
|
* @param {Object} options
|
|
* @instanceName this
|
|
* @showInstanceName true
|
|
*/
|
|
DDPCommon.MethodInvocation =
|
|
/*#__PURE__*/
|
|
function () {
|
|
function MethodInvocation(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; // call this function to allow other method invocations (from the
|
|
// same client) to continue running without waiting for this one to
|
|
// complete.
|
|
|
|
this._unblock = options.unblock || function () {};
|
|
|
|
this._calledUnblock = false; // 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 Call inside a method invocation. Allow subsequent method from this client to begin running in a new fiber.
|
|
* @locus Server
|
|
* @memberOf DDPCommon.MethodInvocation
|
|
* @instance
|
|
*/
|
|
|
|
|
|
var _proto = MethodInvocation.prototype;
|
|
|
|
_proto.unblock = function () {
|
|
function unblock() {
|
|
this._calledUnblock = true;
|
|
|
|
this._unblock();
|
|
}
|
|
|
|
return unblock;
|
|
}();
|
|
/**
|
|
* @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.
|
|
*/
|
|
|
|
|
|
_proto.setUserId = function () {
|
|
function setUserId(userId) {
|
|
if (this._calledUnblock) {
|
|
throw new Error("Can't call setUserId in a method after calling unblock");
|
|
}
|
|
|
|
this.userId = userId;
|
|
|
|
this._setUserId(userId);
|
|
}
|
|
|
|
return setUserId;
|
|
}();
|
|
|
|
return MethodInvocation;
|
|
}();
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
},"random_stream.js":function(){
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/ddp-common/random_stream.js //
|
|
// //
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// 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
|
|
// If omitted, a random array will be used as the seed.
|
|
DDPCommon.RandomStream =
|
|
/*#__PURE__*/
|
|
function () {
|
|
function RandomStream(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.
|
|
|
|
|
|
var _proto = RandomStream.prototype;
|
|
|
|
_proto._sequence = function () {
|
|
function _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 = Random.createWithSeeds.apply(null, sequenceSeed);
|
|
}
|
|
|
|
return sequence;
|
|
}
|
|
|
|
return _sequence;
|
|
}();
|
|
|
|
return 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 Random.hexString(20);
|
|
}
|
|
|
|
; // 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.
|
|
|
|
DDPCommon.RandomStream.get = function (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 Random.insecure;
|
|
}
|
|
|
|
var randomStream = scope.randomStream;
|
|
|
|
if (!randomStream) {
|
|
scope.randomStream = randomStream = new DDPCommon.RandomStream({
|
|
seed: scope.randomSeed
|
|
});
|
|
}
|
|
|
|
return randomStream._sequence(name);
|
|
}; // 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.
|
|
|
|
|
|
DDPCommon.makeRpcSeed = function (enclosing, methodName) {
|
|
var stream = DDPCommon.RandomStream.get(enclosing, '/rpc/' + methodName);
|
|
return stream.hexString(20);
|
|
};
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}}}}},{
|
|
"extensions": [
|
|
".js",
|
|
".json"
|
|
]
|
|
});
|
|
require("/node_modules/meteor/ddp-common/namespace.js");
|
|
require("/node_modules/meteor/ddp-common/heartbeat.js");
|
|
require("/node_modules/meteor/ddp-common/utils.js");
|
|
require("/node_modules/meteor/ddp-common/method_invocation.js");
|
|
require("/node_modules/meteor/ddp-common/random_stream.js");
|
|
|
|
/* Exports */
|
|
Package._define("ddp-common", {
|
|
DDPCommon: DDPCommon
|
|
});
|
|
|
|
})();
|