@hrbolek/uoisfrontend-template 0.6.0

package/src/_Template/Components/LargeCard.jsx

@@ -0,0 +1,50 @@
+// import Row from "react-bootstrap/Row"
+import { MediumCard } from "./MediumCard"
+import { CardCapsule as CardCapsule_} from "./CardCapsule"
+import { Row } from "../../../../_template/src/Base/Components/Row"
+// import { LeftColumn, MiddleColumn } from "@hrbolek/uoisfrontend-shared"
+import { MediumContent as MediumContent_ } from "./MediumContent"
+import { InteractiveMutations } from '../Mutations/InteractiveMutations'
+import { LeftColumn, MiddleColumn } from "../../../../_template/src/Base/Components/Col"
+/**
+ * A large card component for displaying detailed content and layout for an template entity.
+ *
+ * This component wraps an `TemplateCardCapsule` with a flexible layout that includes multiple
+ * columns. It uses a `Row` layout with a `LeftColumn` for displaying an `TemplateMediumCard`
+ * and a `MiddleColumn` for rendering additional children.
+ *
+ * @component
+ * @param {Object} props - The properties for the TemplateLargeCard component.
+ * @param {Object} props.template - The object representing the template entity.
+ * @param {string|number} props.template.id - The unique identifier for the template entity.
+ * @param {string} props.template.name - The name or label of the template entity.
+ * @param {React.ReactNode} [props.children=null] - Additional content to render in the middle column.
+ *
+ * @returns {JSX.Element} A JSX element combining a large card layout with dynamic content.
+ *
+ * @example
+ * // Example usage:
+ * const templateEntity = { id: 123, name: "Sample Entity" };
+ * 
+ * <TemplateLargeCard template={templateEntity}>
+ *   <p>Additional content for the middle column.</p>
+ * </TemplateLargeCard>
+ */
+export const LargeCard = ({ item, children, CardCapsule=CardCapsule_, MediumContent=MediumContent_ }) => {
+    // console.log("LargeCard.item", item)
+    return (
+        <CardCapsule item={item} >
+            <Row>
+                <LeftColumn>
+                    <CardCapsule item={item} title="Detail">
+                        <MediumContent item={item} />
+                    </CardCapsule>
+                    <InteractiveMutations item={item} />
+                </LeftColumn>
+                <MiddleColumn>
+                    {children}
+                </MiddleColumn>
+            </Row>
+        </CardCapsule>
+    )
+}

package/src/_Template/Components/Link.jsx

@@ -0,0 +1,54 @@
+import { URIRoot } from "../../uriroot";
+import { registerLink } from "../../../../_template/src/Base/Components/Link";
+import { ProxyLink } from "../../../../_template/src/Base/Components/ProxyLink";
+
+const modelURI = `${URIRoot}/template`
+export const ListURI = `${modelURI}/list/`;
+export const CreateURI = `${modelURI}/create/`;
+export const ReadURI = `${modelURI}/view/`;
+export const UpdateURI = `${modelURI}/edit/`;
+export const DeleteURI = `${modelURI}/delete/`;
+
+export const LinkURI = ReadURI;
+export const VectorItemsURI = ListURI;
+
+const idParam = ":id"
+export const ReadItemURI = `${LinkURI}${idParam}`;
+export const UpdateItemURI = `${UpdateURI}${idParam}`;
+export const DeleteItemURI = `${DeleteURI}${idParam}`;
+
+/**
+ * A React component that renders a `ProxyLink` to an "template" entity's view page.
+ *
+ * The target URL is dynamically constructed using the `template` object's `id`, and the link displays
+ * the `template` object's `name` as its clickable content.
+ *
+ * @function TemplateLink
+ * @param {Object} props - The properties for the `TemplateLink` component.
+ * @param {Object} props.template - The object representing the "template" entity.
+ * @param {string|number} props.template.id - The unique identifier for the "template" entity. Used to construct the target URL.
+ * @param {string} props.template.name - The display name for the "template" entity. Used as the link text.
+ *
+ * @returns {JSX.Element} A `ProxyLink` component linking to the specified "template" entity's view page.
+ *
+ * @example
+ * // Example usage with a sample template entity:
+ * const templateEntity = { id: 123, name: "Example Template Entity" };
+ * 
+ * <TemplateLink template={templateEntity} />
+ * // Renders: <ProxyLink to="/template/template/view/123">Example Template Entity</ProxyLink>
+ *
+ * @remarks
+ * - This component utilizes `ProxyLink` to ensure consistent link behavior, including parameter preservation and conditional reloads.
+ * - The URL format `/template/template/view/:id` must be supported by the application routing.
+ *
+ * @see ProxyLink - The base component used for rendering the link.
+ */
+export const Link = ({ item, LinkURI: LinkURI_ = LinkURI, action="view", children, ...props}) => {
+    const targetURI = LinkURI_.replace('view', action);
+    return <ProxyLink to={targetURI + item?.id} {...props}>{children || item?.fullname || item?.name || item?.id || "Nevim"}</ProxyLink>
+    // return <BaseUI.Link item={item} />
+    // return <a>{children || item?.fullname || item?.name || item?.id || "Nevim"}</a>
+}
+
+registerLink('TemplateGQLModel', Link)

