tycho-components 0.21.19 → 0.22.0

package/dist/configs/Localization.js

@@ -14,6 +14,12 @@ import { SentenceTexts } from './localization/SentenceTexts';
 import { TreeTexts } from './localization/TreeTexts';
 import { ParametersTexts } from './localization/ParametersTexts';
 import { SentenceSplitTexts } from '../features/SentenceSplit/localization/SentenceSplitTexts';
+import { DocumentTexts } from '../features/DocumentDrawer/localization/DocumentTexts';
+import { ActionsTexts } from '../features/DocumentDrawer/localization/ActionsTexts';
+import PageTexts from '../features/DocumentDrawer/localization/PageTexts';
+import { ExportTexts } from '../features/DocumentDrawer/localization/ExportTexts';
+import { GithubTexts } from '../features/DocumentDrawer/localization/GithubTexts';
+import ParserTexts from '../features/DocumentDrawer/localization/ParserTexts';
 function buildResources(namespaces) {
     return {
         en: Object.fromEntries(Object.entries(namespaces).map(([key, texts]) => [key, texts.en])),
@@ -37,6 +43,12 @@ const FEATURE_NAMESPACES = {
     sentence: SentenceTexts,
     parameters: ParametersTexts,
     sentenceSplit: SentenceSplitTexts,
+    document: DocumentTexts,
+    actions: ActionsTexts,
+    page: PageTexts,
+    export: ExportTexts,
+    github: GithubTexts,
+    parser: ParserTexts,
 };
 export const commonResources = buildResources(CORE_NAMESPACES);
 export const featureResources = buildResources(FEATURE_NAMESPACES);

package/dist/features/DocumentDrawer/Actions/Actions.d.ts

@@ -0,0 +1,12 @@
+import CatalogSearchFilter from '../types/CatalogSearchFilter';
+import { Document } from '../deps';
+import './style.scss';
+type Props = {
+    document: Document;
+    setOpenFile: (b: boolean) => void;
+    setFilter: (p: CatalogSearchFilter) => void;
+    handleClickDocument: (uid: string) => void;
+    useGrid: boolean;
+};
+export default function Actions({ document, setOpenFile, setFilter, handleClickDocument, useGrid, }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/DocumentDrawer/Actions/Actions.js

@@ -0,0 +1,77 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import AutomaticParser from '../AutomaticParser';
+import DocumentRemove from '../DocumentRemove';
+import DocumentService from '../services/DocumentService';
+import SentenceService from '../services/SentenceService';
+import { useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { ToolsUtils, useMessageUtils } from '../deps';
+import { Icon } from 'tycho-storybook';
+import './style.scss';
+export default function Actions({ document, setOpenFile, setFilter, handleClickDocument, useGrid, }) {
+    const { t } = useTranslation(['actions', 'main']);
+    const [openRemove, setOpenRemove] = useState(false);
+    const { dispatchError, dispatchMessage } = useMessageUtils();
+    const [openAutomatic, setOpenAutomatic] = useState(false);
+    const handleResume = () => {
+        SentenceService.resume(document.uid).then((r) => {
+            if (!r.data) {
+                dispatchError({ err: 'warning.syntactic.review', t });
+                return;
+            }
+            window.open(`${import.meta.env.VITE_APP_REVISION_WEB_URL}/tree/${r.data.uid}`);
+        });
+    };
+    const handleReview = () => {
+        const baseUrl = import.meta.env.VITE_APP_REVISION_WEB_URL;
+        const url = document.defaultTool === 'DESIGN'
+            ? `${baseUrl}/box/${document.uid}`
+            : `${baseUrl}/${document.uid}`;
+        window.open(url);
+    };
+    const handleSyncSearch = () => {
+        DocumentService.syncSearch(document.uid)
+            .then(() => dispatchMessage({ key: 'sync.search.success', t }))
+            .catch(() => dispatchError({ err: 'error.unknown', t }));
+    };
+    const actionOptions = [
+        {
+            iconName: ToolsUtils.getIcon(document.defaultTool),
+            title: t('label.edition.title'),
+            description: t('label.edition.description'),
+            onClick: () => handleClickDocument(document.uid),
+            buttonClassName: document.defaultTool === 'DESIGN' ? 'action-design' : undefined,
+        },
+        {
+            iconName: 'graph_4',
+            title: t('label.syntactic.title'),
+            description: t('label.syntactic.description'),
+            onClick: handleReview,
+        },
+        {
+            iconName: 'play_arrow',
+            title: t('label.resume.title'),
+            description: t('label.resume.description'),
+            onClick: handleResume,
+        },
+        {
+            iconName: 'settings_timelapse',
+            title: t('label.automatic.title'),
+            description: t('label.automatic.description'),
+            onClick: () => setOpenAutomatic(true),
+        },
+        {
+            iconName: 'sync',
+            title: t('label.sync.title'),
+            description: t('label.sync.description'),
+            onClick: handleSyncSearch,
+        },
+        {
+            iconName: 'delete',
+            title: t('actions.label.remove'),
+            description: t('actions.label.remove.description'),
+            onClick: () => setOpenRemove(true),
+        },
+    ];
+    return (_jsxs("div", { className: "file-actions-container", children: [_jsx("div", { className: "header", children: _jsx("div", { className: "title", children: t('actions.label.title') }) }), _jsx("div", { className: "body", children: actionOptions.map(({ iconName, title, description, onClick, buttonClassName }) => (_jsxs("div", { className: "action-line", onClick: onClick, children: [_jsx("div", { className: `action-button${buttonClassName ? ` ${buttonClassName}` : ''}`, children: _jsx(Icon, { name: iconName, size: "medium" }) }), _jsxs("div", { className: "action-desc", children: [_jsx("span", { className: "title", children: title }), _jsx("span", { children: description })] })] }, iconName))) }), openRemove && (_jsx(DocumentRemove, { document: document, setFilter: setFilter, onClose: () => setOpenRemove(false), useGrid: useGrid, setOpenFile: setOpenFile })), openAutomatic && (_jsx(AutomaticParser, { document: document, onClose: () => setOpenAutomatic(false) }))] }));
+}

package/dist/features/DocumentDrawer/Actions/index.d.ts

@@ -0,0 +1,2 @@
+import Actions from './Actions';
+export default Actions;

package/dist/features/DocumentDrawer/Actions/index.js

@@ -0,0 +1,2 @@
+import Actions from './Actions';
+export default Actions;

package/dist/features/DocumentDrawer/Actions/style.scss

@@ -0,0 +1,6 @@
+.file-actions-container {
+  .body {
+    height: 90vh;
+    overflow-y: auto;
+  }
+}

package/dist/features/DocumentDrawer/AutomaticParser/AutomaticParser.d.ts

@@ -0,0 +1,8 @@
+import { Document } from '../deps';
+import './style.scss';
+type Props = {
+    document: Document;
+    onClose: () => void;
+};
+export default function AutomaticParser({ document, onClose }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/DocumentDrawer/AutomaticParser/AutomaticParser.js

@@ -0,0 +1,96 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import AutomaticParserService from '../services/AutomaticParserService';
+import { EMPTY_PARSER_REQUEST } from '../types/Parser';
+import { Box, FormControlLabel, LinearProgress, Switch, Typography, } from '@mui/material';
+import { useEffect, useRef, useState } from 'react';
+import { Trans, useTranslation } from 'react-i18next';
+import { AppLoading, AppModal, useMessageUtils, } from '../deps';
+import './style.scss';
+const timingCheck = 5000;
+export default function AutomaticParser({ document, onClose }) {
+    const { t } = useTranslation('parser');
+    const { dispatchMessage, dispatchError } = useMessageUtils();
+    const [checking, setChecking] = useState(true);
+    const [loading, setLoading] = useState(false);
+    const [completed, setCompleted] = useState(false);
+    const [percentage, setPercentage] = useState(0);
+    const [request, setRequest] = useState(EMPTY_PARSER_REQUEST);
+    const intervalCheckRef = useRef(null);
+    const handleChange = (field) => (event) => {
+        setRequest((prev) => ({ ...prev, [field]: event.target.checked }));
+    };
+    const calculatePercentage = (parsed, total, errors) => {
+        if (!total)
+            return 0;
+        const processed = parsed + errors;
+        return Math.min(100, (processed / total) * 100) || 0;
+    };
+    const check = () => {
+        AutomaticParserService.checkParsingStatus(document.uid)
+            .then((res) => {
+            const { parsed = 0, total = 0, completed, errors = 0, } = res?.data ?? {};
+            setChecking(false);
+            setPercentage(calculatePercentage(parsed, total, errors));
+            if (completed) {
+                setLoading(false);
+                if (intervalCheckRef.current) {
+                    clearInterval(intervalCheckRef.current);
+                    intervalCheckRef.current = null;
+                }
+                setCompleted(true);
+                dispatchMessage({
+                    key: 'msg.parser.completed',
+                    t,
+                    ns: 'parser',
+                });
+            }
+        })
+            .catch(() => setChecking(false));
+    };
+    const handleCheck = () => {
+        if (!document)
+            return;
+        setChecking(true);
+        AutomaticParserService.checkParsingStatus(document.uid)
+            .then((res) => {
+            const { completed } = res?.data ?? {};
+            setChecking(false);
+            if (!completed) {
+                setLoading(true);
+                intervalCheckRef.current = setInterval(check, timingCheck);
+            }
+        })
+            .catch(() => setChecking(false));
+    };
+    const handleConfirm = () => {
+        if (loading)
+            return;
+        setLoading(true);
+        AutomaticParserService.executeAutomaticParsing(document.uid, request)
+            .then(() => {
+            if (!intervalCheckRef.current) {
+                intervalCheckRef.current = setInterval(check, timingCheck);
+            }
+        })
+            .catch((err) => {
+            setLoading(false);
+            const message = err?.response?.data?.message || err?.message;
+            dispatchError({
+                err: message ?? 'error.start',
+                key: message ? 'message' : 'parser',
+                t,
+            });
+        });
+    };
+    useEffect(() => {
+        setPercentage(0);
+        handleCheck();
+        return () => {
+            if (intervalCheckRef.current) {
+                clearInterval(intervalCheckRef.current);
+                intervalCheckRef.current = null;
+            }
+        };
+    }, []);
+    return (_jsx(AppModal, { title: t('modal.automatic.title'), className: "modal-automatic-parser", close: onClose, confirm: completed ? onClose : handleConfirm, confirmLabel: completed ? t('modal.automatic.finish') : undefined, disableCancel: completed, disableConfirm: !completed && loading, children: checking ? (_jsx(AppLoading, {})) : (_jsxs(_Fragment, { children: [_jsx("p", { children: _jsx(Trans, { t: t, i18nKey: "modal.automatic.desc", components: { bold: _jsx("b", {}) } }) }), _jsx(FormControlLabel, { control: _jsx(Switch, { checked: request.reprocess, onChange: handleChange('reprocess') }), label: t('modal.automatic.reprocess') }), _jsx(FormControlLabel, { control: _jsx(Switch, { checked: request.resetTags, onChange: handleChange('resetTags') }), label: t('modal.automatic.reset') }), (loading || percentage > 0) && (_jsx(Box, { sx: { mt: 3 }, children: _jsxs(Box, { sx: { display: 'flex', alignItems: 'center', mb: 1 }, children: [_jsx(Box, { sx: { width: '100%', mr: 1 }, children: _jsx(LinearProgress, { variant: "determinate", value: percentage }) }), _jsx(Box, { sx: { minWidth: 60 }, children: _jsx(Typography, { variant: "body2", color: "text.secondary", children: `${percentage.toFixed(2)}%` }) })] }) }))] })) }));
+}

package/dist/features/DocumentDrawer/AutomaticParser/index.d.ts

@@ -0,0 +1,2 @@
+import AutomaticParser from './AutomaticParser';
+export default AutomaticParser;

package/dist/features/DocumentDrawer/AutomaticParser/index.js

@@ -0,0 +1,2 @@
+import AutomaticParser from './AutomaticParser';
+export default AutomaticParser;

package/dist/features/DocumentDrawer/AutomaticParser/style.scss

@@ -0,0 +1,10 @@
+.modal-automatic-parser {
+  > .body {
+    display: flex;
+    flex-direction: column;
+
+    .loading-container {
+      margin: 16px auto;
+    }
+  }
+}

package/dist/features/DocumentDrawer/DocumentDrawer.d.ts

@@ -0,0 +1,14 @@
+import CatalogSearchFilter from './types/CatalogSearchFilter';
+import Category from './types/Category';
+import { Document } from './deps';
+import './style.scss';
+export type DocumentDrawerProps = {
+    uid: string;
+    setOpenFile: (b: boolean) => void;
+    setFilter: (p: CatalogSearchFilter) => void;
+    handleChange: (document: Document) => void;
+    handleClickDocument: (uid: string) => void;
+    useGrid: boolean;
+    categoriesHierarchy: Category[];
+};
+export default function DocumentDrawer({ uid, setOpenFile, setFilter, handleChange, handleClickDocument, useGrid, categoriesHierarchy, }: DocumentDrawerProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/features/DocumentDrawer/DocumentDrawer.js

@@ -0,0 +1,111 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import documenService from './services/DocumentService';
+import { Drawer, Tab, Tabs } from '@mui/material';
+import { useEffect, useMemo, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { Participants, useCorpusUtils } from './deps';
+import { Icon } from 'tycho-storybook';
+import DocumentMetadata from './Metadata/DocumentMetadata';
+import Actions from './Actions';
+import DocumentExport from './DocumentExport';
+import DocumentLexicon from './DocumentLexicon';
+import Github from './Github';
+import ImageGallery from './ImageGallery';
+import Info from './Info';
+import Boxes from './Pages/Boxes';
+import Pages from './Pages/Pages';
+import './style.scss';
+export default function DocumentDrawer({ uid, setOpenFile, setFilter, handleChange, handleClickDocument, useGrid, categoriesHierarchy, }) {
+    const { t } = useTranslation('document');
+    const { getCorpus, hasParameter } = useCorpusUtils();
+    const [document, setDocument] = useState();
+    const [activeKey, setActiveKey] = useState('actions');
+    const hasParticipants = (document?.participants?.length ?? 0) > 0;
+    const fileItems = useMemo(() => {
+        if (!document)
+            return [];
+        let items = hasParticipants
+            ? baseFileItems
+            : baseFileItems.filter((item) => item.eventKey !== 'participants');
+        if (document.github) {
+            items = [...items, githubFileItem];
+        }
+        return items;
+    }, [document, hasParticipants]);
+    const handleTabChange = (_event, newValue) => {
+        setActiveKey(newValue);
+    };
+    const renderPages = () => {
+        if (!document)
+            return null;
+        if (document.defaultTool && document.defaultTool === 'DESIGN')
+            return (_jsx(Boxes, { document: document, setDocument: setDocument, setOpenFile: setOpenFile }));
+        return (_jsx(Pages, { document: document, setDocument: setDocument, setOpenFile: setOpenFile, handleChange: handleChange }));
+    };
+    useEffect(() => {
+        documenService.get(uid).then((response) => {
+            setDocument(response.data);
+        });
+    }, [uid]);
+    useEffect(() => {
+        if (!hasParticipants && activeKey === 'participants') {
+            setActiveKey('actions');
+        }
+    }, [activeKey, hasParticipants]);
+    if (!document)
+        return null;
+    return (_jsx(Drawer, { anchor: "left", open: true, onClose: () => setOpenFile(false), className: "offcanvas-file", children: _jsxs("div", { className: "drawer-container", children: [_jsxs("div", { className: "tabs-col", children: [_jsxs("div", { className: "nav-item-close", onClick: () => setOpenFile(false), children: [_jsx("span", { className: "nav-link-icon", children: _jsx(Icon, { name: "arrow_circle_left" }) }), _jsx("span", { className: "title", children: t('menu.label.close') })] }), _jsx(Tabs, { orientation: "vertical", value: activeKey, onChange: handleTabChange, className: "nav", children: fileItems.map((item, idx) => (_jsx(Tab, { value: item.eventKey, label: _jsxs(_Fragment, { children: [_jsx("span", { className: "nav-link-icon", children: _jsx(Icon, { name: item.icon, filled: true }) }), _jsx("span", { className: "title", children: t(item.title) })] }) }, idx.valueOf()))) })] }), _jsxs("div", { className: "info-col", children: [activeKey === 'home' && (_jsx(Info, { document: document, categoriesHierarchy: categoriesHierarchy, handleChange: (updated) => {
+                                handleChange(updated);
+                                setDocument(updated);
+                            } })), activeKey === 'metadata' && (_jsx(DocumentMetadata, { document: document, onDocumentChange: (updated) => {
+                                handleChange(updated);
+                                setDocument(updated);
+                            } })), activeKey === 'lexicon' && _jsx(DocumentLexicon, { document: document }), activeKey === 'export' && _jsx(DocumentExport, { doc: document }), activeKey === 'actions' && (_jsx(Actions, { document: document, setOpenFile: setOpenFile, setFilter: setFilter, handleClickDocument: handleClickDocument, useGrid: useGrid })), activeKey === 'pages' && renderPages(), activeKey === 'gallery' && (_jsx(ImageGallery, { document: document, setDocument: setDocument, handleChange: handleChange })), activeKey === 'participants' && (_jsx(Participants, { document: document.uid, participants: document.participants || [], onChange: (r) => setDocument({ ...document, participants: r }), useChat: hasParameter(getCorpus(), 'useParticipantChat') })), activeKey === 'github' && (_jsx(Github, { document: document, setOpenFile: setOpenFile }))] })] }) }));
+}
+const baseFileItems = [
+    {
+        eventKey: 'home',
+        icon: 'home',
+        title: 'menu.label.home',
+    },
+    {
+        eventKey: 'actions',
+        icon: 'manufacturing',
+        title: 'menu.label.actions',
+    },
+    {
+        eventKey: 'pages',
+        icon: 'article',
+        title: 'menu.label.pages',
+    },
+    {
+        eventKey: 'gallery',
+        icon: 'photo_library',
+        title: 'menu.label.images',
+    },
+    {
+        eventKey: 'metadata',
+        icon: 'bookmark',
+        title: 'menu.label.metadata',
+    },
+    {
+        eventKey: 'lexicon',
+        icon: 'sort_by_alpha',
+        title: 'menu.label.lexicon',
+    },
+    {
+        eventKey: 'export',
+        icon: 'file_export',
+        title: 'menu.label.export',
+    },
+    {
+        eventKey: 'participants',
+        icon: 'group',
+        title: 'menu.label.participants',
+    },
+];
+const githubFileItem = {
+    eventKey: 'github',
+    icon: 'code',
+    title: 'menu.label.github',
+};

package/dist/features/DocumentDrawer/DocumentEdit/DocumentEdit.d.ts

@@ -0,0 +1,35 @@
+import { DocumentStatus } from '../../../configs/types/Document';
+import Category from '../types/Category';
+import { TFunction } from 'i18next';
+import { AppFormField, Document, PlatformTools, yup } from '../deps';
+declare const baseFormSchema: yup.ObjectSchema<{
+    name: string;
+    translated: string;
+    author: string;
+    reference: string;
+    description: string;
+    category: string;
+    status: NonNullable<DocumentStatus | undefined>;
+    visible: NonNullable<boolean | undefined>;
+    defaultTool: NonNullable<PlatformTools | undefined>;
+}, yup.AnyObject, {
+    name: undefined;
+    translated: "";
+    author: "";
+    reference: "";
+    description: "";
+    category: "";
+    status: undefined;
+    visible: undefined;
+    defaultTool: undefined;
+}, "">;
+export type DocumentEditFormValues = yup.InferType<typeof baseFormSchema>;
+type Props = {
+    document: Document;
+    categoriesHierarchy: Category[];
+    onClose: () => void;
+    onSave: (document: Document) => void;
+};
+export default function DocumentEdit({ document, categoriesHierarchy, onClose, onSave, }: Props): import("react/jsx-runtime").JSX.Element;
+export declare const getDocumentFields: (categories: Category[], t: TFunction) => AppFormField[];
+export {};

package/dist/features/DocumentDrawer/DocumentEdit/DocumentEdit.js

@@ -0,0 +1,207 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import documentService from '../services/DocumentService';
+import { DocumentStatusNames, } from '../../../configs/types/Document';
+import { useEffect, useMemo, useState } from 'react';
+import { useForm } from 'react-hook-form';
+import { Trans, useTranslation } from 'react-i18next';
+import { AppForm, AppModal, AppModalConfirm, DateUtils, EDITION_TOOLS, FormUtils, ToolsUtils, UsabilityUtils, useCorpusUtils, useMessageUtils, yupResolver, yup, } from '../deps';
+const baseFormSchema = yup.object({
+    name: yup.string().trim().required(),
+    translated: yup.string().default(''),
+    author: yup.string().default(''),
+    reference: yup.string().default(''),
+    description: yup.string().default(''),
+    category: yup.string().default(''),
+    status: yup
+        .mixed()
+        .oneOf(['EDITING', 'EDITED', 'SYNTACTIC', 'COMPLETED'])
+        .required(),
+    visible: yup.boolean().required(),
+    defaultTool: yup.mixed().required(),
+});
+export default function DocumentEdit({ document, categoriesHierarchy, onClose, onSave, }) {
+    const { t } = useTranslation(['document', 'actions']);
+    const { dispatchMessage, dispatchError, dispatchLoading, isLoading } = useMessageUtils();
+    const { getCorpus, hasParameter } = useCorpusUtils();
+    const [openToolWarning, setOpenToolWarning] = useState(false);
+    const [pendingValues, setPendingValues] = useState(null);
+    const enabledToolNames = useMemo(() => {
+        const corpus = getCorpus();
+        if (!corpus)
+            return [];
+        const names = EDITION_TOOLS.filter((tool) => hasParameter(corpus, tool.parameter)).map((tool) => tool.name);
+        if (document.defaultTool && !names.includes(document.defaultTool)) {
+            return [...names, document.defaultTool];
+        }
+        return names;
+    }, [document.defaultTool, getCorpus, hasParameter]);
+    const formSchema = useMemo(() => baseFormSchema.shape({
+        defaultTool: yup
+            .mixed()
+            .oneOf(enabledToolNames)
+            .required(),
+    }), [enabledToolNames]);
+    const form = useForm({
+        resolver: yupResolver(formSchema),
+        mode: 'onChange',
+        defaultValues: {
+            name: document.name ?? '',
+            translated: document.translated ?? '',
+            author: document.author ?? '',
+            reference: document.reference ?? '',
+            description: document.description ?? '',
+            category: document.category ?? '',
+            status: document.status,
+            visible: document.visible ?? false,
+            defaultTool: document.defaultTool ?? 'EDICTOR',
+        },
+    });
+    const { formState } = form;
+    const isBusy = isLoading();
+    const performUpdate = (values) => {
+        const payload = { ...values };
+        const toolChanged = values.defaultTool !== document.defaultTool;
+        dispatchLoading(true);
+        documentService
+            .update(document.uid, payload)
+            .then(() => {
+            dispatchMessage({ key: 'update.success', t });
+            if (toolChanged) {
+                return documentService.get(document.uid).then((r) => r.data);
+            }
+            return { ...document, ...values };
+        })
+            .then((updated) => {
+            onSave(updated);
+            onClose();
+        })
+            .catch((err) => {
+            dispatchError({ err, t });
+        })
+            .finally(() => {
+            dispatchLoading(false);
+            setOpenToolWarning(false);
+            setPendingValues(null);
+        });
+    };
+    const onSubmit = (values) => {
+        if (isBusy)
+            return;
+        if (document.defaultTool === 'DESIGN' &&
+            values.defaultTool !== 'DESIGN') {
+            setPendingValues(values);
+            setOpenToolWarning(true);
+            return;
+        }
+        performUpdate(values);
+    };
+    useEffect(() => {
+        UsabilityUtils.attachCloseToEscape(onClose);
+    }, [onClose]);
+    const defaultToolField = useMemo(() => {
+        if (enabledToolNames.length === 0)
+            return undefined;
+        const options = EDITION_TOOLS.filter((tool) => enabledToolNames.includes(tool.name)).map((tool) => ({
+            value: tool.name,
+            label: t(tool.title),
+        }));
+        return {
+            attr: 'defaultTool',
+            name: t('document.field.defaultTool'),
+            type: 'select',
+            required: false,
+            options,
+        };
+    }, [enabledToolNames, t]);
+    const { mainFields, categoryField } = useMemo(() => {
+        const all = getDocumentFields(categoriesHierarchy, t);
+        const hasCategories = (categoriesHierarchy?.length ?? 0) > 0;
+        const filtered = all.filter((field) => field.attr !== 'id' &&
+            field.attr !== 'category' &&
+            field.attr !== 'defaultTool');
+        const fields = [...filtered];
+        if (defaultToolField) {
+            const visibleIdx = fields.findIndex((f) => f.attr === 'visible');
+            const insertAt = visibleIdx >= 0 ? visibleIdx + 1 : fields.length;
+            fields.splice(insertAt, 0, defaultToolField);
+        }
+        return {
+            mainFields: fields,
+            categoryField: hasCategories
+                ? all.find((field) => field.attr === 'category')
+                : undefined,
+        };
+    }, [categoriesHierarchy, t, defaultToolField]);
+    return (_jsxs(_Fragment, { children: [_jsx(AppModal, { title: t('document.modal.edit.title'), className: "modal-document-edit", close: onClose, confirm: form.handleSubmit(onSubmit), disableConfirm: !formState.isValid || isBusy, children: _jsxs("div", { style: {
+                        display: 'flex',
+                        flexDirection: 'column',
+                        gap: 16,
+                    }, children: [_jsx(AppForm, { fields: mainFields, form: form, twoColumns: true }), categoryField && (_jsx("div", { className: "document-edit-category-full-width", children: _jsx(AppForm, { fields: [categoryField], form: form }) }))] }) }), openToolWarning && (_jsx(AppModalConfirm, { title: t('modal.title.design', { ns: 'actions' }), subtitle: _jsx(Trans, { t: t, ns: "actions", i18nKey: "modal.description.design", components: { bold: _jsx("b", { className: "bold" }) } }), onClose: () => {
+                    setOpenToolWarning(false);
+                    setPendingValues(null);
+                }, onConfirm: () => pendingValues && performUpdate(pendingValues) }))] }));
+}
+export const getDocumentFields = (categories, t) => [
+    {
+        attr: 'name',
+        name: t('document.field.name'),
+        type: 'text',
+        required: false,
+    },
+    {
+        attr: 'translated',
+        name: t('document.field.translated'),
+        type: 'text',
+        required: false,
+    },
+    {
+        attr: 'author',
+        name: t('document.field.author'),
+        type: 'text',
+        required: false,
+    },
+    {
+        attr: 'reference',
+        name: t('document.field.reference'),
+        type: 'text',
+        required: false,
+    },
+    {
+        attr: 'category',
+        name: t('document.field.category'),
+        type: 'select',
+        required: false,
+        options: FormUtils.convertList(categories, 'name', 'uid'),
+    },
+    {
+        attr: 'status',
+        name: t('document.field.status'),
+        type: 'select',
+        required: false,
+        options: FormUtils.convertEnum(DocumentStatusNames, t, 'common'),
+    },
+    {
+        attr: 'visible',
+        name: t('document.field.visible'),
+        type: 'switch',
+        required: false,
+    },
+    {
+        attr: 'description',
+        name: t('document.field.description'),
+        type: 'textarea',
+        required: false,
+    },
+    {
+        attr: 'defaultTool',
+        name: t('document.field.defaultTool'),
+        type: 'function',
+        fn: (tool) => t(ToolsUtils.getTitle(tool)),
+    },
+    {
+        attr: 'id',
+        name: t('document.field.inc'),
+        type: 'function',
+        fn: (id) => DateUtils.extractDateFromMongoId(id, true),
+    },
+];

package/dist/features/DocumentDrawer/DocumentEdit/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './DocumentEdit';
+export type { DocumentEditFormValues } from './DocumentEdit';

package/dist/features/DocumentDrawer/DocumentEdit/index.js

@@ -0,0 +1 @@
+export { default } from './DocumentEdit';

package/dist/features/DocumentDrawer/DocumentExport/DocumentExport.d.ts

@@ -0,0 +1,7 @@
+import { Document } from '../deps';
+import './style.scss';
+type Props = {
+    doc: Document;
+};
+export default function DocumentExport({ doc }: Props): import("react/jsx-runtime").JSX.Element;
+export {};