@talend/react-components/lib/JSONSchemaRenderer/JSONSchemaRenderer.component.js

Set of react components.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _propTypes = _interopRequireDefault(require("prop-types"));
var _classnames = _interopRequireDefault(require("classnames"));
var _JSONSchemaRendererModule = _interopRequireDefault(require("./JSONSchemaRenderer.module.scss"));
var _lodash = require("lodash");
var _jsxRuntime = require("react/jsx-runtime");
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
const CLASS_NAME = 'json-schema-renderer';
const RendererProptypes = {
  propertyKey: _propTypes.default.string.isRequired,
  title: _propTypes.default.string
};
const SchemaProptypes = {
  jsonSchema: _propTypes.default.object.isRequired,
  uiSchema: _propTypes.default.shape({
    'ui:order': _propTypes.default.array
  }),
  properties: _propTypes.default.object.isRequired
};

/**
 * UnknownTypeException
 *
 * @param {string} type - The Unknown type
 * @returns {Object} An UnknownTypeException
 */
function UnknownTypeException(type) {
  this.name = 'UnknownTypeException';
  this.message = `Unknown type: ${type}`;
}

/**
 * InvalidSchemaException
 *
 * @returns {Object} An InvalidSchemaException
 */
function InvalidSchemaException() {
  this.name = 'InvalidSchemaException';
  this.message = 'Invalid Schema';
}

/**
 * NullRenderer renders nothing to hide specified properties
 * or properties that don't have a corresponding schema definition
 *
 * @returns null
 */
function NullRenderer() {
  return null;
}

/**
 * TextRenderer renders text based properties (string and numbers)
 */
function TextRenderer({
  propertyKey,
  title,
  properties
}) {
  return [/*#__PURE__*/(0, _jsxRuntime.jsx)("dt", {
    children: title || propertyKey
  }, `${propertyKey}_key`), /*#__PURE__*/(0, _jsxRuntime.jsx)("dd", {
    children: properties
  }, `${propertyKey}_value`)];
}
TextRenderer.propTypes = {
  ...RendererProptypes,
  properties: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number]).isRequired
};
function PasswordRenderer({
  propertyKey,
  title
}) {
  return [/*#__PURE__*/(0, _jsxRuntime.jsx)("dt", {
    children: title || propertyKey
  }, `${propertyKey}_key`), /*#__PURE__*/(0, _jsxRuntime.jsx)("dd", {
    children: '\u2022'.repeat(5)
  }, `${propertyKey}_value`)];
}
PasswordRenderer.propTypes = {
  ...RendererProptypes,
  properties: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number]).isRequired
};

/**
 * booleanRenderer renders boolean properties
 */
function BooleanRenderer({
  propertyKey,
  title,
  properties
}) {
  return [/*#__PURE__*/(0, _jsxRuntime.jsx)("dt", {
    children: title || propertyKey
  }, `${propertyKey}_key`), /*#__PURE__*/(0, _jsxRuntime.jsx)("dd", {
    children: properties
  }, `${propertyKey}_value`)];
}
BooleanRenderer.propTypes = {
  ...RendererProptypes,
  properties: _propTypes.default.bool.isRequired
};

/**
 * arrayRenderer renders an array of properties
 */
function ArrayRenderer({
  propertyKey,
  title,
  properties
}) {
  return [/*#__PURE__*/(0, _jsxRuntime.jsx)("dt", {
    children: title || propertyKey
  }, `${propertyKey}_key`)].concat(properties.map((val, i) => /*#__PURE__*/(0, _jsxRuntime.jsx)("dd", {
    className: _JSONSchemaRendererModule.default['array-value'],
    children: val
  }, `${propertyKey}-value-${i}`)));
}
ArrayRenderer.propTypes = {
  ...RendererProptypes,
  properties: _propTypes.default.arrayOf(_propTypes.default.shape({
    ...RendererProptypes
  })).isRequired
};
const registry = {
  string: TextRenderer,
  integer: TextRenderer,
  boolean: BooleanRenderer,
  array: ArrayRenderer,
  object: ObjectRenderer // eslint-disable-line @typescript-eslint/no-use-before-define
};
function isHidden(uiSchema, element) {
  return uiSchema && uiSchema[element] && uiSchema[element]['ui:widget'] === 'hidden';
}
function isPassword(uiSchema, element) {
  return (0, _lodash.get)(uiSchema, [element, 'ui:widget'], '') === 'password';
}