package/src/_Template/Components/LiveEdit.jsx

@@ -0,0 +1,111 @@
+import { useCallback } from "react";
+import { useMemo } from "react";
+
+import { UpdateAsyncAction } from "../Queries";
+import { CreateDelayer, ErrorHandler, LoadingSpinner } from "@hrbolek/uoisfrontend-shared";
+import { MediumEditableContent } from "./MediumEditableContent";
+import { useEditAction } from "../../../../dynamic/src/Hooks/useEditAction";
+
+/**
+ * TemplateLiveEdit Component
+ *
+ * Interaktivní React komponenta pro live editaci entity `template` s podporou optimistického fetchování a debounce delaye.
+ *
+ * - Používá `useAsyncAction` k načítání a update entit (např. GraphQL mutation).
+ * - Pokud se hodnota pole změní, spustí se update po krátkém zpoždění (`delayer`) — uživatelské změny nejsou ihned posílány, ale až po pauze.
+ * - Zobrazuje loading a error stav pomocí komponent `LoadingSpinner` a `ErrorHandler`.
+ * - Předává editované hodnoty do komponenty `TemplateMediumEditableContent`, která zajišťuje zobrazení a editaci jednotlivých polí šablony (`template`).
+ *
+ * @component
+ * @param {Object} props - Props objekt.
+ * @param {Object} props.template - Objekt reprezentující editovanou šablonu (template entity).
+ * @param {React.ReactNode} [props.children] - Libovolné children, které se vloží pod editační komponentu.
+ * @param {Function} [props.asyncAction=TemplateUpdateAsyncAction] - Asynchronní akce pro update (`useAsyncAction`), typicky GraphQL update mutation.
+ *
+ * @example
+ * // Standardní použití
+ * <TemplateLiveEdit template={templateEntity} />
+ *
+ * @example
+ * // S vlastním asyncAction a doplňkovým obsahem
+ * <TemplateLiveEdit template={templateEntity} asyncAction={myUpdateAction}>
+ *   <div>Extra obsah nebo poznámka</div>
+ * </TemplateLiveEdit>
+ *
+ * @returns {JSX.Element}
+ *   Interaktivní komponenta pro live editaci šablony, včetně spinneru a error handleru.
+ */
+export const LiveEdit_ = ({ children, asyncAction=UpdateAsyncAction}) => {
+    const { onChange, onBlur, item } = useGQLEntityContext()
+    return (
+        <AsyncActionProvider 
+            item={item} 
+            queryAsyncAction={asyncAction}
+            options={{deferred: true, network: true}}
+            onChange={onChange}
+            onBlur={onBlur}
+        >
+            <LiveEditWrapper item={item}>
+                {children}
+                {/* <hr />
+                <pre>{JSON.stringify(item, null, 2)}</pre> */}
+            </LiveEditWrapper>
+        </AsyncActionProvider>
+    )
+}
+
+const LiveEditWrapper = ({ item, children }) => {
+    const { run , error, loading, entity, data, onChange, onBlur } = useGQLEntityContext()
+    
+    const handleEvent = useCallback((handler) => async (e) => {
+        const {id, value} = e?.target || {}
+        if (id === undefined || value === undefined) return 
+        if (item?.[id] === value) {
+            return;
+        }
+        const newItem = { ...item, [e.target.id]: e.target.value }
+        const newEvent = { target: { value: newItem } }
+        // console.log("LiveEditWrapper localOnChange start e", e, '=>', newEvent)
+        // const result = await delayer(()=>onChange(newEvent))
+        const result = await handler(newEvent)
+        // console.log("LiveEditWrapper localOnChange end e", e, '=>', newItem, '=>', result)
+        return result
+    }, [item])
+
+    const bindedOnChange = useMemo(() => handleEvent(onChange), [onChange, handleEvent])
+    const bindedOnBlur = useMemo(() => handleEvent(onBlur), [onBlur, handleEvent])
+
+    return (
+        <MediumEditableContent item={item} onChange={bindedOnChange} onBlur={bindedOnBlur} >
+            {children}
+            {/* <hr />
+            <pre>{JSON.stringify(item, null, 2)}</pre> */}
+        </MediumEditableContent>
+    )
+}
+
+
+export const LiveEdit = ({ item, children, asyncMutationAction=UpdateAsyncAction }) => {
+    // const { run , error, loading, entity, data, onChange: contextOnChange, onBlur: contextOnBlur } = useGQLEntityContext()
+    const {
+        draft,
+        dirty,
+        loading: saving,
+        onChange, 
+        onBlur,
+        onCancel,
+        onConfirm,
+    } = useEditAction(asyncMutationAction, item, {
+        mode: "live", 
+        // onCommit: contextOnChange
+    })
+
+    return (
+        
+        <MediumEditableContent item={item} onChange={onChange} onBlur={onBlur} >
+            {saving && <LoadingSpinner/>}
+            {children}
+        </MediumEditableContent>
+        
+    )
+}

