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

Semantic UI form renderer based on dynamic form generation

import { safeEval, Schema } from '@tomino/dynamic-form';
import { debounce } from '@tomino/toolbelt';
import { root } from '../editor_common';
import { fakerOptions } from './faker_options';
import { schemaDatasetToJS } from '../../helpers';
const typeVisibility = (types) => ({ owner }) => {
    return types.indexOf(owner.type) >= 0;
};
export const objectVisibilityHandler = typeVisibility(['object']);
export const stringVisibleHandler = typeVisibility(['string']);
export const numberVisibleHandler = typeVisibility(['integer', 'number']);
export const arrayVisibleHandler = typeVisibility(['array']);
export const titleValueHandler = ({ owner, context }) => owner.title == null ? context.project.state.selectedSchemaName : owner.title;
export const titleParseHandler = ({ context, args }) => context.project.renameSchema(args.current, context.schema);
export const typeValueHandler = ({ owner }) => {
    return owner.$import || (owner.$ref && owner.$ref.split('/')[2]) || owner.type;
};
export const itemsTypeValueHandler = ({ owner }) => {
    return typeValueHandler({ owner: owner.items });
};
export const typeParseHandler = ({ owner, args }) => owner.changeType(args.current, args.previous);
export const itemsTypeParseHandler = ({ owner, args }) => {
    owner.getValue('items').changeType(args.current, args.previous);
};
export const typeOptions = ({ owner }) => {
    let parent = 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)));
};
export const atomicTypeVisibility = ({ owner }) => owner.getValue('type') === 'integer' ||
    owner.getValue('type') === 'number' ||
    owner.getValue('type') === 'boolean' ||
    owner.getValue('type') === 'string';
export const fakedOptions = fakerOptions;
export const expressionValidationHandler = debounce(({ owner, context, args: { value, source } }) => {
    try {
        const schemaJson = schemaDatasetToJS(context.schema);
        const schema = new Schema(schemaJson);
        const def = schema.defaultValue();
        safeEval(def, value);
    }
    catch (ex) {
        owner.setError(source, ex.message);
        return;
    }
    owner.setError(source, null);
}, 300);
export const formatOptions = () => [
    {
        text: 'None',
        value: ''
    },
    {
        text: 'ISO Date Time',
        value: 'date-time'
    },
    {
        text: 'Date',
        value: 'date'
    },
    {
        text: 'Time',
        value: 'time'
    },
    {
        text: 'Email',
        value: 'email'
    }
];
export const regexValidateHandler = ({ owner, args: { value, source } }) => {
    try {
        new RegExp(value);
    }
    catch (ex) {
        owner.setError(source, ex.message);
    }
    return null;
};
export const requiredValue = ({ context }) => {
    return ((context.selectedParentSchema &&
        context.selectedParentSchema.required &&
        context.selectedParentSchema.required.indexOf(context.project.state.selectedSchemaName) >=
            0) ||
        false);
};
export const requiredParse = ({ args, context }) => {
    if (args.current) {
        context.selectedParentSchema.addRow('required', context.project.state.selectedSchemaName);
    }
    else {
        context.selectedParentSchema.removeRowData('required', context.project.state.selectedSchemaName);
    }
};
export const 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' }]
};
export const errorMessageVisibleHandler = ({ owner }) => typeof owner.errorMessage !== 'object';
export const errorMessageOptions = ({ owner }) => validations[owner.getValue('type')] || [];
//# sourceMappingURL=schema_panel.handlers.js.map