/**
 * typeResolver
 *
 * @param schema - The JSONSchema of the data being rendered
 * @param uiSchema
 * @throws {UnknownTypeException} Type must be part of the registry
 * @returns {Object} Resolved Renderer and props
 */
function typeResolver(schema, uiSchema) {
  return function resolver(e) {
    if (!schema[e[0]]) {
      return {
        render: NullRenderer
      };
    }
    if (isHidden(uiSchema, e[0])) {
      return {
        render: NullRenderer
      };
    }
    const type = schema[e[0]].type;
    const title = schema[e[0]].title;
    if (isPassword(uiSchema, e[0])) {
      return {
        render: PasswordRenderer,
        propertyKey: e[0],
        title,
        properties: e[1],
        schema,
        uiSchema
      };
    }
    const renderer = registry[type];
    if (!renderer) {
      throw new UnknownTypeException(type);
    }
    return {
      render: renderer,
      propertyKey: e[0],
      title,
      properties: e[1],
      schema,
      uiSchema
    };
  };
}

/**
 * orderProperties sorts properties based on uiSchema ui:order array
 *
 * @param order
 * @param properties
 * @returns {Array}
 */
function orderProperties(order, properties) {
  if (!order) {
    return properties;
  }
  return properties.sort((a, b) => {
    const aIndex = order.indexOf(a[0]);
    const bIndex = order.indexOf(b[0]);
    if (aIndex < 0) {
      return 1;
    }
    if (bIndex < 0) {
      return -1;
    }
    return aIndex - bIndex;
  });
}

/**
 * objectRenderer renders nested properties
 */
function ObjectRenderer({
  propertyKey,
  title,
  uiSchema,
  schema,
  properties,
  ...props
}) {
  return [/*#__PURE__*/(0, _jsxRuntime.jsx)("dt", {
    children: /*#__PURE__*/(0, _jsxRuntime.jsx)("h2", {
      children: title || propertyKey
    })
  }, `${propertyKey}_key`), /*#__PURE__*/(0, _jsxRuntime.jsx)("dd", {
    children: /*#__PURE__*/(0, _jsxRuntime.jsx)(JSONSchemaRenderer, {
      schema: {
        jsonSchema: schema[propertyKey],
        uiSchema: uiSchema[propertyKey],
        properties
      },
      className: _JSONSchemaRendererModule.default.nested,
      ...props
    })
  }, `${propertyKey}_value`)];
}
ObjectRenderer.propTypes = {
  ...RendererProptypes,
  schema: _propTypes.default.shape(SchemaProptypes)
};

/**
 * JSONSchemaRenderer renders elements based on a JSONSchema and data
 *
 * @throws {InvalidSchemaException} schema must contain a jsonSchema and
 * properties
 * @returns {string} - HTML markup for the component
 */
function JSONSchemaRenderer({
  schema,
  className,
  ...props
}) {
  if (!schema.jsonSchema || !schema.properties) {
    throw new InvalidSchemaException();
  }
  let properties = (0, _lodash.entries)(schema.properties);
  if (schema.uiSchema) {
    properties = orderProperties(schema.uiSchema['ui:order'], properties);
  }
  const elements = properties.map(typeResolver(schema.jsonSchema.properties, schema.uiSchema));
  return /*#__PURE__*/(0, _jsxRuntime.jsx)("dl", {
    className: (0, _classnames.default)(_JSONSchemaRendererModule.default[CLASS_NAME], 'json-schema-renderer', className),
    ...props,
    children: elements.map(({
      render,
      ...rest
    }) => render(rest))
  });
}
JSONSchemaRenderer.displayName = 'JSONSchemaRenderer';
JSONSchemaRenderer.propTypes = {
  schema: _propTypes.default.shape(SchemaProptypes),
  className: _propTypes.default.string
};
JSONSchemaRenderer.InvalidSchemaException = InvalidSchemaException;
JSONSchemaRenderer.UnknownTypeException = UnknownTypeException;
var _default = exports.default = JSONSchemaRenderer;
//# sourceMappingURL=JSONSchemaRenderer.component.js.map