package/src/_Template/Components/MediumCard.jsx

@@ -0,0 +1,39 @@
+import { PersonFill } from "react-bootstrap-icons"
+import { CardCapsule } from "./CardCapsule"
+import { MediumContent } from "./MediumContent"
+import { Link } from "./Link"
+
+/**
+ * A card component that displays detailed content for an template entity.
+ *
+ * This component combines `TemplateCardCapsule` and `TemplateMediumContent` to create a card layout
+ * with a title and medium-level content. The title includes a `PersonFill` icon and a link to
+ * the template entity's details, while the body displays serialized details of the entity along
+ * with any additional children passed to the component.
+ *
+ * @component
+ * @param {Object} props - The properties for the TemplateMediumCard component.
+ * @param {Object} props.template - The object representing the template entity.
+ * @param {string|number} props.template.id - The unique identifier for the template entity.
+ * @param {string} props.template.name - The name or label of the template entity.
+ * @param {React.ReactNode} [props.children=null] - Additional content to render inside the card body.
+ *
+ * @returns {JSX.Element} A JSX element combining a card with a title and detailed content.
+ *
+ * @example
+ * // Example usage:
+ * const templateEntity = { id: 123, name: "Sample Entity" };
+ * 
+ * <TemplateMediumCard template={templateEntity}>
+ *   <p>Additional details or actions for the entity.</p>
+ * </TemplateMediumCard>
+ */
+export const MediumCard = ({ item, children }) => {
+    return (
+        <CardCapsule title={<><PersonFill /> <Link item={item} /></>}>
+            {children}
+            <MediumContent item={item}>
+            </MediumContent>
+        </CardCapsule>
+    )
+}

package/src/_Template/Components/MediumContent.jsx

