@deskpro/react-forms/lib/Schema.js

Forms library for React

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.number = exports.string = undefined;

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; /**
                                                                                                                                                                                                                                                                   * @copyright 2015, Prometheus Research, LLC
                                                                                                                                                                                                                                                                   */

exports.Schema = Schema;
exports.object = object;
exports.array = array;
exports.validate = validate;
exports.select = select;

var _JSONSchema = require('./JSONSchema');

var _JSONSchema2 = _interopRequireDefault(_JSONSchema);

var _keyPath = require('./keyPath');

var _keyPath2 = _interopRequireDefault(_keyPath);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Create a React Forms schema validator.
 */
function Schema(schema, options) {
  options = _extends({}, options, {
    greedy: true,
    undefinedAsObject: true,
    nullAsObject: true,
    undefinedAsArray: true,
    nullAsUndefined: true,
    nullAsArray: true,
    nullAsBottomType: true
  });
  return (0, _JSONSchema2.default)(schema, options);
}

function _generateSchemaBuilder(type) {
  return function builder(params) {
    return _extends({
      type: type,
      isRequired: params ? !!params.isRequired : false
    }, params);
  };
}

function object(properties, params) {
  return _extends({
    type: 'object',
    properties: properties,
    required: Object.keys(properties).filter(function (k) {
      return properties[k].isRequired;
    }),
    isRequired: params ? !!params.isRequired : false
  }, params);
}

function array(items, params) {
  return _extends({
    type: 'array',
    items: items,
    isRequired: params ? !!params.isRequired : false
  }, params);
}

var string = exports.string = _generateSchemaBuilder('string');
var number = exports.number = _generateSchemaBuilder('number');

var NON_ENUMERABLE_PROP = {
  enumerable: false,
  writable: true,
  configurable: true
};

function cache(obj, key, value) {
  Object.defineProperty(obj, key, _extends({}, NON_ENUMERABLE_PROP, { value: value }));
}

function validate(schema, value, options) {
  if (!schema) {
    return [];
  }
  if (value.__schema === schema && value.__errorList) {
    return value.__errorList;
  } else {
    if (schema.__validator === undefined) {
      cache(schema, '__validator', Schema(schema, _extends({}, options, { formats: schema.formats })));
    }
    var errorList = schema.__validator(value);
    cache(value, '__schema', schema);
    cache(value, '__errorList', errorList);
    return errorList;
  }
}

function select(schema, keyPath) {
  keyPath = (0, _keyPath2.default)(keyPath);
  for (var i = 0, len = keyPath.length; i < len; i++) {
    if (!schema) {
      return schema;
    }
    schema = _select(schema, keyPath[i]);
  }
  return schema;
}

function _select(schema, key) {
  if (schema) {
    if (schema.type === 'object') {
      var subSchema = schema.properties ? schema.properties[key] : undefined;
      if (Array.isArray(schema.required)) {
        // transfer required info onto schema
        subSchema = _extends({
          type: 'object'
        }, subSchema, {
          isRequired: schema.required.indexOf(key) !== -1
        });
      }
      return subSchema;
    } else if (schema.type === 'array') {
      if (schema.items) {
        if (Array.isArray(schema.items)) {
          // eslint-disable-line max-depth
          return schema.items[key];
        } else {
          return schema.items;
        }
      } else {
        return undefined;
      }
    } else {
      throw new Error(JSON.stringify(schema) + ' ' + key);
    }
  }
}