{"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"]}