@@ -0,0 +1,96 @@
+import { Col } from "../../../../_template/src/Base/Components/Col"
+import { Row } from "../../../../_template/src/Base/Components/Row"
+import { Link } from "./Link"
+/**
+ * A component that displays medium-level content for an template entity.
+ *
+ * This component renders a label "TemplateMediumContent" followed by a serialized representation of the `template` object
+ * and any additional child content. It is designed to handle and display information about an template entity object.
+ *
+ * @component
+ * @param {Object} props - The properties for the TemplateMediumContent component.
+ * @param {Object} props.template - The object representing the template entity.
+ * @param {string|number} props.template.id - The unique identifier for the template entity.
+ * @param {string} props.template.name - The name or label of the template entity.
+ * @param {React.ReactNode} [props.children=null] - Additional content to render after the serialized `template` object.
+ *
+ * @returns {JSX.Element} A JSX element displaying the entity's details and optional content.
+ *
+ * @example
+ * // Example usage:
+ * const templateEntity = { id: 123, name: "Sample Entity" };
+ * 
+ * <TemplateMediumContent template={templateEntity}>
+ *   <p>Additional information about the entity.</p>
+ * </TemplateMediumContent>
+ */
+// export const MediumContent = ({ item, children}) => {
+//     return (
+//         <MediumContent_ item={item}>
+//             {children}
+//         </MediumContent_>
+//     )
+// }
+
+// export const MediumContent_ = ({ item, children }) => {
+//     return (
+//         <>
+//             {Object.entries(item).map(([attribute_name, attribute_value]) => {
+//                 // if (attribute_name !== "id") return null
+//                 if (Array.isArray(attribute_value)) return null
+//                 if (typeof attribute_value === "object" && attribute_value !== null) return null
+//                 let attribute_value_result = attribute_value
+//                 // let attribute_value_result = attribute_value
+//                 if (Array.isArray(attribute_value))
+//                     // attribute_value_result = <CardCapsule><Table data={attribute_value} /></CardCapsule>
+//                     return null
+//                 else if (typeof attribute_value === "object" && attribute_value !== null)
+//                     // attribute_value_result = <MediumCard item={attribute_value} />
+//                     return null
+//                 else if (attribute_name === "__typename") {
+//                     /*attribute_value_result = <Link item={attribute_value} />*/
+//                     // console.log("else1", attribute_name, attribute_value)
+//                 }
+//                 if (attribute_name === "id")
+//                     attribute_value_result = <Link item={item}>{item?.id || "Data error"}</Link>
+//                 if (attribute_name === "name")
+//                     attribute_value_result = <Link item={item} />
+//                 // else return null
+//                 if (attribute_value)
+//                     return (
+//                         <Row key={attribute_name}>
+//                             <Col className="col-4"><b>{attribute_name}</b></Col>
+//                             <Col className="col-8">{attribute_value_result}</Col>
+//                         </Row>
+//                     )
+//                 else return null
+//             })}
+//             {Object.entries(item).map(([attribute_name, attribute_value]) => {
+//                 if (attribute_value !== null) return null
+//                 let attribute_value_result = JSON.stringify(attribute_value)
+//                 if (Array.isArray(attribute_value))
+//                     // attribute_value_result = <CardCapsule><Table data={attribute_value} /></CardCapsule>
+//                     return null
+//                 else if (typeof attribute_value === "object" && attribute_value !== null)
+//                     // attribute_value_result = <MediumCard item={attribute_value} />
+//                     return null
+//                 else if (attribute_name === "__typename") {
+//                     /*attribute_value_result = <Link item={attribute_value} />*/
+//                     console.log("else2", attribute_name, attribute_value)
+//                 }
+//                 if (attribute_value)
+//                     return null
+//                 else
+//                     return (
+//                         <Row key={attribute_name}>
+//                             <Col className="col-4"><b>{attribute_name}</b></Col>
+//                             <Col className="col-8">{attribute_value_result}</Col>
+//                         </Row>
+//                     )
+//             })}
+//             {children}
+//         </>
+//     )
+// }
+
+export { MediumContent } from "../../../../_template/src/Base/Components/MediumContent"

package/src/_Template/Components/MediumEditableContent.jsx

