@evergis/react 4.0.167 → 4.0.169

package/dist/components/Dashboard/actions/types.d.ts

@@ -5,6 +5,8 @@ export type ActionParameters = Record<string, unknown>;
 export interface ActionOptionsMap {
     runTask: {
         taskName: string;
+        fileName?: string;
+        methodName?: string;
         parameters?: ActionParameters;
     };
     setFilters: {

package/dist/components/Dashboard/componentTypes.d.ts

@@ -164,9 +164,8 @@ export interface ElementUploaderProps extends Omit<ContainerProps, "elementConfi
  */
 export type ContainerBoxOptions = Pick<ConfigOptions, "width" | "height" | "overflow">;
 export type AddFeatureContainerOptions = Record<string, never>;
-export type AddFeatureButtonOptions = Pick<ConfigOptions, "icon" | "title" | "layerName" | "geometryType">;
-export interface AddFeatureButtonChild extends Omit<ConfigContainerChild, "options" | "type"> {
-    type?: "button";
+export type AddFeatureButtonOptions = Pick<ConfigOptions, "layerName" | "geometryType"> & ElementButtonOptions;
+export interface AddFeatureButtonChild extends Omit<ElementButtonConfig, "options"> {
     options?: AddFeatureButtonOptions;
 }
 export interface AddFeatureContainerConfig extends Omit<ConfigContainerChild, "options" | "templateName" | "children"> {
@@ -356,7 +355,7 @@ export interface EditAttachmentContainerConfig extends Omit<ConfigContainerChild
 export interface EditAttachmentContainerProps extends Omit<ContainerProps, "elementConfig"> {
     elementConfig?: EditAttachmentContainerConfig;
 }
-export type ExportPdfContainerOptions = Pick<ConfigOptions, "icon" | "title">;
+export type ExportPdfContainerOptions = Record<string, never>;
 export interface ExportPdfContainerConfig extends Omit<ConfigContainerChild, "options" | "templateName"> {
     templateName?: ContainerTemplate.ExportPdf;
     options?: ExportPdfContainerOptions;

package/dist/components/Dashboard/components/ContainerButton/index.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import { ElementButtonProps } from '../../types';
+/** Кнопка нативного действия контейнера со стандартными подстановками дочернего конфига. */
+export declare const ContainerButton: FC<ElementButtonProps>;

package/dist/components/Dashboard/containers/VoteContainer/components/VoteScreen.d.ts

@@ -1,9 +1,9 @@
 import { FC } from 'react';
-import { VoteScreenProps } from '../types';
+import { VoteButtonProps, VoteScreenProps } from '../types';
 /**
  * Тело контейнера: выбирает экран по вью-модели голосования.
  *
  * Живёт отдельно от `VoteContainer`, потому что тот отвечает за корень контейнера — размеры,
  * фон и заголовок — и не должен раздуваться ветвлением по состояниям.
  */
-export declare const VoteScreen: FC<VoteScreenProps>;
+export declare const VoteScreen: FC<VoteScreenProps & VoteButtonProps>;

package/dist/components/Dashboard/containers/VoteContainer/types.d.ts

@@ -1,4 +1,11 @@
-import { VoteContainerOptions } from '../../componentTypes';
+import { ElementButtonConfig, VoteContainerOptions } from '../../componentTypes';
+import { WidgetType } from '../../types';
+export type VoteButtonSlotId = "submitButton" | "createButton" | "saveButton" | "deleteButton";
+export type VoteButtonConfigs = Partial<Record<VoteButtonSlotId, ElementButtonConfig>>;
+export interface VoteButtonProps {
+    type?: WidgetType;
+    buttonConfigs: VoteButtonConfigs;
+}
 /** Экран, который показывает контейнер голосования. */
 export type VoteScreen = "loading" | "create" | "voting" | "voted" | "unauthenticated";
 export interface VoteCategory {
@@ -40,7 +47,7 @@ export interface VoteFormVariant {
  * к данным отношения не имеют, а `Required<VoteContainerOptions>` потребовал бы и их.
  */
 export type VoteDataSources = Required<Pick<VoteContainerOptions, "categoryDataSource" | "questionDataSource" | "variantDataSource" | "answerDataSource">>;
-export interface VoteCreateFormProps {
+export interface VoteCreateFormProps extends VoteButtonProps {
     categories: VoteCategory[];
     initialValues?: VoteFormValues;
     isEditing: boolean;
@@ -50,7 +57,7 @@ export interface VoteCreateFormProps {
     onDelete?: () => void;
     onCancel?: () => void;
 }
-export interface VoteResultsProps {
+export interface VoteResultsProps extends VoteButtonProps {
     question: VoteQuestion;
     category?: VoteCategory;
     results: VoteVariantResult[];

package/dist/components/Dashboard/types.d.ts

@@ -833,6 +833,8 @@ export interface ConfigTask {
     params?: Record<string, unknown>;
     subType?: string;
     resourceId?: string;
+    fileName?: string;
+    methodName?: string;
     owner?: string;
     updateDate?: string;
     id?: string;

package/dist/components/Dashboard/utils/getButtonSlot.d.ts

@@ -0,0 +1,4 @@
+import { ElementButtonConfig } from '../componentTypes';
+import { ConfigContainerChild } from '../types';
+/** Слот кнопки существует только при совпадении id и явном type: "button". */
+export declare const getButtonSlot: (children: ConfigContainerChild[] | undefined, id: string) => ElementButtonConfig | undefined;

package/dist/dashboardActions/index.js

@@ -355,6 +355,12 @@ function getActionOptionsError(type, value) {
         return "Options must be an object";
     if (type === "runTask" && (typeof value.taskName !== "string" || !value.taskName))
         return "runTask requires taskName";
+    if (type === "runTask") {
+        for (const field of ["fileName", "methodName"]) {
+            if (value[field] !== undefined && (typeof value[field] !== "string" || !value[field].trim()))
+                return `runTask ${field} must be a non-empty string`;
+        }
+    }
     if (type === "openModal" && (typeof value.modalId !== "string" || !value.modalId))
         return "openModal requires modalId";
     if (type === "openUrl" && (typeof value.url !== "string" || !value.url))

package/dist/dashboardActions/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/hooks/task/runtime/getPythonTaskConfiguration.d.ts

@@ -0,0 +1,2 @@
+import { PythonExecutionDependencies } from './types';
+export declare const getPythonTaskConfiguration: (resourceId: string, manager: Pick<PythonExecutionDependencies["manager"], "getTaskResource">, hasExplicitTarget: boolean) => Promise<import('@evergis/api').TaskConfigurationDc>;

package/dist/index.js

@@ -5154,7 +5154,7 @@ const FeatureControls = styled(uilibGl.Flex).withConfig({ displayName: "FeatureC
 const FiltersContainerWrapper = styled(uilibGl.Flex).withConfig({ displayName: "FiltersContainerWrapper", componentId: "sc-1a6ru74" }) `
   flex-direction: column;
   padding: ${({ $padding }) => $padding ?? `${DEFAULT_FILTER_PADDING}px`};
-  background-color: ${({ $bgColor, $fontColor, theme: { palette } }) => $bgColor || ($fontColor ? transparentizeColor($fontColor, 6) : palette.element)};
+  background: ${({ $bgColor, $fontColor, theme: { palette } }) => $bgColor || ($fontColor ? transparentizeColor($fontColor, 6) : palette.element)};
   border-radius: ${({ theme: { borderRadius } }) => borderRadius.medium};
 
   ${uilibGl.DropdownField}, input {
@@ -6469,6 +6469,12 @@ function getActionOptionsError(type, value) {
         return "Options must be an object";
     if (type === "runTask" && (typeof value.taskName !== "string" || !value.taskName))
         return "runTask requires taskName";
+    if (type === "runTask") {
+        for (const field of ["fileName", "methodName"]) {
+            if (value[field] !== undefined && (typeof value[field] !== "string" || !value[field].trim()))
+                return `runTask ${field} must be a non-empty string`;
+        }
+    }
     if (type === "openModal" && (typeof value.modalId !== "string" || !value.modalId))
         return "openModal requires modalId";
     if (type === "openUrl" && (typeof value.url !== "string" || !value.url))
@@ -8948,7 +8954,7 @@ const POLL_SUBTASK_INTERVAL_MS = 500;
 const POLL_SUBTASK_TIMEOUT_MS = 15_000;
 
 const StatusBadge = styled(uilibGl.Chip).withConfig({ displayName: "StatusBadge", componentId: "sc-1xmfl10" }) `
-  background-color: ${({ bgColor }) => bgColor};
+  background: ${({ bgColor }) => bgColor};
   color: ${({ theme }) => theme.palette.iconContrast};
 `;
 
@@ -9037,6 +9043,22 @@ class PythonExecutionError extends Error {
 const RUN_ID_RADIX = 36;
 const TASK_OBSERVATION_TIMEOUT_MS = 86_400_000;
 
+const BAD_REQUEST_STATUS = 400;
+const getPythonTaskConfiguration = async (resourceId, manager, hasExplicitTarget) => {
+    try {
+        return await manager.getTaskResource({ id: resourceId });
+    }
+    catch (error) {
+        if (!hasExplicitTarget || !(error instanceof api.HTTPError) || error.response.status !== BAD_REQUEST_STATUS)
+            throw error;
+        // Clone the response so a propagated error retains its body for the caller.
+        const body = await error.response.clone().text().catch(() => "");
+        if (!body.includes("Python importMethod is required"))
+            throw error;
+        return undefined;
+    }
+};
+
 const resolvePythonTaskDefinition = async (request, manager) => {
     const task = request.taskName ? request.tasks?.find(({ name }) => name === request.taskName) : undefined;
     if (request.taskName && !task)
@@ -9044,20 +9066,23 @@ const resolvePythonTaskDefinition = async (request, manager) => {
     const resourceId = task?.resourceId ?? request.resourceId;
     if (!resourceId)
         throw new Error(`Task resourceId is missing: ${request.taskName ?? ""}`);
-    const configuration = await manager.getTaskResource({ id: resourceId });
-    if (!["pythonService", "PythonTask"].includes(configuration?.taskType)) {
+    const fileName = request.fileName ?? task?.fileName;
+    const methodName = request.methodName ?? task?.methodName;
+    const hasExplicitTarget = typeof fileName === "string" && !!fileName.trim() && typeof methodName === "string" && !!methodName.trim();
+    const configuration = await getPythonTaskConfiguration(resourceId, manager, hasExplicitTarget);
+    if (configuration && configuration.taskResourceSubType !== api.TaskResourceSubType.PythonTask && !["pythonService", "PythonTask"].includes(configuration.taskType)) {
         throw new Error(`Task ${request.taskName ?? resourceId} is not a Python task`);
     }
-    const schema = configuration.defaultConfiguration ?? {};
+    const schema = configuration?.defaultConfiguration ?? {};
     const defaults = buildDefaultForSchema(new SchemaResolver(schema), schema);
-    const parameters = [defaults, configuration.userConfiguration, task?.params, request.parameters]
+    const parameters = [defaults, configuration?.userConfiguration, task?.params, request.parameters]
         .filter(isObject)
         .reduce((base, override) => mergeActionParameters(base, override), {});
     return {
         resourceId,
         parameters,
-        fileName: request.fileName ?? schema.fileName,
-        methodName: request.methodName ?? schema.methodName,
+        fileName: fileName ?? schema.fileName,
+        methodName: methodName ?? schema.methodName,
         script: request.script,
     };
 };
@@ -11293,7 +11318,7 @@ const FilterChip = styled.div.withConfig({ displayName: "FilterChip", componentI
   padding: 0.3125rem 0.5rem;
   height: 1.5rem;
   border-radius: 0.25rem;
-  background-color: ${({ $isActive, $bgColor, theme }) => $bgColor
+  background: ${({ $isActive, $bgColor, theme }) => $bgColor
     ? $bgColor
     : $isActive
         ? theme.palette?.primary
@@ -11313,7 +11338,7 @@ const FilterChip = styled.div.withConfig({ displayName: "FilterChip", componentI
   box-sizing: border-box;
 
   &:hover {
-    background-color: ${({ $isActive, $bgColor, theme }) => $isActive
+    background: ${({ $isActive, $bgColor, theme }) => $isActive
     ? $bgColor || 'inherit'
     : $bgColor || theme.palette?.elementDark};
   }
@@ -14558,12 +14583,21 @@ const ContainerBackground = React.memo(({ elementConfig, renderElement }) => {
     return (jsxRuntime.jsx(ContainerBackgroundLayer, { "$outflow": elementConfig?.options?.outflow, children: renderElement({ id: BG_IMAGE_SLOT_ID, wrap: false }) }));
 });
 
-const AddFeatureContainer = React.memo(({ elementConfig, renderElement }) => {
+/** Кнопка нативного действия контейнера со стандартными подстановками дочернего конфига. */
+const ContainerButton = React.memo(({ type = exports.WidgetType.Dashboard, elementConfig, ...props }) => {
+    const sources = useConfigStringSources(type);
+    const node = useActionNode();
+    const attributes = props.attributes ?? node.attributes ?? sources.attributes;
+    const resolvedConfig = React.useMemo(() => resolveElementStrings(elementConfig, { ...sources, attributes }), [elementConfig, sources, attributes]);
+    return jsxRuntime.jsx(ElementButton, { ...props, type: type, attributes: attributes, elementConfig: resolvedConfig });
+});
+
+const AddFeatureContainer = React.memo(({ type, elementConfig, renderElement }) => {
     const { id, children, style } = elementConfig || {};
     const bgHost = useBgImageHost(elementConfig);
-    return (jsxRuntime.jsxs(Container, { id: id, style: style, ...bgHost, children: [jsxRuntime.jsx(ContainerBackground, { elementConfig: elementConfig, renderElement: renderElement }), children
-                .filter(({ type }) => type === "button")
-                .map(({ options }, index) => (jsxRuntime.jsx(AddFeatureButton, { icon: options?.icon, title: options?.title, layerName: options?.layerName, geometryType: options?.geometryType }, index)))] }));
+    const handleAddFeature = React.useCallback(() => undefined, []);
+    return (jsxRuntime.jsxs(Container, { id: id, style: style, ...bgHost, children: [jsxRuntime.jsx(ContainerBackground, { elementConfig: elementConfig, renderElement: renderElement }), children?.filter(({ type: childType }) => childType === "button")
+                .map((button, index) => (jsxRuntime.jsx(ContainerButton, { type: type, elementConfig: button, onClick: handleAddFeature }, button.id ?? index)))] }));
 });
 
 /**
@@ -16497,7 +16531,7 @@ const RoundedBackgroundContainerWrapper = styled(uilibGl.Flex).withConfig({ disp
    * иначе фон тонируется цветом иконки, а без неё — цветом текста (colorAttribute/fontColor);
    * если не задан ни один цвет, остаётся токен темы.
    */
-  background-color: ${({ $bgColor, $iconColor, $color, theme: { palette } }) => $bgColor || tintedBackground($iconColor || $color) || palette.element};
+  background: ${({ $bgColor, $iconColor, $color, theme: { palette } }) => $bgColor || tintedBackground($iconColor || $color) || palette.element};
   border-radius: ${({ theme: { borderRadius } }) => borderRadius.large};
   flex-wrap: nowrap;
 
@@ -16568,11 +16602,6 @@ const RoundedBackgroundContainerWrapper = styled(uilibGl.Flex).withConfig({ disp
         > * {
           text-align: left;
         }
-
-        /* Зазор наружу даёт обёртка иконки, здесь — отступ внутри её бокса. */
-        span[kind] {
-          margin-right: 0.5rem;
-        }
         
         ${ContainerValue} {
           width: auto;
@@ -17286,7 +17315,7 @@ const TabContainer = styled.a.withConfig({ displayName: "TabContainer", componen
   justify-content: center;
   flex-wrap: nowrap;
   padding: ${({ onlyIcon }) => (onlyIcon ? 1 : 0.5)}rem 1rem;
-  background-color: ${({ active, bgColor, theme: { palette } }) => active ? bgColor || palette.primary : palette.element};
+  background: ${({ active, bgColor, theme: { palette } }) => active ? bgColor || palette.primary : palette.element};
   border-radius: ${({ column, radius, theme: { borderRadius } }) => radius ? `${radius}px` : column ? borderRadius.medium : borderRadius.xLarge};
   text-decoration: none;
 
@@ -17752,22 +17781,22 @@ const useVoteForm = (initialValues) => {
     };
 };
 
-const VoteCreateForm = ({ categories, initialValues, isEditing, canDelete, submitting, onSubmit, onDelete, onCancel, }) => {
+const VoteCreateForm = ({ type, buttonConfigs, categories, initialValues, isEditing, canDelete, submitting, onSubmit, onDelete, onCancel, }) => {
     const { t } = useGlobalContext();
     const form = useVoteForm(initialValues);
     const { categoryId, setCategoryId, text, setText, multiSelect, setMultiSelect, variants, addVariant, removeVariant, draft, setDraft, isValid, values, } = form;
     const categoryOptions = React.useMemo(() => categories.map(({ id, name }) => ({ text: name, value: id })), [categories]);
+    const submitButton = React.useMemo(() => isEditing ? buttonConfigs.saveButton : buttonConfigs.createButton, [buttonConfigs, isEditing]);
+    const handleSubmit = React.useCallback(() => onSubmit(values), [onSubmit, values]);
     return (jsxRuntime.jsxs(VoteWrapper, { children: [!isEditing && jsxRuntime.jsx(VoteHeading, { children: t("vote.newVote", { ns: VOTE_NS, defaultValue: "Новое голосование" }) }), jsxRuntime.jsx(uilibGl.Dropdown, { zIndex: 110000, label: t("vote.category", { ns: VOTE_NS, defaultValue: "Категория" }), width: "100%", placeholder: t("vote.categoryPlaceholder", { ns: VOTE_NS, defaultValue: "Выберите категорию" }), options: categoryOptions, value: categoryId, onChange: items => setCategoryId(String(items[0]?.value ?? "")) }), jsxRuntime.jsx(uilibGl.Input, { label: t("vote.question", { ns: VOTE_NS, defaultValue: "Вопрос" }), width: "100%", placeholder: t("vote.questionPlaceholder", { ns: VOTE_NS, defaultValue: "Текст вопроса" }), value: text, onChange: ({ target }) => setText(target.value) }), jsxRuntime.jsx(VoteSectionLabel, { children: t("vote.variants", { ns: VOTE_NS, defaultValue: "Варианты ответов" }) }), !!variants.length && (jsxRuntime.jsx(VoteChipList, { children: variants.map(({ text: variantText }, index) => (jsxRuntime.jsxs(VoteChip, { children: [jsxRuntime.jsx(VoteVariantText, { children: variantText }), jsxRuntime.jsx(uilibGl.IconButton, { kind: "close", onClick: () => removeVariant(index) })] }, `${variantText}:${index}`))) })), jsxRuntime.jsx(uilibGl.Input, { width: "100%", placeholder: t("vote.variantPlaceholder", { ns: VOTE_NS, defaultValue: "Введите вариант и нажмите Enter" }), value: draft, onChange: ({ target }) => setDraft(target.value), onKeyDown: event => {
                     if (event.key === "Enter") {
                         event.preventDefault();
                         addVariant();
                     }
-                } }), jsxRuntime.jsxs(uilibGl.Flex, { alignItems: "center", justifyContent: "space-between", children: [jsxRuntime.jsx(VoteSectionLabel, { children: t("vote.multiSelect", { ns: VOTE_NS, defaultValue: "Множественный выбор" }) }), jsxRuntime.jsx(uilibGl.Switch, { checked: multiSelect, onChange: () => setMultiSelect(prev => !prev) })] }), jsxRuntime.jsx(uilibGl.RaisedButton, { primary: true, disabled: !isValid || submitting, onClick: () => onSubmit(values), children: isEditing
-                    ? t("vote.save", { ns: VOTE_NS, defaultValue: "Сохранить" })
-                    : t("vote.create", { ns: VOTE_NS, defaultValue: "Создать голосование" }) }), !isValid && (jsxRuntime.jsx(VoteHint, { children: t("vote.formHint", {
+                } }), jsxRuntime.jsxs(uilibGl.Flex, { alignItems: "center", justifyContent: "space-between", children: [jsxRuntime.jsx(VoteSectionLabel, { children: t("vote.multiSelect", { ns: VOTE_NS, defaultValue: "Множественный выбор" }) }), jsxRuntime.jsx(uilibGl.Switch, { checked: multiSelect, onChange: () => setMultiSelect(prev => !prev) })] }), submitButton && (jsxRuntime.jsx(ContainerButton, { type: type, elementConfig: submitButton, disabled: !isValid || submitting, onClick: handleSubmit })), !isValid && (jsxRuntime.jsx(VoteHint, { children: t("vote.formHint", {
                     ns: VOTE_NS,
                     defaultValue: "Нужны категория, вопрос и минимум два варианта ответа",
-                }) })), isEditing && (jsxRuntime.jsxs(uilibGl.Flex, { alignItems: "center", justifyContent: "space-between", children: [onCancel && (jsxRuntime.jsx(VoteEditLink, { onClick: onCancel, children: t("vote.cancel", { ns: VOTE_NS, defaultValue: "Отмена" }) })), canDelete && onDelete && (jsxRuntime.jsx(uilibGl.RaisedButton, { error: true, disabled: submitting, onClick: onDelete, children: t("vote.delete", { ns: VOTE_NS, defaultValue: "Удалить голосование" }) }))] }))] }));
+                }) })), isEditing && (jsxRuntime.jsxs(uilibGl.Flex, { alignItems: "center", justifyContent: "space-between", children: [onCancel && (jsxRuntime.jsx(VoteEditLink, { onClick: onCancel, children: t("vote.cancel", { ns: VOTE_NS, defaultValue: "Отмена" }) })), canDelete && onDelete && buttonConfigs.deleteButton && (jsxRuntime.jsx(ContainerButton, { type: type, elementConfig: buttonConfigs.deleteButton, disabled: submitting, onClick: onDelete }))] }))] }));
 };
 
 /** Блок «Поделиться в соцсетях» — пока только вёрстка, без рабочих ссылок. */
@@ -17776,7 +17805,7 @@ const VoteShare = () => {
     return (jsxRuntime.jsxs(VoteShareBlock, { children: [jsxRuntime.jsx(VoteSectionLabel, { children: t("vote.share", { ns: VOTE_NS, defaultValue: "Поделиться в соцсетях" }) }), jsxRuntime.jsx(VoteShareChips, { children: VOTE_SOCIALS.map(name => (jsxRuntime.jsx(VoteShareChip, { children: name }, name))) })] }));
 };
 
-const VoteResults = ({ question, category, results, screen, isOwner, hasAnswers, submitting, onSubmit, onEdit, }) => {
+const VoteResults = ({ type, buttonConfigs, question, category, results, screen, isOwner, hasAnswers, submitting, onSubmit, onEdit, }) => {
     const { t } = useGlobalContext();
     const [selected, setSelected] = React.useState([]);
     const showControls = screen === "voting";
@@ -17790,8 +17819,9 @@ const VoteResults = ({ question, category, results, screen, isOwner, hasAnswers,
         });
     }, [question.multiSelect]);
     const canSubmit = React.useMemo(() => selected.length > 0 && !submitting, [selected.length, submitting]);
+    const handleSubmit = React.useCallback(() => onSubmit(selected), [onSubmit, selected]);
     return (jsxRuntime.jsxs(VoteWrapper, { children: [category && jsxRuntime.jsx(VoteCategoryLabel, { children: category.name }), jsxRuntime.jsx(VoteQuestionText, { children: question.text }), jsxRuntime.jsx(VoteVariantList, { column: true, value: selected[0] ?? "", children: results.map(({ id, text, count, percent }) => (jsxRuntime.jsxs(VoteVariantRow, { children: [jsxRuntime.jsxs(VoteVariantHead, { children: [showControls &&
-                                    (question.multiSelect ? (jsxRuntime.jsx(uilibGl.Checkbox, { checked: selected.includes(id), onChange: () => toggle(id) })) : (jsxRuntime.jsx(uilibGl.Radio, { value: id, checked: selected.includes(id), onChange: () => toggle(id) }))), jsxRuntime.jsx(VoteVariantText, { children: text }), jsxRuntime.jsx(VoteVariantCount, { children: count })] }), jsxRuntime.jsx(uilibGl.LinearProgress, { done: percent })] }, id))) }), screen === "unauthenticated" && (jsxRuntime.jsx(VoteHint, { children: t("vote.authHint", { ns: VOTE_NS, defaultValue: "Чтобы проголосовать, пожалуйста, авторизуйтесь" }) })), screen === "voted" && (jsxRuntime.jsxs(VoteAcceptedBadge, { children: [jsxRuntime.jsx(uilibGl.Icon, { kind: "success" }), t("vote.accepted", { ns: VOTE_NS, defaultValue: "Ваш ответ принят" })] })), showControls && (jsxRuntime.jsx(uilibGl.RaisedButton, { primary: true, disabled: !canSubmit, onClick: () => onSubmit(selected), children: t("vote.submit", { ns: VOTE_NS, defaultValue: "Отправить ответ" }) })), canEdit && onEdit && (jsxRuntime.jsx(uilibGl.Flex, { children: jsxRuntime.jsx(VoteEditLink, { onClick: onEdit, children: t("vote.edit", { ns: VOTE_NS, defaultValue: "Редактировать" }) }) })), showShare && jsxRuntime.jsx(VoteShare, {})] }));
+                                    (question.multiSelect ? (jsxRuntime.jsx(uilibGl.Checkbox, { checked: selected.includes(id), onChange: () => toggle(id) })) : (jsxRuntime.jsx(uilibGl.Radio, { value: id, checked: selected.includes(id), onChange: () => toggle(id) }))), jsxRuntime.jsx(VoteVariantText, { children: text }), jsxRuntime.jsx(VoteVariantCount, { children: count })] }), jsxRuntime.jsx(uilibGl.LinearProgress, { done: percent })] }, id))) }), screen === "unauthenticated" && (jsxRuntime.jsx(VoteHint, { children: t("vote.authHint", { ns: VOTE_NS, defaultValue: "Чтобы проголосовать, пожалуйста, авторизуйтесь" }) })), screen === "voted" && (jsxRuntime.jsxs(VoteAcceptedBadge, { children: [jsxRuntime.jsx(uilibGl.Icon, { kind: "success" }), t("vote.accepted", { ns: VOTE_NS, defaultValue: "Ваш ответ принят" })] })), showControls && buttonConfigs.submitButton && (jsxRuntime.jsx(ContainerButton, { type: type, elementConfig: buttonConfigs.submitButton, disabled: !canSubmit, onClick: handleSubmit })), canEdit && onEdit && (jsxRuntime.jsx(uilibGl.Flex, { children: jsxRuntime.jsx(VoteEditLink, { onClick: onEdit, children: t("vote.edit", { ns: VOTE_NS, defaultValue: "Редактировать" }) }) })), showShare && jsxRuntime.jsx(VoteShare, {})] }));
 };
 
 /**
@@ -17800,7 +17830,7 @@ const VoteResults = ({ question, category, results, screen, isOwner, hasAnswers,
  * Живёт отдельно от `VoteContainer`, потому что тот отвечает за корень контейнера — размеры,
  * фон и заголовок — и не должен раздуваться ветвлением по состояниям.
  */
-const VoteScreen = ({ screen, categories, question, category, results, totalVotes, isOwner, hasAnswers, isEditing, setIsEditing, editInitialValues, submitting, createVote, submitAnswer, editVote, deleteVote, }) => {
+const VoteScreen = ({ type, buttonConfigs, screen, categories, question, category, results, totalVotes, isOwner, hasAnswers, isEditing, setIsEditing, editInitialValues, submitting, createVote, submitAnswer, editVote, deleteVote, }) => {
     const handleCreate = React.useCallback((values) => void createVote(values), [createVote]);
     const handleEdit = React.useCallback((values) => void editVote(values).then(() => setIsEditing(false)), [editVote, setIsEditing]);
     const handleDelete = React.useCallback(() => void deleteVote().then(() => setIsEditing(false)), [deleteVote, setIsEditing]);
@@ -17810,14 +17840,14 @@ const VoteScreen = ({ screen, categories, question, category, results, totalVote
     if (screen === "loading")
         return jsxRuntime.jsx(ContainerLoading, {});
     if (isEditing && question) {
-        return (jsxRuntime.jsx(VoteCreateForm, { categories: categories, initialValues: editInitialValues, isEditing: true, canDelete: !hasAnswers, submitting: submitting, onSubmit: handleEdit, onDelete: handleDelete, onCancel: handleCancel }));
+        return (jsxRuntime.jsx(VoteCreateForm, { type: type, buttonConfigs: buttonConfigs, categories: categories, initialValues: editInitialValues, isEditing: true, canDelete: !hasAnswers, submitting: submitting, onSubmit: handleEdit, onDelete: handleDelete, onCancel: handleCancel }));
     }
     if (screen === "create") {
-        return (jsxRuntime.jsx(VoteCreateForm, { categories: categories, isEditing: false, canDelete: false, submitting: submitting, onSubmit: handleCreate }));
+        return (jsxRuntime.jsx(VoteCreateForm, { type: type, buttonConfigs: buttonConfigs, categories: categories, isEditing: false, canDelete: false, submitting: submitting, onSubmit: handleCreate }));
     }
     if (!question)
         return null;
-    return (jsxRuntime.jsx(VoteResults, { question: question, category: category, results: results, totalVotes: totalVotes, screen: screen, isOwner: isOwner, hasAnswers: hasAnswers, submitting: submitting, onSubmit: handleSubmitAnswer, onEdit: handleEditOpen }));
+    return (jsxRuntime.jsx(VoteResults, { type: type, buttonConfigs: buttonConfigs, question: question, category: category, results: results, totalVotes: totalVotes, screen: screen, isOwner: isOwner, hasAnswers: hasAnswers, submitting: submitting, onSubmit: handleSubmitAnswer, onEdit: handleEditOpen }));
 };
 
 /** Приводит значение атрибута к строке-идентификатору (id приходят числами/строками). */
@@ -18244,6 +18274,9 @@ const useVoteContainer = (elementConfig) => {
     };
 };
 
+/** Слот кнопки существует только при совпадении id и явном type: "button". */
+const getButtonSlot = (children, id) => children?.find((child) => child.id === id && child.type === "button");
+
 /**
  * Контейнер «Голосование»: привязывает опрос к объекту карты через `attributeName`
  * и показывает один из экранов — создание, голосование, после голосования
@@ -18255,6 +18288,13 @@ const useVoteContainer = (elementConfig) => {
 const VoteContainer = React.memo(({ type, elementConfig, isVisible, renderElement }) => {
     const { root, body } = useContainerRoot({ elementConfig });
     const { configured, ...vote } = useVoteContainer(elementConfig);
+    const children = elementConfig?.children;
+    const buttonConfigs = React.useMemo(() => ({
+        submitButton: getButtonSlot(children, "submitButton"),
+        createButton: getButtonSlot(children, "createButton"),
+        saveButton: getButtonSlot(children, "saveButton"),
+        deleteButton: getButtonSlot(children, "deleteButton"),
+    }), [children]);
     // Без имени атрибута или хотя бы одного источника контейнеру не с чем работать. Ошибка вместо
     // пустоты: молчаливый `null` выдавал бы опечатку в конфиге за «блока просто нет».
     if (!configured) {
@@ -18264,7 +18304,7 @@ const VoteContainer = React.memo(({ type, elementConfig, isVisible, renderElemen
     // в карточке в этом случае тоже не нужен, поэтому не рисуем и корень.
     if (!vote.screen)
         return null;
-    return (jsxRuntime.jsxs(ContainerRoot, { ...root, children: [jsxRuntime.jsx(ContainerBackground, { elementConfig: elementConfig, renderElement: renderElement }), jsxRuntime.jsx(ExpandableTitle, { elementConfig: elementConfig, type: type, renderElement: renderElement }), isVisible && (jsxRuntime.jsx(Container, { ...body, isColumn: true, children: jsxRuntime.jsx(VoteScreen, { ...vote, screen: vote.screen }) }))] }));
+    return (jsxRuntime.jsxs(ContainerRoot, { ...root, children: [jsxRuntime.jsx(ContainerBackground, { elementConfig: elementConfig, renderElement: renderElement }), jsxRuntime.jsx(ExpandableTitle, { elementConfig: elementConfig, type: type, renderElement: renderElement }), isVisible && (jsxRuntime.jsx(Container, { ...body, isColumn: true, children: jsxRuntime.jsx(VoteScreen, { ...vote, screen: vote.screen, type: type, buttonConfigs: buttonConfigs }) }))] }));
 });
 
 const ExpandableTitle = React.memo(({ elementConfig, type, renderElement }) => {
@@ -18880,12 +18920,11 @@ const ContainersGroupContainer = React.memo(props => {
 });
 
 const ExportPdfContainer = React.memo(({ type, elementConfig, renderElement }) => {
-    const { t } = useGlobalContext();
     const { loading, onExport } = useExportPdf(getRootElementId(type));
-    const { id, style, options } = elementConfig || {};
-    const { icon, title } = options || {};
+    const { id, style, children } = elementConfig || {};
+    const buttonConfig = React.useMemo(() => getButtonSlot(children, "button"), [children]);
     const bgHost = useBgImageHost(elementConfig);
-    return (jsxRuntime.jsxs(Container, { id: id, style: style, ...bgHost, children: [jsxRuntime.jsx(ContainerBackground, { elementConfig: elementConfig, renderElement: renderElement }), jsxRuntime.jsx(uilibGl.IconButton, { kind: icon || "download", primary: true, disabled: loading, onClick: onExport, children: title ?? t("downloadPdf", { ns: "dashboard", defaultValue: "Скачать PDF" }) })] }));
+    return (jsxRuntime.jsxs(Container, { id: id, style: style, ...bgHost, children: [jsxRuntime.jsx(ContainerBackground, { elementConfig: elementConfig, renderElement: renderElement }), buttonConfig && jsxRuntime.jsx(ContainerButton, { type: type, elementConfig: buttonConfig, disabled: loading, onClick: onExport })] }));
 });
 
 exports.ThemeName = void 0;