@airtasker/form-schema-compiler/lib/utils.js

a form schema compiler

"use strict";

exports.__esModule = true;
exports.createProgram = exports.createIdentifier = exports.createValue = exports.createCallExpression = exports.isVersionCompatible = exports.hasKey = undefined;

var _const = require("./const");

function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }

function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

var hasKey = exports.hasKey = function hasKey(obj, key) {
  return Object.prototype.hasOwnProperty.call(obj, key);
};

var semvarToArray = function semvarToArray(version) {
  return version.split(".");
};

var normalizeVersion = function normalizeVersion(versions) {
  return versions.map(function (version) {
    return version.padStart(4, '0');
  }).join('');
};

var isVersionCompatible = exports.isVersionCompatible = function isVersionCompatible(version) {
  var versions = semvarToArray(version);

  if (versions.length !== 3) {
    throw new Error("can't recognize your schema version: ".concat(version));
  }

  var _COMPATIBLE_SCHEMA_VE = _const.COMPATIBLE_SCHEMA_VERSION.map(semvarToArray),
      _COMPATIBLE_SCHEMA_VE2 = _slicedToArray(_COMPATIBLE_SCHEMA_VE, 2),
      min = _COMPATIBLE_SCHEMA_VE2[0],
      max = _COMPATIBLE_SCHEMA_VE2[1];

  var versionStr = normalizeVersion(versions);
  var minStr = normalizeVersion(min);
  var maxStr = normalizeVersion(max);
  return versionStr >= minStr && versionStr <= maxStr;
};

var createCallExpression = exports.createCallExpression = function createCallExpression(callee) {
  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
    args[_key - 1] = arguments[_key];
  }

  return {
    type: _const.TYPES.CallExpression,
    callee: callee,
    arguments: args
  };
};

var createValue = exports.createValue = function createValue(value) {
  if (value === null) {
    return {
      type: _const.TYPES.Null,
      value: null
    };
  }

  var type = _typeof(value);

  switch (type) {
    case "string":
      return {
        type: _const.TYPES.String,
        value: value
      };

    case "number":
      return {
        type: _const.TYPES.Numeric,
        value: value
      };

    case "boolean":
      return {
        type: _const.TYPES.Boolean,
        value: value
      };

    case "object":
      if (value instanceof RegExp) {
        return {
          type: _const.TYPES.RegExp,
          pattern: value.source,
          flags: value.flags
        };
      }

  }

  throw new Error("un recognizable value");
};

var createIdentifier = exports.createIdentifier = function createIdentifier(name) {
  return {
    type: _const.TYPES.Identifier,
    name: name
  };
};

var createProgram = exports.createProgram = function createProgram(body) {
  var isProgram = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
  return {
    type: isProgram ? _const.TYPES.Program : _const.TYPES.BlockStatement,
    body: Array.isArray(body) ? body : [body]
  };
};