@gravity-ui/page-constructor 6.3.2-alpha.7 → 6.3.2-alpha.9

package/build/cjs/form-generator/hooks/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"../../../../src","sources":["form-generator/hooks/types.ts"],"names":[],"mappings":"","sourcesContent":["import {\n    AnyOfInput,\n    ArrayObjectInput,\n    ArrayTextInput,\n    ConfigInput,\n    ObjectInput,\n    OneOfInput,\n} from '../../editor-v2';\n\nexport type FormField = ConfigInput & {id: string};\n\nexport type FormObjectField = ObjectInput & {id: string};\nexport type FormArrayField = (ArrayTextInput | ArrayObjectInput) & {\n    id: string;\n    properties?: FormField[];\n};\nexport type FormOneOfField = OneOfInput & {id: string};\nexport type FormAnyOfField = AnyOfInput & {id: string};\nexport type FormOptionsField = (OneOfInput | AnyOfInput) & {id: string};\n\nexport interface InputTypeMenuItem {\n    action: () => void;\n    text: string;\n    type: string;\n}\n\nexport interface ContentConfig {\n    [key: string]: unknown;\n}\n\nexport interface FormFieldsActions {\n    createField: (type: ConfigInput['type'], name?: string) => FormField;\n    addField: (type: ConfigInput['type']) => void;\n    removeField: (fieldId: string) => void;\n    updateField: (fieldId: string, updates: Partial<ConfigInput>) => void;\n\n    addObjectProperty: (objectId: string, type: ConfigInput['type']) => void;\n    removeObjectProperty: (fieldId: string, propertyIndex: number) => void;\n    updateObjectProperty: (\n        fieldId: string,\n        propertyIndex: number,\n        updates: Partial<ConfigInput>,\n    ) => void;\n\n    addOption: (fieldId: string) => void;\n    removeOption: (fieldId: string, optionIndex: number) => void;\n    addOptionProperty: (fieldId: string, optionIndex: number, type?: ConfigInput['type']) => void;\n    removeOptionProperty: (fieldId: string, optionIndex: number, propertyIndex: number) => void;\n    updateOptionProperty: (\n        fieldId: string,\n        optionIndex: number,\n        propertyIndex: number,\n        updates: Partial<ConfigInput>,\n    ) => void;\n\n    resetForm: () => void;\n}\n\nexport interface FormData {\n    formFields: Array<FormField>;\n}\n\nexport interface FormContextType extends FormData, FormFieldsActions {}\n"]}

package/build/cjs/form-generator/hooks/useFormFields.d.ts

@@ -0,0 +1,18 @@
+import { ConfigInput } from "../../editor-v2/index.js";
+import { FormField } from "./types.js";
+export declare const useFormFields: () => {
+    formFields: FormField[];
+    createField: (type: ConfigInput["type"], name?: string) => FormField;
+    addField: (type: ConfigInput["type"]) => void;
+    removeField: (fieldId: string) => void;
+    updateField: (fieldId: string, updates: Partial<ConfigInput>) => void;
+    addObjectProperty: (objectId: string, type?: ConfigInput["type"]) => void;
+    addOptionProperty: (fieldId: string, optionIndex: number, type?: ConfigInput["type"]) => void;
+    removeObjectProperty: (fieldId: string, propertyIndex: number) => void;
+    removeOptionProperty: (fieldId: string, optionIndex: number, propertyIndex: number) => void;
+    updateObjectProperty: (fieldId: string, propertyIndex: number, updates: Partial<ConfigInput>) => void;
+    updateOptionProperty: (fieldId: string, optionIndex: number, propertyIndex: number, updates: Partial<ConfigInput>) => void;
+    addOption: (fieldId: string) => void;
+    removeOption: (fieldId: string, optionIndex: number) => void;
+    resetForm: () => void;
+};

package/build/cjs/form-generator/hooks/useFormFields.js