@@ -0,0 +1,35 @@
+import { Input } from "../../../../_template/src/Base/FormControls/Input"
+
+/**
+ * A component that displays medium-level content for an template entity.
+ *
+ * This component renders a label "TemplateMediumContent" followed by a serialized representation of the `template` object
+ * and any additional child content. It is designed to handle and display information about an template entity object.
+ *
+ * @component
+ * @param {Object} props - The properties for the TemplateMediumContent component.
+ * @param {Object} props.template - The object representing the template entity.
+ * @param {string|number} props.template.id - The unique identifier for the template entity.
+ * @param {string} props.template.name - The name or label of the template entity.
+ * @param {React.ReactNode} [props.children=null] - Additional content to render after the serialized `template` object.
+ *
+ * @returns {JSX.Element} A JSX element displaying the entity's details and optional content.
+ *
+ * @example
+ * // Example usage:
+ * const templateEntity = { id: 123, name: "Sample Entity" };
+ * 
+ * <TemplateMediumContent template={templateEntity}>
+ *   <p>Additional information about the entity.</p>
+ * </TemplateMediumContent>
+ */
+export const MediumEditableContent = ({ item, onChange=(e)=>null, onBlur=(e)=>null, children}) => {
+    return (
+        <>           
+        {/* defaultValue={item?.name|| "Název"}  */}
+            <Input id={"name"} label={"Jméno"} className="form-control" value={item?.name|| "Název"} onChange={onChange} onBlur={onBlur} />
+            <Input id={"nameEn"} label={"Anglický název"} className="form-control" value={item?.nameEn|| "Anglický název"} onChange={onChange} onBlur={onBlur} />
+            {children}
+        </>
+    )
+}

package/src/_Template/Components/Table.jsx

@@ -0,0 +1,7 @@
+import { Table as BaseTable } from "../../../../_template/src/Base/Components/Table" 
+
+export const Table = ({ data }) => {
+    return (
+        <BaseTable data={data} />
+    )
+}

package/src/_Template/Components/index.js

@@ -0,0 +1,13 @@
+
+export * from './CardCapsule'
+export * from './Children'
+export * from './LargeCard'
+export * from './Link'
+export * from './MediumContent'
+export * from './MediumCard'
+
+export * from './MediumEditableContent'
+export * from './LiveEdit'
+
+
+export * from './ConfirmEdit'

package/src/_Template/Mutations/Create.jsx

