@tomino/dynamic-form-semantic-ui/dist/cjs/editor/schema/schema_panel.handlers.js

Semantic UI form renderer based on dynamic form generation

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const dynamic_form_1 = require("@tomino/dynamic-form");
const toolbelt_1 = require("@tomino/toolbelt");
const editor_common_1 = require("../editor_common");
const faker_options_1 = require("./faker_options");
const helpers_1 = require("../../helpers");
const typeVisibility = (types) => ({ owner }) => {
    return types.indexOf(owner.type) >= 0;
};
exports.objectVisibilityHandler = typeVisibility(['object']);
exports.stringVisibleHandler = typeVisibility(['string']);
exports.numberVisibleHandler = typeVisibility(['integer', 'number']);
exports.arrayVisibleHandler = typeVisibility(['array']);
exports.titleValueHandler = ({ owner, context }) => owner.title == null ? context.project.state.selectedSchemaName : owner.title;
exports.titleParseHandler = ({ context, args }) => context.project.renameSchema(args.current, context.schema);
exports.typeValueHandler = ({ owner }) => {
    return owner.$import || (owner.$ref && owner.$ref.split('/')[2]) || owner.type;
};
exports.itemsTypeValueHandler = ({ owner }) => {
    return exports.typeValueHandler({ owner: owner.items });
};
exports.typeParseHandler = ({ owner, args }) => owner.changeType(args.current, args.previous);
exports.itemsTypeParseHandler = ({ owner, args }) => {
    owner.getValue('items').changeType(args.current, args.previous);
};
exports.typeOptions = ({ owner }) => {
    let parent = editor_common_1.root(owner);
    if (!parent) {
        return [];
    }
    return [
        { text: 'Array', value: 'array' },
        { text: 'Boolean', value: 'boolean' },
        { text: 'Integer', value: 'integer' },
        { text: 'Number', value: 'number' },
        { text: 'Object', value: 'object' },
        { text: 'String', value: 'string' },
        { text: 'TYPES', value: '_types', disabled: true }
    ].concat(Array.from(parent.definitions.keys())
        .map(d => ({
        value: d,
        text: parent.definitions.get(d).title
    }))
        .sort((a, b) => (a.text < b.text ? -1 : 1)));
};
exports.atomicTypeVisibility = ({ owner }) => owner.getValue('type') === 'integer' ||
    owner.getValue('type') === 'number' ||
    owner.getValue('type') === 'boolean' ||
    owner.getValue('type') === 'string';
exports.fakedOptions = faker_options_1.fakerOptions;
exports.expressionValidationHandler = toolbelt_1.debounce(({ owner, context, args: { value, source } }) => {
    try {
        const schemaJson = helpers_1.schemaDatasetToJS(context.schema);
        const schema = new dynamic_form_1.Schema(schemaJson);
        const def = schema.defaultValue();
        dynamic_form_1.safeEval(def, value);
    }
    catch (ex) {
        owner.setError(source, ex.message);
        return;
    }
    owner.setError(source, null);
}, 300);
exports.formatOptions = () => [
    {
        text: 'None',
        value: ''
    },
    {
        text: 'ISO Date Time',
        value: 'date-time'
    },
    {
        text: 'Date',
        value: 'date'
    },
    {
        text: 'Time',
        value: 'time'
    },
    {
        text: 'Email',
        value: 'email'
    }
];
exports.regexValidateHandler = ({ owner, args: { value, source } }) => {
    try {
        new RegExp(value);
    }
    catch (ex) {
        owner.setError(source, ex.message);
    }
    return null;
};
exports.requiredValue = ({ context }) => {
    return ((context.selectedParentSchema &&
        context.selectedParentSchema.required &&
        context.selectedParentSchema.required.indexOf(context.project.state.selectedSchemaName) >=
            0) ||
        false);
};
exports.requiredParse = ({ args, context }) => {
    if (args.current) {
        context.selectedParentSchema.addRow('required', context.project.state.selectedSchemaName);
    }
    else {
        context.selectedParentSchema.removeRowData('required', context.project.state.selectedSchemaName);
    }
};
exports.requiredOptionsHandler = ({ owner }) => {
    let element = owner;
    while (!element.properties && !element.reference) {
        element = element.parent;
    }
    return Array.from(((element.reference && element.reference.properties) || element.properties).keys()).map(v => ({
        value: v,
        text: v
    }));
};
const validations = {
    string: [
        { value: 'format', text: 'Format' },
        { value: 'maxLength', text: 'Maximum Length' },
        { value: 'minLength', text: 'Minimum Length' },
        { value: 'pattern', text: 'Regular Expression' }
    ],
    array: [
        { value: 'maxItems', text: 'Maximum Items' },
        { value: 'minItems', text: 'Minimum Items' },
        { value: 'uniqueItems', text: 'Unique Items' }
    ],
    number: [
        { value: 'maximum', text: 'Maximum' },
        { value: 'minimum', text: 'Minimum' },
        { value: 'exclusiveMaximum', text: 'Exclusive Maximum' },
        { value: 'exclusiveMinimum', text: 'Exclusive Minimum' },
        { value: 'multipleOf', text: 'Multiple Of' }
    ],
    object: [{ value: 'required', text: 'Required' }]
};
exports.errorMessageVisibleHandler = ({ owner }) => typeof owner.errorMessage !== 'object';
exports.errorMessageOptions = ({ owner }) => validations[owner.getValue('type')] || [];
//# sourceMappingURL=schema_panel.handlers.js.map