@jsonforms/core
Version:
Core module of JSON Forms
1,421 lines (1,387 loc) • 117 kB
JavaScript
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var isEmpty = require('lodash/isEmpty');
var startCase = require('lodash/startCase');
var keys = require('lodash/keys');
var range = require('lodash/range');
var get = require('lodash/get');
var has = require('lodash/has');
var find = require('lodash/find');
var isArray = require('lodash/isArray');
var includes = require('lodash/includes');
var Ajv = require('ajv');
var addFormats = require('ajv-formats');
var filter = require('lodash/filter');
var isEqual = require('lodash/isEqual');
var merge = require('lodash/merge');
var cloneDeep = require('lodash/cloneDeep');
var setFp = require('lodash/fp/set');
var unsetFp = require('lodash/fp/unset');
var isFunction = require('lodash/isFunction');
var maxBy = require('lodash/maxBy');
var remove = require('lodash/remove');
var endsWith = require('lodash/endsWith');
var last = require('lodash/last');
var reduce = require('lodash/reduce');
var toPairs = require('lodash/toPairs');
var isUndefined = require('lodash/isUndefined');
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
var isEmpty__default = /*#__PURE__*/_interopDefaultLegacy(isEmpty);
var startCase__default = /*#__PURE__*/_interopDefaultLegacy(startCase);
var keys__default = /*#__PURE__*/_interopDefaultLegacy(keys);
var range__default = /*#__PURE__*/_interopDefaultLegacy(range);
var get__default = /*#__PURE__*/_interopDefaultLegacy(get);
var has__default = /*#__PURE__*/_interopDefaultLegacy(has);
var find__default = /*#__PURE__*/_interopDefaultLegacy(find);
var isArray__default = /*#__PURE__*/_interopDefaultLegacy(isArray);
var includes__default = /*#__PURE__*/_interopDefaultLegacy(includes);
var Ajv__default = /*#__PURE__*/_interopDefaultLegacy(Ajv);
var addFormats__default = /*#__PURE__*/_interopDefaultLegacy(addFormats);
var filter__default = /*#__PURE__*/_interopDefaultLegacy(filter);
var isEqual__default = /*#__PURE__*/_interopDefaultLegacy(isEqual);
var merge__default = /*#__PURE__*/_interopDefaultLegacy(merge);
var cloneDeep__default = /*#__PURE__*/_interopDefaultLegacy(cloneDeep);
var setFp__default = /*#__PURE__*/_interopDefaultLegacy(setFp);
var unsetFp__default = /*#__PURE__*/_interopDefaultLegacy(unsetFp);
var isFunction__default = /*#__PURE__*/_interopDefaultLegacy(isFunction);
var maxBy__default = /*#__PURE__*/_interopDefaultLegacy(maxBy);
var remove__default = /*#__PURE__*/_interopDefaultLegacy(remove);
var endsWith__default = /*#__PURE__*/_interopDefaultLegacy(endsWith);
var last__default = /*#__PURE__*/_interopDefaultLegacy(last);
var reduce__default = /*#__PURE__*/_interopDefaultLegacy(reduce);
var toPairs__default = /*#__PURE__*/_interopDefaultLegacy(toPairs);
var isUndefined__default = /*#__PURE__*/_interopDefaultLegacy(isUndefined);
var ADDITIONAL_PROPERTIES = 'additionalProperties';
var REQUIRED_PROPERTIES = 'required';
var distinct = function (properties, discriminator) {
var known = {};
return properties.filter(function (item) {
var discriminatorValue = discriminator(item);
if (Object.prototype.hasOwnProperty.call(known, discriminatorValue)) {
return false;
}
else {
known[discriminatorValue] = true;
return true;
}
});
};
var Gen = (function () {
function Gen(findOption) {
var _this = this;
this.findOption = findOption;
this.schemaObject = function (data) {
var props = _this.properties(data);
var schema = {
type: 'object',
properties: props,
additionalProperties: _this.findOption(props)(ADDITIONAL_PROPERTIES),
};
var required = _this.findOption(props)(REQUIRED_PROPERTIES);
if (required.length > 0) {
schema.required = required;
}
return schema;
};
this.properties = function (data) {
var emptyProps = {};
return Object.keys(data).reduce(function (acc, propName) {
acc[propName] = _this.property(data[propName]);
return acc;
}, emptyProps);
};
this.property = function (data) {
switch (typeof data) {
case 'string':
return { type: 'string' };
case 'boolean':
return { type: 'boolean' };
case 'number':
if (Number.isInteger(data)) {
return { type: 'integer' };
}
return { type: 'number' };
case 'object':
if (data == null) {
return { type: 'null' };
}
return _this.schemaObjectOrArray(data);
default:
return {};
}
};
this.schemaObjectOrArray = function (data) {
if (data instanceof Array) {
return _this.schemaArray(data);
}
else {
return _this.schemaObject(data);
}
};
this.schemaArray = function (data) {
if (data.length > 0) {
var allProperties = data.map(_this.property);
var uniqueProperties = distinct(allProperties, function (prop) {
return JSON.stringify(prop);
});
if (uniqueProperties.length === 1) {
return {
type: 'array',
items: uniqueProperties[0],
};
}
else {
return {
type: 'array',
items: {
oneOf: uniqueProperties,
},
};
}
}
else {
return {
type: 'array',
items: {},
};
}
};
}
return Gen;
}());
var generateJsonSchema = function (
instance, options) {
if (options === void 0) { options = {}; }
var findOption = function (props) {
return function (optionName) {
switch (optionName) {
case ADDITIONAL_PROPERTIES:
if (Object.prototype.hasOwnProperty.call(options, ADDITIONAL_PROPERTIES)) {
return options[ADDITIONAL_PROPERTIES];
}
return true;
case REQUIRED_PROPERTIES:
if (Object.prototype.hasOwnProperty.call(options, REQUIRED_PROPERTIES)) {
return options[REQUIRED_PROPERTIES](props);
}
return Object.keys(props);
default:
return;
}
};
};
var gen = new Gen(findOption);
return gen.schemaObject(instance);
};
var usedIds = new Set();
var makeId = function (idBase, iteration) {
return iteration <= 1 ? idBase : idBase + iteration.toString();
};
var isUniqueId = function (idBase, iteration) {
var newID = makeId(idBase, iteration);
return !usedIds.has(newID);
};
var createId = function (proposedId) {
if (proposedId === undefined) {
proposedId = 'undefined';
}
var tries = 0;
while (!isUniqueId(proposedId, tries)) {
tries++;
}
var newID = makeId(proposedId, tries);
usedIds.add(newID);
return newID;
};
var removeId = function (id) { return usedIds.delete(id); };
var clearAllIds = function () { return usedIds.clear(); };
var compose = function (path1, path2) {
var p1 = path1;
if (!isEmpty__default["default"](path1) && !isEmpty__default["default"](path2) && !path2.startsWith('[')) {
p1 = path1 + '.';
}
if (isEmpty__default["default"](p1)) {
return path2;
}
else if (isEmpty__default["default"](path2)) {
return p1;
}
else {
return "".concat(p1).concat(path2);
}
};
var toDataPathSegments = function (schemaPath) {
var s = schemaPath
.replace(/(anyOf|allOf|oneOf)\/[\d]+\//g, '')
.replace(/(then|else)\//g, '');
var segments = s.split('/');
var decodedSegments = segments.map(decode);
var startFromRoot = decodedSegments[0] === '#' || decodedSegments[0] === '';
var startIndex = startFromRoot ? 2 : 1;
return range__default["default"](startIndex, decodedSegments.length, 2).map(function (idx) { return decodedSegments[idx]; });
};
var toDataPath = function (schemaPath) {
return toDataPathSegments(schemaPath).join('.');
};
var encode = function (segment) {
return segment === null || segment === void 0 ? void 0 : segment.replace(/~/g, '~0').replace(/\//g, '~1');
};
var decode = function (pointerSegment) {
return pointerSegment === null || pointerSegment === void 0 ? void 0 : pointerSegment.replace(/~1/g, '/').replace(/~0/, '~');
};
var getPropPath = function (path) {
return "/properties/".concat(path
.split('.')
.map(function (p) { return encode(p); })
.join('/properties/'));
};
var deriveLabel = function (controlElement, schemaElement) {
if (schemaElement && typeof schemaElement.title === 'string') {
return schemaElement.title;
}
if (typeof controlElement.scope === 'string') {
var ref = controlElement.scope;
var label = decode(ref.substr(ref.lastIndexOf('/') + 1));
return startCase__default["default"](label);
}
return '';
};
var createCleanLabel = function (label) {
return startCase__default["default"](label.replace('_', ' '));
};
var createLabelDescriptionFrom = function (withLabel, schema) {
var labelProperty = withLabel.label;
if (typeof labelProperty === 'boolean') {
return labelDescription(deriveLabel(withLabel, schema), labelProperty);
}
if (typeof labelProperty === 'string') {
return labelDescription(labelProperty, true);
}
if (typeof labelProperty === 'object') {
var label = typeof labelProperty.text === 'string'
? labelProperty.text
: deriveLabel(withLabel, schema);
var show = typeof labelProperty.show === 'boolean' ? labelProperty.show : true;
return labelDescription(label, show);
}
return labelDescription(deriveLabel(withLabel, schema), true);
};
var labelDescription = function (text, show) { return ({
text: text,
show: show,
}); };
/******************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
var __assign = function() {
__assign = Object.assign || function __assign(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
function __rest(s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
}
function __spreadArray(to, from, pack) {
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
}
typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
var e = new Error(message);
return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
};
var isObjectSchema$1 = function (schema) {
return schema.properties !== undefined;
};
var isArraySchema = function (schema) {
return schema.type === 'array' && schema.items !== undefined;
};
var resolveData = function (instance, dataPath) {
if (isEmpty__default["default"](dataPath)) {
return instance;
}
var dataPathSegments = dataPath.split('.');
return dataPathSegments.reduce(function (curInstance, decodedSegment) {
if (!curInstance ||
!Object.prototype.hasOwnProperty.call(curInstance, decodedSegment)) {
return undefined;
}
return curInstance[decodedSegment];
}, instance);
};
var findAllRefs = function (schema, result, resolveTuples) {
if (result === void 0) { result = {}; }
if (resolveTuples === void 0) { resolveTuples = false; }
if (isObjectSchema$1(schema)) {
Object.keys(schema.properties).forEach(function (key) {
return findAllRefs(schema.properties[key], result);
});
}
if (isArraySchema(schema)) {
if (Array.isArray(schema.items)) {
if (resolveTuples) {
var items = schema.items;
items.forEach(function (child) { return findAllRefs(child, result); });
}
}
else {
findAllRefs(schema.items, result);
}
}
if (Array.isArray(schema.anyOf)) {
var anyOf = schema.anyOf;
anyOf.forEach(function (child) { return findAllRefs(child, result); });
}
if (schema.$ref !== undefined) {
result[schema.$ref] = schema;
}
return result;
};
var invalidSegment = function (pathSegment) {
return pathSegment === '#' || pathSegment === undefined || pathSegment === '';
};
var resolveSchema = function (schema, schemaPath, rootSchema) {
var segments = schemaPath === null || schemaPath === void 0 ? void 0 : schemaPath.split('/').map(decode);
return resolveSchemaWithSegments(schema, segments, rootSchema);
};
var resolveSchemaWithSegments = function (schema, pathSegments, rootSchema) {
var _a, _b, _c, _d, _e;
if (typeof (schema === null || schema === void 0 ? void 0 : schema.$ref) === 'string') {
schema = resolveSchema(rootSchema, schema.$ref, rootSchema);
}
if (!pathSegments || pathSegments.length === 0) {
return schema;
}
if (isEmpty__default["default"](schema)) {
return undefined;
}
var segment = pathSegments[0], remainingSegments = pathSegments.slice(1);
if (invalidSegment(segment)) {
return resolveSchemaWithSegments(schema, remainingSegments, rootSchema);
}
var singleSegmentResolveSchema = get__default["default"](schema, segment);
var resolvedSchema = resolveSchemaWithSegments(singleSegmentResolveSchema, remainingSegments, rootSchema);
if (resolvedSchema) {
return resolvedSchema;
}
if (segment === 'properties' || segment === 'items') {
var alternativeResolveResult = undefined;
var subSchemas = [].concat((_a = schema.oneOf) !== null && _a !== void 0 ? _a : [], (_b = schema.allOf) !== null && _b !== void 0 ? _b : [], (_c = schema.anyOf) !== null && _c !== void 0 ? _c : [], (_d = schema.then) !== null && _d !== void 0 ? _d : [], (_e = schema.else) !== null && _e !== void 0 ? _e : []);
for (var _i = 0, subSchemas_1 = subSchemas; _i < subSchemas_1.length; _i++) {
var subSchema = subSchemas_1[_i];
alternativeResolveResult = resolveSchemaWithSegments(subSchema, __spreadArray([segment], remainingSegments, true), rootSchema);
if (alternativeResolveResult) {
break;
}
}
return alternativeResolveResult;
}
return undefined;
};
var Draft4 = {
id: 'http://json-schema.org/draft-04/schema#',
$schema: 'http://json-schema.org/draft-04/schema#',
description: 'Core schema meta-schema',
definitions: {
schemaArray: {
type: 'array',
minItems: 1,
items: { $ref: '#' },
},
positiveInteger: {
type: 'integer',
minimum: 0,
},
positiveIntegerDefault0: {
allOf: [{ $ref: '#/definitions/positiveInteger' }, { default: 0 }],
},
simpleTypes: {
enum: [
'array',
'boolean',
'integer',
'null',
'number',
'object',
'string',
],
},
stringArray: {
type: 'array',
items: { type: 'string' },
minItems: 1,
uniqueItems: true,
},
},
type: 'object',
properties: {
id: {
type: 'string',
format: 'uri',
},
$schema: {
type: 'string',
format: 'uri',
},
title: {
type: 'string',
},
description: {
type: 'string',
},
default: {},
multipleOf: {
type: 'number',
minimum: 0,
exclusiveMinimum: true,
},
maximum: {
type: 'number',
},
exclusiveMaximum: {
type: 'boolean',
default: false,
},
minimum: {
type: 'number',
},
exclusiveMinimum: {
type: 'boolean',
default: false,
},
maxLength: { $ref: '#/definitions/positiveInteger' },
minLength: { $ref: '#/definitions/positiveIntegerDefault0' },
pattern: {
type: 'string',
format: 'regex',
},
additionalItems: {
anyOf: [{ type: 'boolean' }, { $ref: '#' }],
default: {},
},
items: {
anyOf: [{ $ref: '#' }, { $ref: '#/definitions/schemaArray' }],
default: {},
},
maxItems: { $ref: '#/definitions/positiveInteger' },
minItems: { $ref: '#/definitions/positiveIntegerDefault0' },
uniqueItems: {
type: 'boolean',
default: false,
},
maxProperties: { $ref: '#/definitions/positiveInteger' },
minProperties: { $ref: '#/definitions/positiveIntegerDefault0' },
required: { $ref: '#/definitions/stringArray' },
additionalProperties: {
anyOf: [{ type: 'boolean' }, { $ref: '#' }],
default: {},
},
definitions: {
type: 'object',
additionalProperties: { $ref: '#' },
default: {},
},
properties: {
type: 'object',
additionalProperties: { $ref: '#' },
default: {},
},
patternProperties: {
type: 'object',
additionalProperties: { $ref: '#' },
default: {},
},
dependencies: {
type: 'object',
additionalProperties: {
anyOf: [{ $ref: '#' }, { $ref: '#/definitions/stringArray' }],
},
},
enum: {
type: 'array',
minItems: 1,
uniqueItems: true,
},
type: {
anyOf: [
{ $ref: '#/definitions/simpleTypes' },
{
type: 'array',
items: { $ref: '#/definitions/simpleTypes' },
minItems: 1,
uniqueItems: true,
},
],
},
allOf: { $ref: '#/definitions/schemaArray' },
anyOf: { $ref: '#/definitions/schemaArray' },
oneOf: { $ref: '#/definitions/schemaArray' },
not: { $ref: '#' },
},
dependencies: {
exclusiveMaximum: ['maximum'],
exclusiveMinimum: ['minimum'],
},
default: {},
};
exports.RuleEffect = void 0;
(function (RuleEffect) {
RuleEffect["HIDE"] = "HIDE";
RuleEffect["SHOW"] = "SHOW";
RuleEffect["ENABLE"] = "ENABLE";
RuleEffect["DISABLE"] = "DISABLE";
})(exports.RuleEffect || (exports.RuleEffect = {}));
var setReadonlyPropertyValue = function (value) {
return function (child) {
if (!child.options) {
child.options = {};
}
child.options.readonly = value;
};
};
var setReadonly = function (uischema) {
iterateSchema(uischema, setReadonlyPropertyValue(true));
};
var unsetReadonly = function (uischema) {
iterateSchema(uischema, setReadonlyPropertyValue(false));
};
var iterateSchema = function (uischema, toApply) {
if (isEmpty__default["default"](uischema)) {
return;
}
if (isLayout(uischema)) {
uischema.elements.forEach(function (child) { return iterateSchema(child, toApply); });
return;
}
toApply(uischema);
};
var findUiControl = function (uiSchema, path) {
var _a;
if (isControlElement(uiSchema)) {
if (isScoped(uiSchema) && uiSchema.scope.endsWith(getPropPath(path))) {
return uiSchema;
}
else if ((_a = uiSchema.options) === null || _a === void 0 ? void 0 : _a.detail) {
return findUiControl(uiSchema.options.detail, path);
}
}
if (isLayout(uiSchema)) {
for (var _i = 0, _b = uiSchema.elements; _i < _b.length; _i++) {
var elem = _b[_i];
var result = findUiControl(elem, path);
if (result !== undefined)
return result;
}
}
return undefined;
};
var composeWithUi = function (scopableUi, path) {
if (!isScoped(scopableUi)) {
return path !== null && path !== void 0 ? path : '';
}
var segments = toDataPathSegments(scopableUi.scope);
if (isEmpty__default["default"](segments)) {
return path !== null && path !== void 0 ? path : '';
}
return compose(path, segments.join('.'));
};
var isInternationalized = function (element) {
return typeof element === 'object' &&
element !== null &&
typeof element.i18n === 'string';
};
var isGroup = function (layout) {
return layout.type === 'Group';
};
var isLayout = function (uischema) {
return uischema.elements !== undefined;
};
var isScopable = function (obj) {
return !!obj && typeof obj === 'object';
};
var isScoped = function (obj) {
return isScopable(obj) && typeof obj.scope === 'string';
};
var isLabelable = function (obj) {
return !!obj && typeof obj === 'object';
};
var isLabeled = function (obj) {
return isLabelable(obj) && ['string', 'boolean'].includes(typeof obj.label);
};
var isControlElement = function (uiSchema) { return uiSchema.type === 'Control'; };
var isOrCondition = function (condition) {
return condition.type === 'OR';
};
var isAndCondition = function (condition) {
return condition.type === 'AND';
};
var isLeafCondition = function (condition) {
return condition.type === 'LEAF';
};
var isSchemaCondition = function (condition) { return has__default["default"](condition, 'schema'); };
var isValidateFunctionCondition = function (condition) {
return has__default["default"](condition, 'validate') &&
typeof condition.validate === 'function';
};
var getConditionScope = function (condition, path) {
return composeWithUi(condition, path);
};
var evaluateCondition = function (data, uischema, condition, path, ajv) {
if (isAndCondition(condition)) {
return condition.conditions.reduce(function (acc, cur) { return acc && evaluateCondition(data, uischema, cur, path, ajv); }, true);
}
else if (isOrCondition(condition)) {
return condition.conditions.reduce(function (acc, cur) { return acc || evaluateCondition(data, uischema, cur, path, ajv); }, false);
}
else if (isLeafCondition(condition)) {
var value = resolveData(data, getConditionScope(condition, path));
return value === condition.expectedValue;
}
else if (isSchemaCondition(condition)) {
var value = resolveData(data, getConditionScope(condition, path));
if (condition.failWhenUndefined && value === undefined) {
return false;
}
return ajv.validate(condition.schema, value);
}
else if (isValidateFunctionCondition(condition)) {
var value = resolveData(data, getConditionScope(condition, path));
var context = {
data: value,
fullData: data,
path: path,
uischemaElement: uischema,
};
return condition.validate(context);
}
else {
return true;
}
};
var isRuleFulfilled = function (uischema, data, path, ajv) {
var condition = uischema.rule.condition;
return evaluateCondition(data, uischema, condition, path, ajv);
};
var evalVisibility = function (uischema, data, path, ajv) {
if (path === void 0) { path = undefined; }
var fulfilled = isRuleFulfilled(uischema, data, path, ajv);
switch (uischema.rule.effect) {
case exports.RuleEffect.HIDE:
return !fulfilled;
case exports.RuleEffect.SHOW:
return fulfilled;
default:
return true;
}
};
var evalEnablement = function (uischema, data, path, ajv) {
if (path === void 0) { path = undefined; }
var fulfilled = isRuleFulfilled(uischema, data, path, ajv);
switch (uischema.rule.effect) {
case exports.RuleEffect.DISABLE:
return !fulfilled;
case exports.RuleEffect.ENABLE:
return fulfilled;
default:
return true;
}
};
var hasShowRule = function (uischema) {
if (uischema.rule &&
(uischema.rule.effect === exports.RuleEffect.SHOW ||
uischema.rule.effect === exports.RuleEffect.HIDE)) {
return true;
}
return false;
};
var hasEnableRule = function (uischema) {
if (uischema.rule &&
(uischema.rule.effect === exports.RuleEffect.ENABLE ||
uischema.rule.effect === exports.RuleEffect.DISABLE)) {
return true;
}
return false;
};
var isVisible = function (uischema, data, path, ajv) {
if (path === void 0) { path = undefined; }
if (uischema.rule) {
return evalVisibility(uischema, data, path, ajv);
}
return true;
};
var isEnabled = function (uischema, data, path, ajv) {
if (path === void 0) { path = undefined; }
if (uischema.rule) {
return evalEnablement(uischema, data, path, ajv);
}
return true;
};
var getFirstPrimitiveProp = function (schema) {
if (schema &&
typeof schema === 'object' &&
'properties' in schema &&
schema.properties) {
return find__default["default"](Object.keys(schema.properties), function (propName) {
var prop = schema.properties[propName];
return (prop &&
typeof prop === 'object' &&
'type' in prop &&
(prop.type === 'string' ||
prop.type === 'number' ||
prop.type === 'integer'));
});
}
return undefined;
};
var isOneOfEnumSchema = function (schema) {
return !!schema &&
Object.prototype.hasOwnProperty.call(schema, 'oneOf') &&
schema.oneOf &&
schema.oneOf.every(function (s) { return s.const !== undefined; });
};
var isEnumSchema = function (schema) {
return !!schema &&
typeof schema === 'object' &&
(Object.prototype.hasOwnProperty.call(schema, 'enum') ||
Object.prototype.hasOwnProperty.call(schema, 'const'));
};
var convertDateToString = function (date, format) {
var dateString = date.toISOString();
if (format === 'date-time') {
return dateString;
}
else if (format === 'date') {
return dateString.split('T')[0];
}
else if (format === 'time') {
return dateString.split('T')[1].split('.')[0];
}
return dateString;
};
var convertToValidClassName = function (s) {
return s.replace('#', 'root').replace(new RegExp('/', 'g'), '_');
};
var hasType = function (jsonSchema, expected) {
return includes__default["default"](deriveTypes(jsonSchema), expected);
};
var deriveTypes = function (jsonSchema) {
if (isEmpty__default["default"](jsonSchema)) {
return [];
}
if (!isEmpty__default["default"](jsonSchema.type) && typeof jsonSchema.type === 'string') {
return [jsonSchema.type];
}
if (isArray__default["default"](jsonSchema.type)) {
return jsonSchema.type;
}
if (!isEmpty__default["default"](jsonSchema.properties) ||
!isEmpty__default["default"](jsonSchema.additionalProperties)) {
return ['object'];
}
if (!isEmpty__default["default"](jsonSchema.items)) {
return ['array'];
}
if (!isEmpty__default["default"](jsonSchema.enum)) {
var types_1 = new Set();
jsonSchema.enum.forEach(function (enumElement) {
if (typeof enumElement === 'string') {
types_1.add('string');
}
else {
deriveTypes(enumElement).forEach(function (type) { return types_1.add(type); });
}
});
return Array.from(types_1);
}
if (!isEmpty__default["default"](jsonSchema.allOf)) {
var allOfType = find__default["default"](jsonSchema.allOf, function (schema) { return deriveTypes(schema).length !== 0; });
if (allOfType) {
return deriveTypes(allOfType);
}
}
return [];
};
var Resolve = {
schema: resolveSchema,
data: resolveData,
};
var fromScoped = function (scopable) {
return toDataPathSegments(scopable.scope).join('.');
};
var Paths = {
compose: compose,
fromScoped: fromScoped,
};
var Runtime = {
isEnabled: function (uischema, data, ajv) {
return isEnabled(uischema, data, undefined, ajv);
},
isVisible: function (uischema, data, ajv) {
return isVisible(uischema, data, undefined, ajv);
},
};
var createAjv = function (options) {
var ajv = new Ajv__default["default"](__assign({ allErrors: true, verbose: true, strict: false, addUsedSchema: false }, options));
addFormats__default["default"](ajv);
return ajv;
};
var validate = function (validator, data) {
if (validator === undefined) {
return [];
}
var valid = validator(data);
if (valid) {
return [];
}
return validator.errors;
};
var defaultDateFormat = 'YYYY-MM-DD';
var defaultTimeFormat = 'HH:mm:ss';
var defaultDateTimeFormat = 'YYYY-MM-DDTHH:mm:ss.sssZ';
var getInvalidProperty = function (error) {
switch (error.keyword) {
case 'required':
case 'dependencies':
return error.params.missingProperty;
case 'additionalProperties':
return error.params.additionalProperty;
default:
return undefined;
}
};
var getControlPath = function (error) {
var controlPath = error.dataPath || error.instancePath || '';
controlPath = controlPath.replace(/\//g, '.');
var invalidProperty = getInvalidProperty(error);
if (invalidProperty !== undefined && !controlPath.endsWith(invalidProperty)) {
controlPath = "".concat(controlPath, ".").concat(invalidProperty);
}
controlPath = controlPath.replace(/^./, '');
controlPath = decode(controlPath);
return controlPath;
};
var errorsAt = function (instancePath, schema, matchPath) {
return function (errors) {
var combinatorPaths = filter__default["default"](errors, function (error) { return error.keyword === 'oneOf' || error.keyword === 'anyOf'; }).map(function (error) { return getControlPath(error); });
return filter__default["default"](errors, function (error) {
if (filteredErrorKeywords.indexOf(error.keyword) !== -1 &&
!isOneOfEnumSchema(error.parentSchema)) {
return false;
}
var controlPath = getControlPath(error);
var result = matchPath(controlPath);
var parentSchema = error.parentSchema;
if (result &&
!isObjectSchema(parentSchema) &&
!isOneOfEnumSchema(parentSchema) &&
combinatorPaths.findIndex(function (p) { return instancePath.startsWith(p); }) !== -1) {
result = result && isEqual__default["default"](parentSchema, schema);
}
return result;
});
};
};
var isObjectSchema = function (schema) {
return (schema === null || schema === void 0 ? void 0 : schema.type) === 'object' || !!(schema === null || schema === void 0 ? void 0 : schema.properties);
};
var filteredErrorKeywords = [
'additionalProperties',
'allOf',
'anyOf',
'oneOf',
];
var formatErrorMessage = function (errors) {
if (errors === undefined || errors === null) {
return '';
}
return errors.join('\n');
};
var Helpers = {
createLabelDescriptionFrom: createLabelDescriptionFrom,
convertToValidClassName: convertToValidClassName,
};
var createLayout = function (layoutType) { return ({
type: layoutType,
elements: [],
}); };
var createControlElement = function (ref) { return ({
type: 'Control',
scope: ref,
}); };
var wrapInLayoutIfNecessary = function (uischema, layoutType) {
if (!isEmpty__default["default"](uischema) && !isLayout(uischema)) {
var verticalLayout = createLayout(layoutType);
verticalLayout.elements.push(uischema);
return verticalLayout;
}
return uischema;
};
var addLabel = function (layout, labelName) {
if (!isEmpty__default["default"](labelName)) {
var fixedLabel = startCase__default["default"](labelName);
if (isGroup(layout)) {
layout.label = fixedLabel;
}
else {
var label = {
type: 'Label',
text: fixedLabel,
};
layout.elements.push(label);
}
}
};
var isCombinator = function (jsonSchema) {
return (!isEmpty__default["default"](jsonSchema) &&
(!isEmpty__default["default"](jsonSchema.oneOf) ||
!isEmpty__default["default"](jsonSchema.anyOf) ||
!isEmpty__default["default"](jsonSchema.allOf)));
};
var generateUISchema = function (jsonSchema, schemaElements, currentRef, schemaName, layoutType, rootSchema) {
if (!isEmpty__default["default"](jsonSchema) && jsonSchema.$ref !== undefined) {
return generateUISchema(resolveSchema(rootSchema, jsonSchema.$ref, rootSchema), schemaElements, currentRef, schemaName, layoutType, rootSchema);
}
if (isCombinator(jsonSchema)) {
var controlObject = createControlElement(currentRef);
schemaElements.push(controlObject);
return controlObject;
}
var types = deriveTypes(jsonSchema);
if (types.length === 0) {
return null;
}
if (types.length > 1) {
var controlObject = createControlElement(currentRef);
schemaElements.push(controlObject);
return controlObject;
}
if (currentRef === '#' && types[0] === 'object') {
var layout_1 = createLayout(layoutType);
schemaElements.push(layout_1);
if (jsonSchema.properties && keys__default["default"](jsonSchema.properties).length > 1) {
addLabel(layout_1, schemaName);
}
if (!isEmpty__default["default"](jsonSchema.properties)) {
var nextRef_1 = currentRef + '/properties';
Object.keys(jsonSchema.properties).map(function (propName) {
var value = jsonSchema.properties[propName];
var ref = "".concat(nextRef_1, "/").concat(encode(propName));
if (value.$ref !== undefined) {
value = resolveSchema(rootSchema, value.$ref, rootSchema);
}
generateUISchema(value, layout_1.elements, ref, propName, layoutType, rootSchema);
});
}
return layout_1;
}
switch (types[0]) {
case 'object':
case 'array':
case 'string':
case 'number':
case 'integer':
case 'null':
case 'boolean': {
var controlObject = createControlElement(currentRef);
schemaElements.push(controlObject);
return controlObject;
}
default:
throw new Error('Unknown type: ' + JSON.stringify(jsonSchema));
}
};
var generateDefaultUISchema = function (jsonSchema, layoutType, prefix, rootSchema) {
if (layoutType === void 0) { layoutType = 'VerticalLayout'; }
if (prefix === void 0) { prefix = '#'; }
if (rootSchema === void 0) { rootSchema = jsonSchema; }
return wrapInLayoutIfNecessary(generateUISchema(jsonSchema, [], prefix, '', layoutType, rootSchema), layoutType);
};
var Generate = {
jsonSchema: generateJsonSchema,
uiSchema: generateDefaultUISchema,
controlElement: createControlElement,
};
var INIT = 'jsonforms/INIT';
var UPDATE_CORE = 'jsonforms/UPDATE_CORE';
var SET_AJV = 'jsonforms/SET_AJV';
var UPDATE_DATA = 'jsonforms/UPDATE';
var UPDATE_ERRORS = 'jsonforms/UPDATE_ERRORS';
var VALIDATE = 'jsonforms/VALIDATE';
var ADD_RENDERER = 'jsonforms/ADD_RENDERER';
var REMOVE_RENDERER = 'jsonforms/REMOVE_RENDERER';
var ADD_CELL = 'jsonforms/ADD_CELL';
var REMOVE_CELL = 'jsonforms/REMOVE_CELL';
var SET_CONFIG = 'jsonforms/SET_CONFIG';
var ADD_UI_SCHEMA = 'jsonforms/ADD_UI_SCHEMA';
var REMOVE_UI_SCHEMA = 'jsonforms/REMOVE_UI_SCHEMA';
var SET_SCHEMA = 'jsonforms/SET_SCHEMA';
var SET_UISCHEMA = 'jsonforms/SET_UISCHEMA';
var SET_VALIDATION_MODE = 'jsonforms/SET_VALIDATION_MODE';
var SET_LOCALE = 'jsonforms/SET_LOCALE';
var SET_TRANSLATOR = 'jsonforms/SET_TRANSLATOR';
var UPDATE_I18N = 'jsonforms/UPDATE_I18N';
var ADD_DEFAULT_DATA = 'jsonforms/ADD_DEFAULT_DATA';
var REMOVE_DEFAULT_DATA = 'jsonforms/REMOVE_DEFAULT_DATA';
var isUpdateArrayContext = function (context) {
if (!('type' in context)) {
return false;
}
if (typeof context.type !== 'string') {
return false;
}
switch (context.type) {
case 'ADD': {
return ('values' in context &&
Array.isArray(context.values) &&
context.values.length > 0);
}
case 'REMOVE': {
return ('indices' in context &&
Array.isArray(context.indices) &&
context.indices.length > 0 &&
context.indices.every(function (i) { return typeof i === 'number'; }));
}
case 'MOVE': {
return ('moves' in context &&
Array.isArray(context.moves) &&
context.moves.length > 0 &&
context.moves.every(function (m) {
return typeof m === 'object' &&
m !== null &&
'from' in m &&
'to' in m &&
typeof m.from === 'number' &&
typeof m.to === 'number';
}));
}
default:
return false;
}
};
var init = function (data, schema, uischema, options) {
if (schema === void 0) { schema = generateJsonSchema(data); }
return ({
type: INIT,
data: data,
schema: schema,
uischema: typeof uischema === 'object' ? uischema : generateDefaultUISchema(schema),
options: options,
});
};
var updateCore = function (data, schema, uischema, options) { return ({
type: UPDATE_CORE,
data: data,
schema: schema,
uischema: uischema,
options: options,
}); };
var registerDefaultData = function (schemaPath, data) { return ({
type: ADD_DEFAULT_DATA,
schemaPath: schemaPath,
data: data,
}); };
var unregisterDefaultData = function (schemaPath) { return ({
type: REMOVE_DEFAULT_DATA,
schemaPath: schemaPath,
}); };
var setAjv = function (ajv) { return ({
type: SET_AJV,
ajv: ajv,
}); };
var update = function (path, updater, context) { return ({
type: UPDATE_DATA,
path: path,
updater: updater,
context: context,
}); };
var updateErrors = function (errors) { return ({
type: UPDATE_ERRORS,
errors: errors,
}); };
var registerRenderer = function (tester, renderer) { return ({
type: ADD_RENDERER,
tester: tester,
renderer: renderer,
}); };
var registerCell = function (tester, cell) { return ({
type: ADD_CELL,
tester: tester,
cell: cell,
}); };
var unregisterCell = function (tester, cell) { return ({
type: REMOVE_CELL,
tester: tester,
cell: cell,
}); };
var unregisterRenderer = function (tester, renderer) { return ({
type: REMOVE_RENDERER,
tester: tester,
renderer: renderer,
}); };
var setConfig = function (config) { return ({
type: SET_CONFIG,
config: config,
}); };
var setValidationMode = function (validationMode) { return ({
type: SET_VALIDATION_MODE,
validationMode: validationMode,
}); };
var registerUISchema = function (tester, uischema) {
return {
type: ADD_UI_SCHEMA,
tester: tester,
uischema: uischema,
};
};
var unregisterUISchema = function (tester) {
return {
type: REMOVE_UI_SCHEMA,
tester: tester,
};
};
var setLocale = function (locale) { return ({
type: SET_LOCALE,
locale: locale,
}); };
var setSchema = function (schema) { return ({
type: SET_SCHEMA,
schema: schema,
}); };
var setTranslator = function (translator, errorTranslator) { return ({
type: SET_TRANSLATOR,
translator: translator,
errorTranslator: errorTranslator,
}); };
var updateI18n = function (locale, translator, errorTranslator) { return ({
type: UPDATE_I18N,
locale: locale,
translator: translator,
errorTranslator: errorTranslator,
}); };
var setUISchema = function (uischema) { return ({
type: SET_UISCHEMA,
uischema: uischema,
}); };
var index$1 = /*#__PURE__*/Object.freeze({
__proto__: null,
INIT: INIT,
UPDATE_CORE: UPDATE_CORE,
SET_AJV: SET_AJV,
UPDATE_DATA: UPDATE_DATA,
UPDATE_ERRORS: UPDATE_ERRORS,
VALIDATE: VALIDATE,
ADD_RENDERER: ADD_RENDERER,
REMOVE_RENDERER: REMOVE_RENDERER,
ADD_CELL: ADD_CELL,
REMOVE_CELL: REMOVE_CELL,
SET_CONFIG: SET_CONFIG,
ADD_UI_SCHEMA: ADD_UI_SCHEMA,
REMOVE_UI_SCHEMA: REMOVE_UI_SCHEMA,
SET_SCHEMA: SET_SCHEMA,
SET_UISCHEMA: SET_UISCHEMA,
SET_VALIDATION_MODE: SET_VALIDATION_MODE,
SET_LOCALE: SET_LOCALE,
SET_TRANSLATOR: SET_TRANSLATOR,
UPDATE_I18N: UPDATE_I18N,
ADD_DEFAULT_DATA: ADD_DEFAULT_DATA,
REMOVE_DEFAULT_DATA: REMOVE_DEFAULT_DATA,
isUpdateArrayContext: isUpdateArrayContext,
init: init,
updateCore: updateCore,
registerDefaultData: registerDefaultData,
unregisterDefaultData: unregisterDefaultData,
setAjv: setAjv,
update: update,
updateErrors: updateErrors,
registerRenderer: registerRenderer,
registerCell: registerCell,
unregisterCell: unregisterCell,
unregisterRenderer: unregisterRenderer,
setConfig: setConfig,
setValidationMode: setValidationMode,
registerUISchema: registerUISchema,
unregisterUISchema: unregisterUISchema,
setLocale: setLocale,
setSchema: setSchema,
setTranslator: setTranslator,
updateI18n: updateI18n,
setUISchema: setUISchema
});
var cellReducer = function (state, _a) {
if (state === void 0) { state = []; }
var type = _a.type, tester = _a.tester, cell = _a.cell;
switch (type) {
case ADD_CELL:
return state.concat([{ tester: tester, cell: cell }]);
case REMOVE_CELL:
return state.filter(function (t) { return t.tester !== tester; });
default:
return state;
}
};
var configDefault = {
restrict: false,
trim: false,
showUnfocusedDescription: false,
hideRequiredAsterisk: false,
};
var applyDefaultConfiguration = function (config) {
if (config === void 0) { config = {}; }
return merge__default["default"]({}, configDefault, config);
};
var configReducer = function (state, action) {
if (state === void 0) { state = applyDefaultConfiguration(); }
switch (action.type) {
case SET_CONFIG:
return applyDefaultConfiguration(action.config);
default:
return state;
}
};
var initState = {
data: {},
schema: {},
uischema: undefined,
errors: [],
validator: undefined,
ajv: undefined,
validationMode: 'ValidateAndShow',
additionalErrors: [],
};
var getValidationMode = function (state, action) {
if (action && hasValidationModeOption(action.options)) {
return action.options.validationMode;
}
return state.validationMode;
};
var hasValidationModeOption = function (option) {
if (option) {
return option.validationMode !== undefined;
}
return false;
};
var hasAdditionalErrorsOption = function (option) {
if (option) {
return option.additionalErrors !== undefined;
}
return false;
};
var getAdditionalErrors = function (state, action) {
if (action && hasAdditionalErrorsOption(action.options)) {
return action.options.additionalErrors;
}
return state.additionalErrors;
};
var getOrCreateAjv = function (state, action) {
if (action) {
if (hasAjvOption(action.options)) {
return action.options.ajv;
}
else if (action.options !== undefined) {
if (isFunction__default["default"](action.options.compile)) {
return action.options;
}
}
}
return state.ajv ? state.ajv : createAjv();
};
var hasAjvOption = function (option) {
if (option) {
return option.ajv !== undefined;
}
return false;
};
var coreReducer = function (state, action) {
if (state === void 0) { state = initState; }
switch (action.type) {
case INIT: {
var thisAjv = getOrCreateAjv(state, action);
var validationMode = getValidationMode(state, action);
var v = validationMode === 'NoValidation'
? undefined
: thisAjv.compile(action.schema);
var e = validate(v, action.data);
var additionalErrors = getAdditionalErrors(state, action);
return __assign(__assign({}, state), { data: action.data, schema: action.schema, uischema: action.uischema, additionalErrors: additionalErrors, errors: e, validator: v, ajv: thisAjv, validationMode: validationMode });
}
case UPDATE_CORE: {
var thisAjv = getOrCreateAjv(state, action);
var validationMode = getValidationMode(state, action);
var validator = state.validator;
var errors = state.errors;
if (state.schema !== action.schema ||
state.validationMode !== validationMode ||
state.ajv !== thisAjv) {
validator =
validationMode === 'NoValidation'
? undefined
: thisAjv.compile(action.schema);
errors = validate(validator, action.data);
}
else if (state.data !== action.data) {
errors = validate(validator, action.data);
}
var additionalErrors = getAdditionalErrors(state, action);
var stateChanged = state.data !== action.data ||
state.schema !== action.schema ||
state.uischema !== action.uischema ||
state.ajv !== thisAjv ||
state.errors !== errors ||
state.validator !== validator ||
state.validationMode !== validationMode ||
state.additionalErrors !== additionalErrors;
return stateChanged
? __assign(__assign({}, state), { data: action.data, schema: action.schema, uischema: action.uischema, ajv: thisAjv, errors: isEqual__default["default"](errors, state.errors) ? state.errors : errors, validator: validator, validationMode: validationMode, additionalErrors: additionalErrors }) : state;
}
case SET_AJV: {
var currentAjv = action.ajv;
var validator = state.validationMode === 'NoValidation'
? undefined
: currentAjv.compile(state.schema);
var errors = validate(validator, state.data);
return __assign(__assign({}, state), { validator: validator, errors: errors });
}
case SET_SCHEMA: {
var needsNewValidator = action.schema && state.ajv && state.validationMode !== 'NoValidation';
var v = needsNewValidator
? state.ajv.compile(action.schema)
: state.validator;
var errors = validate(v, state.data);
return __assign(__assign({}, state), { validator: v, schema: action.schema, errors: errors });
}
case SET_UISCHEMA: {
return __assign(__assign({}, state), { uischema: action.uischema });
}
case UPDATE_DATA: {
if (action.path === undefined || action.path === null) {
return state;
}
else if (action.path === '') {
var result = action.updater(cloneDeep__default["default"](state.data));
var errors = valid