@@ -0,0 +1,570 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFormFields = void 0;
+const tslib_1 = require("tslib");
+const React = tslib_1.__importStar(require("react"));
+const useFormFields = () => {
+    const [formFields, setFormFields] = React.useState([]);
+    const [nextId, setNextId] = React.useState(1);
+    const generateId = () => {
+        const id = `field_id_${nextId}`;
+        setNextId((prev) => prev + 1);
+        return id;
+    };
+    const generateName = () => {
+        const name = `field_${nextId}`;
+        return name;
+    };
+    const createField = (type, name = '') => {
+        const fieldName = name || generateName();
+        const fieldId = generateId();
+        let newField;
+        switch (type) {
+            case 'text':
+                newField = {
+                    type: 'text',
+                    name: fieldName,
+                    title: 'Text Input',
+                    id: fieldId,
+                };
+                break;
+            case 'number':
+                newField = {
+                    type: 'number',
+                    name: fieldName,
+                    title: 'Number Input',
+                    id: fieldId,
+                };
+                break;
+            case 'boolean':
+                newField = {
+                    type: 'boolean',
+                    name: fieldName,
+                    title: 'Boolean Input',
+                    id: fieldId,
+                };
+                break;
+            case 'textarea':
+                newField = {
+                    type: 'textarea',
+                    name: fieldName,
+                    title: 'Textarea Input',
+                    id: fieldId,
+                };
+                break;
+            case 'select':
+                newField = {
+                    type: 'select',
+                    name: fieldName,
+                    title: 'Select Input',
+                    view: 'select',
+                    mode: 'single',
+                    enum: [
+                        { content: 'Option 1', value: 'option1' },
+                        { content: 'Option 2', value: 'option2' },
+                    ],
+                    id: fieldId,
+                };
+                break;
+            case 'object':
+                newField = {
+                    type: 'object',
+                    name: fieldName,
+                    title: 'Object Input',
+                    properties: [
+                        {
+                            type: 'text',
+                            name: 'property1',
+                            title: 'Property 1',
+                            id: generateId(),
+                        },
+                    ],
+                    id: fieldId,
+                };
+                break;
+            case 'array':
+                newField = {
+                    type: 'array',
+                    name: fieldName,
+                    title: 'Array Input',
+                    buttonText: 'Add Item',
+                    arrayType: 'text',
+                    id: fieldId,
+                };
+                break;
+            case 'oneOf':
+                newField = {
+                    type: 'oneOf',
+                    name: fieldName,
+                    title: 'OneOf Input',
+                    options: [
+                        {
+                            title: 'Option A',
+                            value: 'optionA',
+                            properties: [
+                                {
+                                    type: 'text',
+                                    name: 'textField',
+                                    title: 'Text Field',
+                                    id: generateId(),
+                                },
+                            ],
+                        },
+                        {
+                            title: 'Option B',
+                            value: 'optionB',
+                            properties: [
+                                {
+                                    type: 'number',
+                                    name: 'numberField',
+                                    title: 'Number Field',
+                                    id: generateId(),
+                                },
+                            ],
+                        },
+                    ],
+                    id: fieldId,
+                };
+                break;
+            case 'anyOf':
+                newField = {
+                    type: 'anyOf',
+                    name: fieldName,
+                    title: 'AnyOf Input',
+                    options: [
+                        {
+                            title: 'Option A',
+                            value: 'optionA',
+                            properties: [
+                                {
+                                    type: 'text',
+                                    name: 'textField',
+                                    title: 'Text Field',
+                                    id: generateId(),
+                                },
+                            ],
+                        },
+                        {
+                            title: 'Option B',
+                            value: 'optionB',
+                            properties: [
+                                {
+                                    type: 'boolean',
+                                    name: 'booleanField',
+                                    title: 'Boolean Field',
+                                    id: generateId(),
+                                },
+                            ],
+                        },
+                    ],
+                    id: fieldId,
+                };
+                break;
+            default:
+                return createField('text', fieldName);
+        }
+        return newField;
+    };
+    const updateFieldById = (fields, fieldId, updates) => {
+        return fields.map((field) => {
+            if (field.id === fieldId) {
+                return { ...field, ...updates };
+            }
+            if (field.type === 'object' && field.properties) {
+                const objectField = field;
+                return {
+                    ...field,
+                    properties: updateFieldById(objectField.properties, fieldId, updates),
+                };
+            }
+            if ((field.type === 'oneOf' || field.type === 'anyOf') &&
+                field.options) {
+                const optionsField = field;
+                return {
+                    ...field,
+                    options: optionsField.options.map((option) => ({
+                        ...option,
+                        properties: updateFieldById(option.properties, fieldId, updates),
+                    })),
+                };
+            }
+            if (field.type === 'array' && field.arrayType === 'object') {
+                const arrayField = field;
+                return {
+                    ...field,
+                    properties: updateFieldById(arrayField.properties, fieldId, updates),
+                };
+            }
+            return field;
+        });
+    };
+    const addField = (type) => {
+        const newField = createField(type);
+        setFormFields((prev) => [...prev, newField]);
+    };
+    const removeField = (fieldId) => {
+        setFormFields((prev) => prev.filter((field) => field.id !== fieldId));
+    };
+    const updateField = (fieldId, updates) => {
+        setFormFields((prev) => updateFieldById(prev, fieldId, updates));
+    };
+    const addPropertyToObjectById = (fields, objectId, type = 'text') => {
+        return fields.map((field) => {
+            if (field.id === objectId && field.type === 'object') {
+                const objectField = field;
+                const propertyName = `property${(objectField.properties?.length || 0) + 1}`;
+                const newProperty = createField(type, propertyName);
+                return {
+                    ...field,
+                    properties: [...(objectField.properties || []), newProperty],
+                };
+            }
+            if (field.type === 'object' && field.properties) {
+                const objectField = field;
+                return {
+                    ...field,
+                    properties: addPropertyToObjectById(objectField.properties, objectId, type),
+                };
+            }
+            if ((field.type === 'oneOf' || field.type === 'anyOf') &&
+                field.options) {
+                const optionsField = field;
+                return {
+                    ...field,
+                    options: optionsField.options.map((option) => ({
+                        ...option,
+                        properties: addPropertyToObjectById(option.properties, objectId, type),
+                    })),
+                };
+            }
+            if (field.type === 'array' && field.arrayType === 'object') {
+                const arrayField = field;
+                if (field.id === objectId) {
+                    const propertyName = `property${(arrayField.properties?.length || 0) + 1}`;
+                    const newProperty = createField(type, propertyName);
+                    return {
+                        ...field,
+                        properties: [...(arrayField.properties || []), newProperty],
+                    };
+                }
+                if (arrayField.properties && arrayField.properties.length > 0) {
+                    return {
+                        ...field,
+                        properties: addPropertyToObjectById(arrayField.properties, objectId, type),
+                    };
+                }
+            }
+            return field;
+        });
+    };
+    const addObjectProperty = (objectId, type = 'text') => {
+        setFormFields((prev) => addPropertyToObjectById(prev, objectId, type));
+    };
+    const addOptionProperty = (fieldId, optionIndex, type = 'text') => {
+        const addPropertyToOptionRecursive = (fields, targetFieldId, targetOptionIndex) => {
+            return fields.map((field) => {
+                if (field.id === targetFieldId &&
+                    (field.type === 'oneOf' || field.type === 'anyOf')) {
+                    const updatedField = JSON.parse(JSON.stringify(field));
+                    const options = updatedField.options;
+                    if (options &&
+                        Array.isArray(options) &&
+                        targetOptionIndex >= 0 &&
+                        targetOptionIndex < options.length &&
+                        options[targetOptionIndex].properties) {
+                        const propertyName = `property${options[targetOptionIndex].properties.length + 1}`;
+                        const newProperty = createField(type, propertyName);
+                        options[targetOptionIndex].properties.push(newProperty);
+                    }
+                    return updatedField;
+                }
+                if (field.type === 'object' && field.properties) {
+                    const objectField = field;
+                    return {
+                        ...field,
+                        properties: addPropertyToOptionRecursive(objectField.properties, targetFieldId, targetOptionIndex),
+                    };
+                }
+                if ((field.type === 'oneOf' || field.type === 'anyOf') &&
+                    field.options) {
+                    const optionsField = field;
+                    return {
+                        ...field,
+                        options: optionsField.options.map((option) => ({
+                            ...option,
+                            properties: addPropertyToOptionRecursive(option.properties, targetFieldId, targetOptionIndex),
+                        })),
+                    };
+                }
+                if (field.type === 'array' &&
+                    field.arrayType === 'object' &&
+                    field.properties) {
+                    const arrayField = field;
+                    return {
+                        ...field,
+                        properties: addPropertyToOptionRecursive(arrayField.properties, targetFieldId, targetOptionIndex),
+                    };
+                }
+                return field;
+            });
+        };
+        setFormFields((prev) => addPropertyToOptionRecursive(prev, fieldId, optionIndex));
+    };
+    const removeObjectProperty = (fieldId, propertyIndex) => {
+        setFormFields((prev) => {
+            return prev.map((field) => {
+                if (field.id !== fieldId)
+                    return field;
+                const updatedField = JSON.parse(JSON.stringify(field));
+                const objectInput = updatedField;
+                objectInput.properties.splice(propertyIndex, 1);
+                return updatedField;
+            });
+        });
+    };
+    const removeOptionProperty = (fieldId, optionIndex, propertyIndex) => {
+        const removePropertyFromOptionRecursive = (fields, targetFieldId, targetOptionIndex, targetPropertyIndex) => {
+            return fields.map((field) => {
+                if (field.id === targetFieldId &&
+                    (field.type === 'oneOf' || field.type === 'anyOf')) {
+                    const updatedField = JSON.parse(JSON.stringify(field));
+                    const options = updatedField.options;
+                    if (options &&
+                        Array.isArray(options) &&
+                        targetOptionIndex >= 0 &&
+                        targetOptionIndex < options.length &&
+                        options[targetOptionIndex].properties &&
+                        targetPropertyIndex >= 0 &&
+                        targetPropertyIndex < options[targetOptionIndex].properties.length) {
+                        options[targetOptionIndex].properties.splice(targetPropertyIndex, 1);
+                    }
+                    return updatedField;
+                }
+                if (field.type === 'object' && field.properties) {
+                    const objectField = field;
+                    return {
+                        ...field,
+                        properties: removePropertyFromOptionRecursive(objectField.properties, targetFieldId, targetOptionIndex, targetPropertyIndex),
+                    };
+                }
+                if ((field.type === 'oneOf' || field.type === 'anyOf') &&
+                    field.options) {
+                    const optionsField = field;
+                    return {
+                        ...field,
+                        options: optionsField.options.map((option) => ({
+                            ...option,
+                            properties: removePropertyFromOptionRecursive(option.properties, targetFieldId, targetOptionIndex, targetPropertyIndex),
+                        })),
+                    };
+                }
+                if (field.type === 'array' &&
+                    field.arrayType === 'object' &&
+                    field.properties) {
+                    const arrayField = field;
+                    return {
+                        ...field,
+                        properties: removePropertyFromOptionRecursive(arrayField.properties, targetFieldId, targetOptionIndex, targetPropertyIndex),
+                    };
+                }
+                return field;
+            });
+        };
+        setFormFields((prev) => removePropertyFromOptionRecursive(prev, fieldId, optionIndex, propertyIndex));
+    };
+    const updateObjectProperty = (fieldId, propertyIndex, updates) => {
+        setFormFields((prev) => {
+            return prev.map((field) => {
+                if (field.id !== fieldId)
+                    return field;
+                const updatedField = JSON.parse(JSON.stringify(field));
+                const objectInput = updatedField;
+                objectInput.properties[propertyIndex] = {
+                    ...objectInput.properties[propertyIndex],
+                    ...updates,
+                };
+                return updatedField;
+            });
+        });
+    };
+    const updateOptionProperty = (fieldId, optionIndex, propertyIndex, updates) => {
+        const updatePropertyInOptionRecursive = (fields, targetFieldId, targetOptionIndex, targetPropertyIndex, propertyUpdates) => {
+            return fields.map((field) => {
+                if (field.id === targetFieldId &&
+                    (field.type === 'oneOf' || field.type === 'anyOf')) {
+                    const updatedField = JSON.parse(JSON.stringify(field));
+                    const options = updatedField.options;
+                    if (options &&
+                        Array.isArray(options) &&
+                        targetOptionIndex >= 0 &&
+                        targetOptionIndex < options.length &&
+                        options[targetOptionIndex].properties &&
+                        targetPropertyIndex >= 0 &&
+                        targetPropertyIndex < options[targetOptionIndex].properties.length) {
+                        options[targetOptionIndex].properties[targetPropertyIndex] = {
+                            ...options[targetOptionIndex].properties[targetPropertyIndex],
+                            ...propertyUpdates,
+                        };
+                    }
+                    return updatedField;
+                }
+                if (field.type === 'object' && field.properties) {
+                    const objectField = field;
+                    return {
+                        ...field,
+                        properties: updatePropertyInOptionRecursive(objectField.properties, targetFieldId, targetOptionIndex, targetPropertyIndex, propertyUpdates),
+                    };
+                }
+                if ((field.type === 'oneOf' || field.type === 'anyOf') &&
+                    field.options) {
+                    const optionsField = field;
+                    return {
+                        ...field,
+                        options: optionsField.options.map((option) => ({
+                            ...option,
+                            properties: updatePropertyInOptionRecursive(option.properties, targetFieldId, targetOptionIndex, targetPropertyIndex, propertyUpdates),
+                        })),
+                    };
+                }
+                if (field.type === 'array' &&
+                    field.arrayType === 'object' &&
+                    field.properties) {
+                    const arrayField = field;
+                    return {
+                        ...field,
+                        properties: updatePropertyInOptionRecursive(arrayField.properties, targetFieldId, targetOptionIndex, targetPropertyIndex, propertyUpdates),
+                    };
+                }
+                return field;
+            });
+        };
+        setFormFields((prev) => updatePropertyInOptionRecursive(prev, fieldId, optionIndex, propertyIndex, updates));
+    };
+    const addOption = (fieldId) => {
+        const addOptionRecursive = (fields, targetFieldId) => {
+            return fields.map((field) => {
+                if (field.id === targetFieldId &&
+                    (field.type === 'oneOf' || field.type === 'anyOf')) {
+                    const updatedField = JSON.parse(JSON.stringify(field));
+                    const options = updatedField.options;
+                    if (options && Array.isArray(options)) {
+                        const optionLetter = String.fromCharCode(65 + options.length);
+                        const newOption = {
+                            title: `Option ${optionLetter}`,
+                            value: `option${optionLetter.toLowerCase()}`,
+                            properties: [
+                                {
+                                    type: 'text',
+                                    name: 'textField',
+                                    title: 'Text Field',
+                                    id: generateId(),
+                                },
+                            ],
+                        };
+                        options.push(newOption);
+                    }
+                    return updatedField;
+                }
+                if (field.type === 'object' && field.properties) {
+                    const objectField = field;
+                    return {
+                        ...field,
+                        properties: addOptionRecursive(objectField.properties, targetFieldId),
+                    };
+                }
+                if ((field.type === 'oneOf' || field.type === 'anyOf') &&
+                    field.options) {
+                    const optionsField = field;
+                    return {
+                        ...field,
+                        options: optionsField.options.map((option) => ({
+                            ...option,
+                            properties: addOptionRecursive(option.properties, targetFieldId),
+                        })),
+                    };
+                }
+                if (field.type === 'array' &&
+                    field.arrayType === 'object' &&
+                    field.properties) {
+                    const arrayField = field;
+                    return {
+                        ...field,
+                        properties: addOptionRecursive(arrayField.properties, targetFieldId),
+                    };
+                }
+                return field;
+            });
+        };
+        setFormFields((prev) => addOptionRecursive(prev, fieldId));
+    };
+    const removeOption = (fieldId, optionIndex) => {
+        const removeOptionRecursive = (fields, targetFieldId, targetOptionIndex) => {
+            return fields.map((field) => {
+                if (field.id === targetFieldId &&
+                    (field.type === 'oneOf' || field.type === 'anyOf')) {
+                    const updatedField = JSON.parse(JSON.stringify(field));
+                    const options = updatedField.options;
+                    if (options &&
+                        Array.isArray(options) &&
+                        targetOptionIndex >= 0 &&
+                        targetOptionIndex < options.length) {
+                        if (options.length > 1) {
+                            options.splice(targetOptionIndex, 1);
+                        }
+                    }
+                    return updatedField;
+                }
+                if (field.type === 'object' && field.properties) {
+                    const objectField = field;
+                    return {
+                        ...field,
+                        properties: removeOptionRecursive(objectField.properties, targetFieldId, targetOptionIndex),
+                    };
+                }
+                if ((field.type === 'oneOf' || field.type === 'anyOf') &&
+                    field.options) {
+                    const optionsField = field;
+                    return {
+                        ...field,
+                        options: optionsField.options.map((option) => ({
+                            ...option,
+                            properties: removeOptionRecursive(option.properties, targetFieldId, targetOptionIndex),
+                        })),
+                    };
+                }
+                if (field.type === 'array' &&
+                    field.arrayType === 'object' &&
+                    field.properties) {
+                    const arrayField = field;
+                    return {
+                        ...field,
+                        properties: removeOptionRecursive(arrayField.properties, targetFieldId, targetOptionIndex),
+                    };
+                }
+                return field;
+            });
+        };
+        setFormFields((prev) => removeOptionRecursive(prev, fieldId, optionIndex));
+    };
+    const resetForm = () => {
+        setFormFields([]);
+    };
+    return {
+        formFields,
+        createField,
+        addField,
+        removeField,
+        updateField,
+        addObjectProperty,
+        addOptionProperty,
+        removeObjectProperty,
+        removeOptionProperty,
+        updateObjectProperty,
+        updateOptionProperty,
+        addOption,
+        removeOption,
+        resetForm,
+    };
+};
+exports.useFormFields = useFormFields;
+//# sourceMappingURL=useFormFields.js.map