{"version":3,"sources":["meteor://💻app/packages/check/match.js","meteor://💻app/packages/check/isPlainObject.js"],"names":["module","export","check","Match","isPlainObject","link","v","currentArgumentChecker","Meteor","EnvironmentVariable","hasOwn","Object","prototype","hasOwnProperty","value","pattern","argChecker","getOrNullIfOutsideFiber","checking","result","testSubtree","err","Error","message","path","Optional","Maybe","OneOf","args","Any","Where","condition","ObjectIncluding","ObjectWithValues","Integer","makeErrorType","msg","sanitizedError","test","_failIfArgumentsAreNotAllChecked","f","context","description","ArgumentChecker","withValue","apply","throwUnlessAllArgumentsHaveBeenChecked","constructor","choices","length","stringForErrorMessage","options","onlyShowType","EJSON","stringify","JSON","stringifyError","name","typeofChecks","String","Number","Boolean","Function","undefined","i","Array","isArray","isArguments","_prependPath","unknownKeysAllowed","unknownKeyPattern","requiredPatterns","create","optionalPatterns","keys","forEach","key","subPattern","subValue","call","reverse","_checkingOneValue","bind","isNaN","splice","_jsKeywords","base","match","indexOf","isObject","baseIsArguments","item","toString","arguments","callee","class2type","fnToString","ObjectFunctionString","getProto","getPrototypeOf","obj","proto","Ctor"],"mappings":"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","file":"/packages/check.js","sourcesContent":["// XXX docs\nimport { isPlainObject } from './isPlainObject';\n\n// Things we explicitly do NOT support:\n// - heterogenous arrays\n\nconst currentArgumentChecker = new Meteor.EnvironmentVariable;\nconst hasOwn = Object.prototype.hasOwnProperty;\n\n/**\n * @summary Check that a value matches a [pattern](#matchpatterns).\n * If the value does not match the pattern, throw a `Match.Error`.\n *\n * Particularly useful to assert that arguments to a function have the right\n * types and structure.\n * @locus Anywhere\n * @param {Any} value The value to check\n * @param {MatchPattern} pattern The pattern to match `value` against\n */\nexport function check(value, pattern) {\n // Record that check got called, if somebody cared.\n //\n // We use getOrNullIfOutsideFiber so that it's OK to call check()\n // from non-Fiber server contexts; the downside is that if you forget to\n // bindEnvironment on some random callback in your method/publisher,\n // it might not find the argumentChecker and you'll get an error about\n // not checking an argument that it looks like you're checking (instead\n // of just getting a \"Node code must run in a Fiber\" error).\n const argChecker = currentArgumentChecker.getOrNullIfOutsideFiber();\n if (argChecker) {\n argChecker.checking(value);\n }\n\n const result = testSubtree(value, pattern);\n if (result) {\n const err = new Match.Error(result.message);\n if (result.path) {\n err.message += ` in field ${result.path}`;\n err.path = result.path;\n }\n\n throw err;\n }\n};\n\n/**\n * @namespace Match\n * @summary The namespace for all Match types and methods.\n */\nexport const Match = {\n Optional: function(pattern) {\n return new Optional(pattern);\n },\n\n Maybe: function(pattern) {\n return new Maybe(pattern);\n },\n\n OneOf: function(...args) {\n return new OneOf(args);\n },\n\n Any: ['__any__'],\n Where: function(condition) {\n return new Where(condition);\n },\n\n ObjectIncluding: function(pattern) {\n return new ObjectIncluding(pattern)\n },\n\n ObjectWithValues: function(pattern) {\n return new ObjectWithValues(pattern);\n },\n\n // Matches only signed 32-bit integers\n Integer: ['__integer__'],\n\n // XXX matchers should know how to describe themselves for errors\n Error: Meteor.makeErrorType('Match.Error', function (msg) {\n this.message = `Match error: ${msg}`;\n\n // The path of the value that failed to match. Initially empty, this gets\n // populated by catching and rethrowing the exception as it goes back up the\n // stack.\n // E.g.: \"vals[3].entity.created\"\n this.path = '';\n\n // If this gets sent over DDP, don't give full internal details but at least\n // provide something better than 500 Internal server error.\n this.sanitizedError = new Meteor.Error(400, 'Match failed');\n }),\n\n // Tests to see if value matches pattern. Unlike check, it merely returns true\n // or false (unless an error other than Match.Error was thrown). It does not\n // interact with _failIfArgumentsAreNotAllChecked.\n // XXX maybe also implement a Match.match which returns more information about\n // failures but without using exception handling or doing what check()\n // does with _failIfArgumentsAreNotAllChecked and Meteor.Error conversion\n\n /**\n * @summary Returns true if the value matches the pattern.\n * @locus Anywhere\n * @param {Any} value The value to check\n * @param {MatchPattern} pattern The pattern to match `value` against\n */\n test(value, pattern) {\n return !testSubtree(value, pattern);\n },\n\n // Runs `f.apply(context, args)`. If check() is not called on every element of\n // `args` (either directly or in the first level of an array), throws an error\n // (using `description` in the message).\n _failIfArgumentsAreNotAllChecked(f, context, args, description) {\n const argChecker = new ArgumentChecker(args, description);\n const result = currentArgumentChecker.withValue(\n argChecker, \n () => f.apply(context, args)\n );\n\n // If f didn't itself throw, make sure it checked all of its arguments.\n argChecker.throwUnlessAllArgumentsHaveBeenChecked();\n return result;\n }\n};\n\nclass Optional {\n constructor(pattern) {\n this.pattern = pattern;\n }\n}\n\nclass Maybe {\n constructor(pattern) {\n this.pattern = pattern;\n }\n}\n\nclass OneOf {\n constructor(choices) {\n if (!choices || choices.length === 0) {\n throw new Error('Must provide at least one choice to Match.OneOf');\n }\n\n this.choices = choices;\n }\n}\n\nclass Where {\n constructor(condition) {\n this.condition = condition;\n }\n}\n\nclass ObjectIncluding {\n constructor(pattern) {\n this.pattern = pattern;\n }\n}\n\nclass ObjectWithValues {\n constructor(pattern) {\n this.pattern = pattern;\n }\n}\n\nconst stringForErrorMessage = (value, options = {}) => {\n if ( value === null ) {\n return 'null';\n }\n\n if ( options.onlyShowType ) {\n return typeof value;\n }\n\n // Your average non-object things. Saves from doing the try/catch below for.\n if ( typeof value !== 'object' ) {\n return EJSON.stringify(value)\n }\n\n try {\n\n // Find objects with circular references since EJSON doesn't support them yet (Issue #4778 + Unaccepted PR)\n // If the native stringify is going to choke, EJSON.stringify is going to choke too.\n JSON.stringify(value);\n } catch (stringifyError) {\n if ( stringifyError.name === 'TypeError' ) {\n return typeof value;\n }\n }\n\n return EJSON.stringify(value);\n};\n\nconst typeofChecks = [\n [String, 'string'],\n [Number, 'number'],\n [Boolean, 'boolean'],\n\n // While we don't allow undefined/function in EJSON, this is good for optional\n // arguments with OneOf.\n [Function, 'function'],\n [undefined, 'undefined'],\n];\n\n// Return `false` if it matches. Otherwise, return an object with a `message` and a `path` field.\nconst testSubtree = (value, pattern) => {\n\n // Match anything!\n if (pattern === Match.Any) {\n return false;\n }\n\n // Basic atomic types.\n // Do not match boxed objects (e.g. String, Boolean)\n for (let i = 0; i < typeofChecks.length; ++i) {\n if (pattern === typeofChecks[i][0]) {\n if (typeof value === typeofChecks[i][1]) {\n return false;\n }\n\n return {\n message: `Expected ${typeofChecks[i][1]}, got ${stringForErrorMessage(value, { onlyShowType: true })}`,\n path: '',\n };\n }\n }\n\n if (pattern === null) {\n if (value === null) {\n return false;\n }\n\n return {\n message: `Expected null, got ${stringForErrorMessage(value)}`,\n path: '',\n };\n }\n\n // Strings, numbers, and booleans match literally. Goes well with Match.OneOf.\n if (typeof pattern === 'string' || typeof pattern === 'number' || typeof pattern === 'boolean') {\n if (value === pattern) {\n return false;\n }\n\n return {\n message: `Expected ${pattern}, got ${stringForErrorMessage(value)}`,\n path: '',\n };\n }\n\n // Match.Integer is special type encoded with array\n if (pattern === Match.Integer) {\n\n // There is no consistent and reliable way to check if variable is a 64-bit\n // integer. One of the popular solutions is to get reminder of division by 1\n // but this method fails on really large floats with big precision.\n // E.g.: 1.348192308491824e+23 % 1 === 0 in V8\n // Bitwise operators work consistantly but always cast variable to 32-bit\n // signed integer according to JavaScript specs.\n if (typeof value === 'number' && (value | 0) === value) {\n return false;\n }\n \n return {\n message: `Expected Integer, got ${stringForErrorMessage(value)}`,\n path: '',\n };\n }\n\n // 'Object' is shorthand for Match.ObjectIncluding({});\n if (pattern === Object) {\n pattern = Match.ObjectIncluding({});\n }\n\n // Array (checked AFTER Any, which is implemented as an Array).\n if (pattern instanceof Array) {\n if (pattern.length !== 1) {\n return {\n message: `Bad pattern: arrays must have one type element ${stringForErrorMessage(pattern)}`,\n path: '',\n };\n }\n\n if (!Array.isArray(value) && !isArguments(value)) {\n return {\n message: `Expected array, got ${stringForErrorMessage(value)}`,\n path: '',\n };\n }\n\n for (let i = 0, length = value.length; i < length; i++) {\n const result = testSubtree(value[i], pattern[0]);\n if (result) {\n result.path = _prependPath(i, result.path);\n return result;\n }\n }\n \n return false;\n }\n\n // Arbitrary validation checks. The condition can return false or throw a\n // Match.Error (ie, it can internally use check()) to fail.\n if (pattern instanceof Where) {\n let result;\n try {\n result = pattern.condition(value);\n } catch (err) {\n if (!(err instanceof Match.Error)) {\n throw err;\n }\n \n return {\n message: err.message,\n path: err.path\n };\n }\n\n if (result) {\n return false;\n }\n\n // XXX this error is terrible\n return {\n message: 'Failed Match.Where validation',\n path: '',\n };\n }\n\n if (pattern instanceof Maybe) {\n pattern = Match.OneOf(undefined, null, pattern.pattern);\n } else if (pattern instanceof Optional) {\n pattern = Match.OneOf(undefined, pattern.pattern);\n }\n\n if (pattern instanceof OneOf) {\n for (let i = 0; i < pattern.choices.length; ++i) {\n const result = testSubtree(value, pattern.choices[i]);\n if (!result) {\n\n // No error? Yay, return.\n return false;\n }\n\n // Match errors just mean try another choice.\n }\n\n // XXX this error is terrible\n return {\n message: 'Failed Match.OneOf, Match.Maybe or Match.Optional validation',\n path: '',\n };\n }\n\n // A function that isn't something we special-case is assumed to be a\n // constructor.\n if (pattern instanceof Function) {\n if (value instanceof pattern) {\n return false;\n }\n\n return {\n message: `Expected ${pattern.name || 'particular constructor'}`,\n path: '',\n };\n }\n\n let unknownKeysAllowed = false;\n let unknownKeyPattern;\n if (pattern instanceof ObjectIncluding) {\n unknownKeysAllowed = true;\n pattern = pattern.pattern;\n }\n\n if (pattern instanceof ObjectWithValues) {\n unknownKeysAllowed = true;\n unknownKeyPattern = [pattern.pattern];\n pattern = {}; // no required keys\n }\n\n if (typeof pattern !== 'object') {\n return {\n message: 'Bad pattern: unknown pattern type',\n path: '',\n };\n }\n\n // An object, with required and optional keys. Note that this does NOT do\n // structural matches against objects of special types that happen to match\n // the pattern: this really needs to be a plain old {Object}!\n if (typeof value !== 'object') {\n return {\n message: `Expected object, got ${typeof value}`,\n path: '',\n };\n }\n\n if (value === null) {\n return {\n message: `Expected object, got null`,\n path: '',\n };\n }\n\n if (! isPlainObject(value)) {\n return {\n message: `Expected plain object`,\n path: '',\n };\n }\n\n const requiredPatterns = Object.create(null);\n const optionalPatterns = Object.create(null);\n\n Object.keys(pattern).forEach(key => {\n const subPattern = pattern[key];\n if (subPattern instanceof Optional ||\n subPattern instanceof Maybe) {\n optionalPatterns[key] = subPattern.pattern;\n } else {\n requiredPatterns[key] = subPattern;\n }\n });\n\n for (let key in Object(value)) {\n const subValue = value[key];\n if (hasOwn.call(requiredPatterns, key)) {\n const result = testSubtree(subValue, requiredPatterns[key]);\n if (result) {\n result.path = _prependPath(key, result.path);\n return result;\n }\n\n delete requiredPatterns[key];\n } else if (hasOwn.call(optionalPatterns, key)) {\n const result = testSubtree(subValue, optionalPatterns[key]);\n if (result) {\n result.path = _prependPath(key, result.path);\n return result;\n }\n\n } else {\n if (!unknownKeysAllowed) {\n return {\n message: 'Unknown key',\n path: key,\n };\n }\n\n if (unknownKeyPattern) {\n const result = testSubtree(subValue, unknownKeyPattern[0]);\n if (result) {\n result.path = _prependPath(key, result.path);\n return result;\n }\n }\n }\n }\n\n const keys = Object.keys(requiredPatterns);\n if (keys.length) {\n return {\n message: `Missing key '${keys[0]}'`,\n path: '',\n };\n }\n};\n\nclass ArgumentChecker {\n constructor (args, description) {\n\n // Make a SHALLOW copy of the arguments. (We'll be doing identity checks\n // against its contents.)\n this.args = [...args];\n\n // Since the common case will be to check arguments in order, and we splice\n // out arguments when we check them, make it so we splice out from the end\n // rather than the beginning.\n this.args.reverse();\n this.description = description;\n }\n\n checking(value) {\n if (this._checkingOneValue(value)) {\n return;\n }\n\n // Allow check(arguments, [String]) or check(arguments.slice(1), [String])\n // or check([foo, bar], [String]) to count... but only if value wasn't\n // itself an argument.\n if (Array.isArray(value) || isArguments(value)) {\n Array.prototype.forEach.call(value, this._checkingOneValue.bind(this));\n }\n }\n\n _checkingOneValue(value) {\n for (let i = 0; i < this.args.length; ++i) {\n\n // Is this value one of the arguments? (This can have a false positive if\n // the argument is an interned primitive, but it's still a good enough\n // check.)\n // (NaN is not === to itself, so we have to check specially.)\n if (value === this.args[i] ||\n (Number.isNaN(value) && Number.isNaN(this.args[i]))) {\n this.args.splice(i, 1);\n return true;\n }\n }\n return false;\n }\n\n throwUnlessAllArgumentsHaveBeenChecked() {\n if (this.args.length > 0)\n throw new Error(`Did not check() all arguments during ${this.description}`);\n }\n}\n\nconst _jsKeywords = ['do', 'if', 'in', 'for', 'let', 'new', 'try', 'var', 'case',\n 'else', 'enum', 'eval', 'false', 'null', 'this', 'true', 'void', 'with',\n 'break', 'catch', 'class', 'const', 'super', 'throw', 'while', 'yield',\n 'delete', 'export', 'import', 'public', 'return', 'static', 'switch',\n 'typeof', 'default', 'extends', 'finally', 'package', 'private', 'continue',\n 'debugger', 'function', 'arguments', 'interface', 'protected', 'implements',\n 'instanceof'];\n\n// Assumes the base of path is already escaped properly\n// returns key + base\nconst _prependPath = (key, base) => {\n if ((typeof key) === 'number' || key.match(/^[0-9]+$/)) {\n key = `[${key}]`;\n } else if (!key.match(/^[a-z_$][0-9a-z_$]*$/i) ||\n _jsKeywords.indexOf(key) >= 0) {\n key = JSON.stringify([key]);\n }\n\n if (base && base[0] !== '[') {\n return `${key}.${base}`;\n }\n\n return key + base;\n}\n\nconst isObject = value => typeof value === 'object' && value !== null;\n\nconst baseIsArguments = item =>\n isObject(item) &&\n Object.prototype.toString.call(item) === '[object Arguments]';\n\nconst isArguments = baseIsArguments(function() { return arguments; }()) ?\n baseIsArguments :\n value => isObject(value) && typeof value.callee === 'function';\n","// Copy of jQuery.isPlainObject for the server side from jQuery v3.1.1.\n\nconst class2type = {};\n\nconst toString = class2type.toString;\n\nconst hasOwn = Object.prototype.hasOwnProperty;\n\nconst fnToString = hasOwn.toString;\n\nconst ObjectFunctionString = fnToString.call(Object);\n\nconst getProto = Object.getPrototypeOf;\n\nexport const isPlainObject = obj => {\n let proto;\n let Ctor;\n\n // Detect obvious negatives\n // Use toString instead of jQuery.type to catch host objects\n if (!obj || toString.call(obj) !== '[object Object]') {\n return false;\n }\n\n proto = getProto(obj);\n\n // Objects with no prototype (e.g., `Object.create( null )`) are plain\n if (!proto) {\n return true;\n }\n\n // Objects with prototype are plain iff they were constructed by a global Object function\n Ctor = hasOwn.call(proto, 'constructor') && proto.constructor;\n return typeof Ctor === 'function' && \n fnToString.call(Ctor) === ObjectFunctionString;\n};\n"]}