@@ -0,0 +1,202 @@
+import { CreateURI, MediumEditableContent, ReadItemURI } from "../Components"
+import { InsertAsyncAction } from "../Queries"
+import { 
+    CreateBody as BaseCreateBody, 
+    CreateButton as BaseCreateButton, 
+    CreateDialog as BaseCreateDialog, 
+    CreateLink  as BaseCreateLink
+} from "../../../../_template/src/Base/Mutations/Create"
+
+const DefaultContent = (props) => <MediumEditableContent {...props} />
+const MutationAsyncAction = InsertAsyncAction
+
+const permissions = {
+    oneOfRoles: ["superadmin"],
+    mode: "absolute",
+}
+
+const defaultitem = { name: "Nový" };
+
+/**
+ * Wrapper nad `BaseCreateLink` (alias importu `CreateLink` z Base/Mutations/Create),
+ * který je odvozený z obecných `General*` komponent.
+ *
+ * Účel wrapperu:
+ * - nastaví výchozí `uriPattern` pro create route
+ * - aplikuje výchozí RBAC nastavení přes `permissions` (např. `oneOfRoles`, `mode`)
+ * - všechny ostatní props pouze přeposílá do Base komponenty
+ * 
+ * Vizuálně vyrenderuje link pro kliknutí
+ *
+ * @param {Object} params
+ * @param {string} [params.uriPattern=CreateURI]
+ *   Cílová URI/pattern pro link na create stránku nebo create akci (dle routování aplikace).
+ *
+ * @param {Object} params.props
+ *   Další props přeposílané do `BaseCreateLink` (např. `children`, `className`,
+ *   `preserveSearch`, `preserveHash`, atd.).
+ *
+ * @returns {JSX.Element} Vykreslí `BaseCreateLink` s přednastaveným `uriPattern` a RBAC oprávněními.
+ */
+export const CreateLink = ({
+    uriPattern=CreateURI,
+    ...props
+}) => (
+    <BaseCreateLink {...props} uriPattern={uriPattern} {...permissions} />
+);
+
+/**
+ * Wrapper nad `BaseCreateButton` (alias importu `CreateButton` z Base/Mutations/Create),
+ * který je odvozený z obecných `General*` komponent.
+ *
+ * Účel wrapperu:
+ * - nastaví výchozí oprávnění (RBAC) přes `permissions` (`oneOfRoles`, `mode`)
+ * - nastaví výchozí mutaci pro vytvoření entity (`mutationAsyncAction`)
+ * - umožní vyměnit dialog a obsah formuláře (`CreateDialog`, `DefaultContent`)
+ * - určí kam se má po úspěšném vytvoření navigovat (`readItemURI`)
+ * - předá výchozí `item` pro nový záznam
+ *
+ * Zobrazí tlačítko a po jeho stisku otevře dialog, při volbě OK dochází k odeslání mutace na backend
+ *
+ * @param {Object} params
+ * @param {Function} [params.mutationAsyncAction=MutationAsyncAction]
+ *   Async action (thunk) pro vytvoření entity (např. InsertAsyncAction). Používá ho Base/General logika.
+ *
+ * @param {React.ComponentType<Object>} [params.CreateDialog=CreateDialog]
+ *   Komponenta dialogu použitá pro vytvoření (renderuje formulář a volá `onOk(draft)` / `onCancel()`).
+ *
+ * @param {React.ComponentType<Object>} [params.DefaultContent=DefaultContent]
+ *   Komponenta, která vykreslí editable obsah formuláře (typicky MediumEditableContent).
+ *
+ * @param {string} [params.readItemURI=ReadItemURI]
+ *   URI pattern pro navigaci na detail nově vytvořené entity (obvykle obsahuje `:id`).
+ *
+ * @param {Object} [params.rbacitem]
+ *   RBAC item pro PermissionGate/Permission check (pokud se liší od entity, která se vytváří).
+ *
+ * @param {Object} [params.item=defaultitem]
+ *   Výchozí objekt (draft) pro nový záznam. Posílá se do dialogu jako `item`.
+ *
+ * @param {Object} params.props
+ *   Všechny další props jsou přeposlány přímo do `BaseCreateButton`
+ *   (typicky `children`, `className`, `disabled`, `title`, atd.).
+ *
+ * @returns {JSX.Element} Vykreslí `BaseCreateButton` s přednastavenými defaulty a RBAC oprávněními.
+ */
+export const CreateButton = ({
+    mutationAsyncAction=MutationAsyncAction,
+    CreateDialog: CreateDialog_=CreateDialog,
+    DefaultContent:defaultContent=DefaultContent,
+    readItemURI=ReadItemURI, 
+    rbacitem,
+    item=defaultitem,
+    ...props
+}) => {
+    return <BaseCreateButton 
+        {...props}
+        DefaultContent={defaultContent} 
+        CreateDialog={CreateDialog_}
+        readItemURI={readItemURI}
+        rbacitem={rbacitem}
+        item={item}
+        mutationAsyncAction={mutationAsyncAction}
+        {...permissions}
+    />
+}
+
+/**
+ * Wrapper nad `BaseCreateDialog` (alias importu `CreateDialog` z Base/Mutations/Create),
+ * který je odvozený z obecných `General*` komponent.
+ *
+ * Účel wrapperu:
+ * - nastaví výchozí title, obsah formuláře a výchozí draft (`item`)
+ * - předá `readItemURI` pro případnou navigaci po vytvoření (dle implementace Base/General)
+ * - umožní přepsat `mutationAsyncAction` (pokud BaseCreateDialog mutaci používá)
+ *
+ * Mutaci provadi až tlačítko (`BaseCreateButton`) Dialog jen zobrazuje a zabezpecuje sber dat
+ * a dialog je jen “formulář”. 
+ *
+ * @param {Object} params
+ * @param {string} [params.title="Nov(ý/é)"]
+ *   Titulek dialogu.
+ *
+ * @param {Function} [params.mutationAsyncAction=MutationAsyncAction]
+ *   Async action (thunk) pro vytvoření entity. Použije se pouze pokud ho `BaseCreateDialog` skutečně volá
+ *   (záleží na Base/General implementaci).
+ *
+ * @param {React.ComponentType<Object>} [params.DefaultContent=DefaultContent]
+ *   Komponenta, která vykreslí editable obsah formuláře (typicky MediumEditableContent).
+ *
+ * @param {string} [params.readItemURI=ReadItemURI]
+ *   URI pattern pro navigaci na detail nově vytvořené entity (obvykle obsahuje `:id`).
+ *
+ * @param {Object} [params.item=defaultitem]
+ *   Výchozí objekt (draft) pro nový záznam. Posílá se do dialogu jako `item`.
+ *
+ * @param {Object} params.props
+ *   Všechny další props jsou přeposlány přímo do `BaseCreateDialog`
+ *   (typicky `oklabel`, `cancellabel`, `onOk`, `onCancel`, `className`, atd.).
+ *
+ * @returns {JSX.Element} Vykreslí `BaseCreateDialog` s přednastavenými defaulty.
+ */
+export const CreateDialog = ({
+    title = "Nov(ý/é)",
+    // mutationAsyncAction=MutationAsyncAction,
+    DefaultContent:defaultContent=DefaultContent,
+    readItemURI=ReadItemURI, 
+    item=defaultitem,
+    ...props
+}) => {
+    return <BaseCreateDialog 
+        {...props} 
+        title={title}
+        DefaultContent={defaultContent} 
+        readItemURI={readItemURI}
+        item={item}
+        // mutationAsyncAction={mutationAsyncAction}
+    />
+};
+
+/**
+ * Wrapper nad `BaseCreateBody` (alias importu `CreateBody` z Base/Mutations/Create),
+ * který je odvozený z obecných `General*` komponent.
+ *
+ * `CreateBody` typicky reprezentuje “page-level” create workflow (ne jen tlačítko + modal):
+ * - vykreslí create formulář pomocí `DefaultContent`
+ * - zajistí uložení přes `mutationAsyncAction` (dle Base/General implementace)
+ * - po úspěchu může navigovat na detail vytvořené entity přes `readItemURI` (pokud Base/General takto funguje)
+ *
+ * Wrapper pouze nastavuje defaulty a přeposílá props do `BaseCreateBody`.
+ * 
+ * Vizualizuje <DefaultContent />, sbira zmeny a umoznuje volani backendu pro ulozeni dat
+ *
+ * @param {Object} params
+ * @param {Function} [params.mutationAsyncAction=MutationAsyncAction]
+ *   Async action (thunk) pro vytvoření entity (např. InsertAsyncAction). Používá ho Base/General logika.
+ *
+ * @param {React.ComponentType<Object>} [params.DefaultContent=DefaultContent]
+ *   Komponenta, která vykreslí editable obsah formuláře (typicky MediumEditableContent).
+ *
+ * @param {string} [params.readItemURI=ReadItemURI]
+ *   URI pattern pro navigaci na detail nově vytvořené entity (obvykle obsahuje `:id`).
+ *
+ * @param {Object} params.props
+ *   Všechny další props jsou přeposlány přímo do `BaseCreateBody`
+ *   (typicky `title`, `oklabel`, `cancellabel`, `onOk`, `onCancel`, `className`, atd.).
+ *
+ * @returns {JSX.Element} Vykreslí `BaseCreateBody` s přednastavenými defaulty.
+ */
+export const CreateBody = ({
+    mutationAsyncAction=MutationAsyncAction,
+    DefaultContent:defaultContent=DefaultContent,
+    readItemURI=ReadItemURI, 
+    ...props
+}) => {
+    return <BaseCreateBody 
+        {...props} 
+        DefaultContent={defaultContent} 
+        readItemURI={readItemURI}
+        mutationAsyncAction={mutationAsyncAction}
+    />
+};
+