@acorex-platform/module-workplacesafety-management-client 0.0.21

package/fesm2022/acorex-platform-module-workplacesafety-management-client-index-kF37zgd4.mjs

@@ -0,0 +1,1900 @@
+import { AXPWidgetsCatalog, AXPSystemStatusType } from '@acorex-platform/framework-shared/core';
+import { AXPDataGenerator, AXPHookService } from '@acorex-platform/framework-client/core';
+import { AXPEntityDataSelectorService, AXPEntityDefinitionRegistryService, AXPEntityService } from '@acorex-platform/framework-client/layout/entity';
+import { AXPCommandService, AXPRuntimeRemoteHookKeys } from '@acorex-platform/framework-client/runtime';
+import { AXPLayoutBuilderService, resolveLayoutBuilderDialogResult } from '@acorex-platform/framework-client/layout/builder';
+import { AXPPageLayoutBaseComponent, AXPPageLayoutBase } from '@acorex-platform/framework-client/layout/views';
+import { clearDependentItemsOnParentChange, enrichSectionTypeSnapshot, isStepTableSectionType, safetyPlanSectionTypeAlreadyExists, SAFETY_PLAN_SECTION_DUPLICATE_SECTION_TYPE_MESSAGE_KEY, collectBuiltInRepeatableSectionTypeIds, RootConfig, WORKPLACE_SAFETY_SECTION_TYPE_LOOKUP_WIDGET_OPTIONS, normalizeStepTableColumns, resolveSafetyPlanSectionItemFilterAsync, resolveSafetyPlanSectionItemEntityKey, resolveSafetyPlanSectionItemColumns, mapSafetyPlanSectionSelectedItems, dedupeSafetyPlanSectionItemSelection, sortStepTableColumns, stepTableColumnKey, resolveStepTableColumnLookupEntity, isStepTableColumnMultiLookup, stepTableColumnTitle, normalizeStepTableRows, resolveEntityRefId, AXMWorkplaceSafetyManagementCommandKeys, dedupeSafetyPlanSectionStructure, buildSectionStructureFromTypeSections, toBuilderValueFromStructure, SAFETY_PLAN_SECTIONS_PAGE_COMPONENT_KEY } from '@acorex-platform/module-workplacesafety-management-client/contracts';
+import * as i0 from '@angular/core';
+import { input, output, viewChild, inject, signal, computed, effect, ChangeDetectionStrategy, Component, untracked, Injectable } from '@angular/core';
+import { isEqual, cloneDeep } from 'lodash';
+import { AXDialogService } from '@acorex/components/dialog';
+import * as i1 from '@acorex/components/button';
+import { AXButtonModule } from '@acorex/components/button';
+import * as i2 from '@acorex/components/decorators';
+import { AXDecoratorModule } from '@acorex/components/decorators';
+import { AXToastService } from '@acorex/components/toast';
+import * as i3$1 from '@acorex/core/translation';
+import { AXTranslationService, AXTranslationModule } from '@acorex/core/translation';
+import { AXPStandardSectionItemsBuilderComponent } from '@acorex-platform/framework-client/layout/components';
+import * as i3 from '@angular/common';
+import { CommonModule, AsyncPipe } from '@angular/common';
+import { n as normalizeSafetyPlanSectionBuilderValue, s as summarizeStepTableRow, S as SAFETY_PLAN_SECTIONS_SAVE_COMMAND, a as safetyPlanSectionsToBuilderValue, h as hydrateStepTableSectionsWithWorkSteps } from './acorex-platform-module-workplacesafety-management-client-save-safety-plan-sections.command-BJsg3pHZ.mjs';
+export { A as AXMSaveSafetyPlanSectionsCommand } from './acorex-platform-module-workplacesafety-management-client-save-safety-plan-sections.command-BJsg3pHZ.mjs';
+
+//#endregion
+//#region ----- Component -----
+class AXMSafetyPlanSectionBuilderComponent {
+    constructor() {
+        //#region ----- Inputs / Outputs -----
+        this.value = input(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "value" }] : /* istanbul ignore next */ []));
+        this.safetyPlanId = input(undefined, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "safetyPlanId" }] : /* istanbul ignore next */ []));
+        this.options = input({}, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "options" }] : /* istanbul ignore next */ []));
+        this.valueChange = output();
+        //#endregion
+        //#region ----- Services & Dependencies -----
+        this.standardRef = viewChild(AXPStandardSectionItemsBuilderComponent, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "standardRef" }] : /* istanbul ignore next */ []));
+        this.layoutBuilder = inject(AXPLayoutBuilderService);
+        this.translationService = inject(AXTranslationService);
+        this.toastService = inject(AXToastService);
+        this.entityDataSelector = inject(AXPEntityDataSelectorService);
+        this.entityRegistry = inject(AXPEntityDefinitionRegistryService);
+        this.entityService = inject(AXPEntityService);
+        //#endregion
+        //#region ----- State Signals -----
+        this.builderValue = signal({ sections: [] }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "builderValue" }] : /* istanbul ignore next */ []));
+        /** Applied on the next builder commit so section header title survives item add/edit. */
+        this.pendingSectionTitles = new Map();
+        this.disabledSectionPrompt = false;
+        this.standardConfig = computed(() => ({
+            mapItemToView: (item) => this.mapItemToView(item),
+            promptAddSection: this.allowAddSection() ? (value) => this.promptAddSection(value) : async () => null,
+            promptEditSection: this.allowEditSection()
+                ? (section, value) => this.promptEditSection(section, value)
+                : this.disabledSectionPrompt,
+            promptAddItems: this.allowAddItems() ? (sectionId, value) => this.promptAddItems(sectionId, value) : undefined,
+            promptEditItem: (item, sectionId, value) => this.promptEditItem(item, sectionId, value),
+            showSectionTechnicalName: false,
+            allowReorderSections: this.allowReorderSections(),
+            minSectionCount: this.allowAddSection() ? 0 : Number.MAX_SAFE_INTEGER,
+            texts: {
+                addSection: '@workplacesafety-management:safety-plan-sections.entities.safety-plan-section.actions.add-section.title',
+                addItem: '@workplacesafety-management:safety-plan-sections.entities.safety-plan-section.actions.add-item.title',
+            },
+        }), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "standardConfig" }] : /* istanbul ignore next */ []));
+        this.hideHeaderActions = computed(() => this.options()['hideHeaderActions'] === true, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "hideHeaderActions" }] : /* istanbul ignore next */ []));
+        this.allowAddSection = computed(() => this.options()['allowAddSection'] !== false, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "allowAddSection" }] : /* istanbul ignore next */ []));
+        this.allowEditSection = computed(() => this.options()['allowEditSection'] === true, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "allowEditSection" }] : /* istanbul ignore next */ []));
+        this.allowEditItem = computed(() => this.options()['allowEditItem'] === true, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "allowEditItem" }] : /* istanbul ignore next */ []));
+        this.allowAddItems = computed(() => this.options()['allowAddItems'] !== false, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "allowAddItems" }] : /* istanbul ignore next */ []));
+        this.allowReorderSections = computed(() => {
+            const option = this.options()['allowReorderSections'];
+            return typeof option === 'boolean' ? option : true;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "allowReorderSections" }] : /* istanbul ignore next */ []));
+        this.readonly = computed(() => this.options()['readonly'] === true, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "readonly" }] : /* istanbul ignore next */ []));
+        //#endregion
+        //#region ----- Lifecycle -----
+        this.#syncValueToBuilder = effect(() => {
+            const normalized = normalizeSafetyPlanSectionBuilderValue(this.value());
+            this.builderValue.set(this.toBuilderValue(normalized));
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "#syncValueToBuilder" }] : /* istanbul ignore next */ []));
+    }
+    //#endregion
+    //#region ----- Lifecycle -----
+    #syncValueToBuilder;
+    //#endregion
+    //#region ----- Public API -----
+    async addSection() {
+        await this.standardRef()?.addSection();
+    }
+    syncAfterSave(value) {
+        const normalized = normalizeSafetyPlanSectionBuilderValue(value);
+        this.builderValue.set(this.toBuilderValue(normalized));
+        queueMicrotask(() => this.standardRef()?.markClean());
+    }
+    resetAfterDiscard() {
+        const normalized = normalizeSafetyPlanSectionBuilderValue(this.value());
+        this.builderValue.set(this.toBuilderValue(normalized));
+        queueMicrotask(() => this.standardRef()?.markClean());
+    }
+    //#endregion
+    //#region ----- Event Handlers -----
+    onBuilderValueChange(next) {
+        const previous = this.fromBuilderValue(this.builderValue());
+        let nextValue = clearDependentItemsOnParentChange(previous, this.fromBuilderValue(next));
+        if (this.pendingSectionTitles.size > 0) {
+            nextValue = {
+                sections: nextValue.sections.map((section) => {
+                    const title = this.pendingSectionTitles.get(section.id);
+                    return title ? { ...section, title } : section;
+                }),
+            };
+            this.pendingSectionTitles.clear();
+        }
+        this.builderValue.set(this.toBuilderValue(nextValue));
+        this.valueChange.emit(nextValue);
+    }
+    //#endregion
+    //#region ----- Section prompts -----
+    async promptAddSection(value) {
+        const dialogValue = await this.promptSectionForm('create', {
+            sectionTypeId: '',
+            sectionTypeDescription: '',
+            title: '',
+            description: '',
+        });
+        if (!dialogValue)
+            return null;
+        if (await this.blockIfSectionTypeExists(value, dialogValue.sectionTypeId, {
+            sectionType: dialogValue.sectionType,
+        })) {
+            return null;
+        }
+        const sectionId = AXPDataGenerator.uuid();
+        return {
+            id: sectionId,
+            name: sectionId,
+            sectionTypeId: dialogValue.sectionTypeId,
+            sectionType: dialogValue.sectionType,
+            title: dialogValue.title,
+            description: dialogValue.description ?? '',
+            safetyPlanId: this.safetyPlanId() ?? '',
+            sortOrder: (value.sections?.length ?? 0) + 1,
+            items: [],
+        };
+    }
+    async promptEditSection(section, value) {
+        const previousSectionTypeId = String(section['sectionTypeId'] ?? '');
+        const sectionTypeSnapshot = section['sectionType'];
+        const dialogValue = await this.promptSectionForm('edit', {
+            sectionTypeId: previousSectionTypeId,
+            sectionType: sectionTypeSnapshot,
+            sectionTypeDescription: enrichSectionTypeSnapshot(previousSectionTypeId, sectionTypeSnapshot)?.description ??
+                String(section['description'] ?? ''),
+            title: String(section['title'] ?? ''),
+            description: String(section['description'] ?? ''),
+        });
+        if (!dialogValue)
+            return null;
+        if (await this.blockIfSectionTypeExists(value, dialogValue.sectionTypeId, {
+            excludeSectionId: String(section.id ?? ''),
+            sectionType: dialogValue.sectionType,
+        })) {
+            return null;
+        }
+        const sectionTypeChanged = previousSectionTypeId !== dialogValue.sectionTypeId;
+        const isStepTable = isStepTableSectionType(dialogValue.sectionTypeId, dialogValue.sectionType);
+        const keepWorkStep = isStepTable && !sectionTypeChanged
+            ? {
+                workStepTypeId: section['workStepTypeId'],
+                workStepType: section['workStepType'],
+                columns: section['columns'],
+            }
+            : {
+                workStepTypeId: undefined,
+                workStepType: undefined,
+                columns: [],
+            };
+        return {
+            ...section,
+            sectionTypeId: dialogValue.sectionTypeId,
+            sectionType: dialogValue.sectionType,
+            title: dialogValue.title,
+            description: dialogValue.description ?? '',
+            ...keepWorkStep,
+            ...(sectionTypeChanged ? { items: [] } : {}),
+        };
+    }
+    async blockIfSectionTypeExists(value, sectionTypeId, options) {
+        const repeatableSectionTypeIds = await this.loadRepeatableSectionTypeIds();
+        const sections = value.sections.map((section) => ({
+            id: String(section.id ?? ''),
+            sectionTypeId: section['sectionTypeId'],
+            sectionType: section['sectionType'],
+        }));
+        if (!safetyPlanSectionTypeAlreadyExists(sections, sectionTypeId, {
+            ...options,
+            repeatableSectionTypeIds,
+            sectionType: options?.sectionType,
+        })) {
+            return false;
+        }
+        this.toastService.show({
+            color: 'danger',
+            title: await this.translationService.translateAsync('@general:messages.generic.error.title'),
+            content: await this.translationService.translateAsync(SAFETY_PLAN_SECTION_DUPLICATE_SECTION_TYPE_MESSAGE_KEY),
+        });
+        return true;
+    }
+    async loadRepeatableSectionTypeIds() {
+        const builtIn = collectBuiltInRepeatableSectionTypeIds();
+        try {
+            const entityKey = `${RootConfig.module.name}.${RootConfig.entities.sectionType.name}`;
+            const result = await this.entityService.withEntity(entityKey).data().query({
+                skip: 0,
+                take: 1000,
+            });
+            const fromQuery = (result.items ?? [])
+                .filter((row) => row.isRepeatable === true)
+                .map((row) => {
+                const id = row.id;
+                return typeof id === 'string' ? id.trim() : '';
+            })
+                .filter(Boolean);
+            return [...new Set([...fromQuery, ...builtIn])];
+        }
+        catch {
+            return builtIn;
+        }
+    }
+    async promptSectionForm(mode, seed) {
+        const titleKey = mode === 'create'
+            ? '@workplacesafety-management:safety-plan-sections.entities.safety-plan-section.actions.add-section.title'
+            : '@general:actions.edit.title';
+        const title = (await this.translationService.translateAsync(titleKey)) || (mode === 'create' ? 'Add Section' : 'Edit');
+        const result = await this.layoutBuilder
+            .create()
+            .dialog((dialog) => {
+            dialog
+                .setTitle(title)
+                .setSize('md')
+                .setCloseButton(true)
+                .setContext({ ...seed })
+                .content((layout) => {
+                layout.mode('edit');
+                layout.dynamicForm(this.buildSectionFormDefinition());
+            })
+                .setActions((actions) => {
+                actions.cancel('@general:actions.cancel.title').submit('@general:actions.save.title');
+            })
+                .onAction((dialogRef) => {
+                if (dialogRef.action() === 'cancel') {
+                    return { success: false };
+                }
+                const context = dialogRef.context();
+                const sectionTypeId = String(context.sectionTypeId ?? '').trim();
+                if (!sectionTypeId) {
+                    return { success: false };
+                }
+                const sectionType = enrichSectionTypeSnapshot(sectionTypeId, context.sectionType);
+                const titleValue = String(context.title ?? '').trim() ||
+                    String(sectionType?.title ?? '').trim() ||
+                    String(sectionType?.code ?? '').trim();
+                if (!titleValue) {
+                    return { success: false };
+                }
+                const description = String(context.sectionTypeDescription ?? '').trim() ||
+                    String(context.description ?? '').trim() ||
+                    String(sectionType?.description ?? '').trim();
+                return {
+                    success: true,
+                    kind: 'object',
+                    value: {
+                        sectionTypeId,
+                        sectionType,
+                        title: titleValue,
+                        description,
+                        sectionTypeDescription: description,
+                    },
+                };
+            });
+        })
+            .show();
+        return result?.success && result.value ? result.value : null;
+    }
+    buildSectionFormDefinition() {
+        const group = {
+            name: 'section',
+            title: '@workplacesafety-management:safety-plan-sections.entities.safety-plan-section.title',
+            parameters: [
+                {
+                    path: 'sectionTypeId',
+                    title: '@workplacesafety-management:safety-plan-sections.entities.safety-plan-section.fields.section-type.title',
+                    widget: {
+                        path: 'sectionTypeId',
+                        type: AXPWidgetsCatalog.lookup,
+                        options: {
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.sectionType.name}`,
+                            ...WORKPLACE_SAFETY_SECTION_TYPE_LOOKUP_WIDGET_OPTIONS,
+                        },
+                    },
+                },
+                {
+                    path: 'sectionTypeDescription',
+                    title: '@workplacesafety-management:safety-plan-sections.entities.safety-plan-section.fields.description.title',
+                    widget: {
+                        path: 'sectionTypeDescription',
+                        type: AXPWidgetsCatalog.largeText,
+                        options: {
+                            readonly: true,
+                            rows: 2,
+                        },
+                    },
+                },
+            ],
+        };
+        return { groups: [group] };
+    }
+    //#endregion
+    //#region ----- Item prompts -----
+    async promptAddItems(sectionId, value) {
+        const section = value.sections.find((s) => s.id === sectionId);
+        if (!section || !this.sectionContextFromBuilderSection(section)) {
+            return null;
+        }
+        let sectionContext = this.sectionContextFromBuilderSection(section);
+        if (isStepTableSectionType(sectionContext.sectionTypeId, sectionContext.sectionType)) {
+            if (!sectionContext.workStepTypeId || sectionContext.columns.length === 0) {
+                const assigned = await this.ensureStepTableWorkStep(sectionId);
+                if (!assigned) {
+                    return null;
+                }
+                const updatedSection = this.builderValue().sections.find((entry) => entry.id === sectionId);
+                const nextContext = updatedSection ? this.sectionContextFromBuilderSection(updatedSection) : null;
+                if (!nextContext?.workStepTypeId || nextContext.columns.length === 0) {
+                    return null;
+                }
+                sectionContext = nextContext;
+            }
+            const currentSection = this.builderValue().sections.find((entry) => entry.id === sectionId) ?? section;
+            const sectionTitle = String(currentSection['title'] ?? '').trim();
+            const sectionTypeTitle = String(sectionContext.sectionType?.title ?? '').trim();
+            const applyTitleToSection = (currentSection.items?.length ?? 0) === 0 ||
+                !sectionTitle ||
+                sectionTitle === sectionTypeTitle ||
+                sectionTitle === sectionContext.sectionTypeId;
+            const row = await this.promptStepTableRowForm('create', sectionContext, {
+                title: applyTitleToSection
+                    ? sectionTitle && sectionTitle !== sectionTypeTitle
+                        ? sectionTitle
+                        : String(sectionContext.workStepType?.title ?? '').trim()
+                    : '',
+            }, { requireTitle: true, applyTitleToSection });
+            if (!row) {
+                return null;
+            }
+            if (applyTitleToSection && row.title?.trim()) {
+                this.patchSectionTitle(sectionId, row.title.trim());
+            }
+            const itemCount = this.builderValue().sections.find((entry) => entry.id === sectionId)?.items.length ??
+                currentSection.items.length;
+            return [this.toBuilderItemFromStepTableRow(row, itemCount)];
+        }
+        const existingIds = this.collectEntityIdsFromBuilderItems(section.items);
+        const dialogValue = await this.openItemDataSelector('create', undefined, sectionId, value, section, true);
+        if (!dialogValue)
+            return null;
+        const selected = this.expandDialogSelectionToLinkedEntities(dialogValue).filter((entry) => !existingIds.has(entry.id));
+        if (!selected.length) {
+            return null;
+        }
+        const startOrder = section.items.length;
+        return selected.map((entry, index) => this.toBuilderItemFromEntity(sectionId, entry, startOrder + index));
+    }
+    async promptEditItem(item, sectionId, value) {
+        const section = value.sections.find((s) => s.id === sectionId);
+        if (!section || !this.sectionContextFromBuilderSection(section)) {
+            return null;
+        }
+        const sectionContext = this.sectionContextFromBuilderSection(section);
+        if (isStepTableSectionType(sectionContext.sectionTypeId, sectionContext.sectionType)) {
+            const existing = item['stepTableRow'];
+            if (!existing || sectionContext.columns.length === 0) {
+                return null;
+            }
+            const seed = {
+                ...this.cellsToDialogValue(existing.cells ?? [], sectionContext.columns),
+                title: String(existing.title ?? item['title'] ?? '').trim(),
+            };
+            const isPrimaryRow = (item.order ?? 0) === 0;
+            const row = await this.promptStepTableRowForm('edit', sectionContext, seed, {
+                requireTitle: true,
+                applyTitleToSection: isPrimaryRow,
+            });
+            if (!row) {
+                return null;
+            }
+            if (isPrimaryRow && row.title?.trim()) {
+                this.patchSectionTitle(sectionId, row.title.trim());
+            }
+            return this.toBuilderItemFromStepTableRow({
+                ...row,
+                code: existing.code,
+            }, item.order ?? 0, String(item.id));
+        }
+        if (!this.allowEditItem()) {
+            return null;
+        }
+        const currentEntityId = this.resolveBuilderItemEntityId(item);
+        const seed = currentEntityId
+            ? {
+                itemIds: [currentEntityId],
+                items: Array.isArray(item['items'])
+                    ? item['items']
+                    : [],
+            }
+            : undefined;
+        const dialogValue = await this.openItemDataSelector('edit', seed, sectionId, value, section, false);
+        if (!dialogValue)
+            return null;
+        const selected = this.expandDialogSelectionToLinkedEntities(dialogValue);
+        if (!selected.length) {
+            return null;
+        }
+        const otherIds = this.collectEntityIdsFromBuilderItems(section.items.filter((row) => String(row.id) !== String(item.id)));
+        const replacement = selected.find((entry) => !otherIds.has(entry.id)) ?? selected[0];
+        return this.toBuilderItemFromEntity(sectionId, replacement, item.order ?? 0);
+    }
+    async toastWorkStepRequired() {
+        this.toastService.show({
+            color: 'warning',
+            title: await this.translationService.translateAsync('@general:messages.generic.error.title'),
+            content: await this.translationService.translateAsync('@workplacesafety-management:safety-plan-sections.messages.work-step-required.message'),
+        });
+    }
+    /** Prompts for Work Step and patches the Step Table section before rows can be added. */
+    async ensureStepTableWorkStep(sectionId) {
+        const picked = await this.promptWorkStepPicker();
+        if (!picked) {
+            return false;
+        }
+        const current = this.fromBuilderValue(this.builderValue());
+        const next = {
+            sections: current.sections.map((section) => {
+                if (section.id !== sectionId) {
+                    return section;
+                }
+                return {
+                    ...section,
+                    workStepTypeId: picked.id,
+                    workStepType: { id: picked.id, title: picked.title, code: picked.code },
+                    columns: picked.columns,
+                };
+            }),
+        };
+        this.builderValue.set(this.toBuilderValue(next));
+        this.valueChange.emit(next);
+        return true;
+    }
+    patchSectionTitle(sectionId, title) {
+        const trimmed = title.trim();
+        if (!trimmed) {
+            return;
+        }
+        this.pendingSectionTitles.set(sectionId, trimmed);
+    }
+    async promptWorkStepPicker() {
+        const title = (await this.translationService.translateAsync('@workplacesafety-management:safety-plan-sections.entities.safety-plan-section.fields.work-step.title')) || 'Work Step';
+        const result = await this.layoutBuilder
+            .create()
+            .dialog((dialog) => {
+            dialog
+                .setTitle(title)
+                .setSize('md')
+                .setCloseButton(true)
+                .setContext({ workStepTypeId: '' })
+                .content((layout) => {
+                layout.mode('edit');
+                layout.dynamicForm({
+                    groups: [
+                        {
+                            name: 'work-step',
+                            title: '@workplacesafety-management:safety-plan-sections.entities.safety-plan-section.fields.work-step.title',
+                            parameters: [
+                                {
+                                    path: 'workStepTypeId',
+                                    title: '@workplacesafety-management:safety-plan-sections.entities.safety-plan-section.fields.work-step.title',
+                                    widget: {
+                                        path: 'workStepTypeId',
+                                        type: AXPWidgetsCatalog.lookup,
+                                        options: {
+                                            entity: `${RootConfig.module.name}.${RootConfig.entities.workStepType.name}`,
+                                            look: 'select',
+                                            textField: 'title',
+                                            valueField: 'id',
+                                            columns: ['code', 'title'],
+                                            expose: [
+                                                { source: 'id', target: 'workStepType.id' },
+                                                { source: 'title', target: 'workStepType.title' },
+                                                { source: 'code', target: 'workStepType.code' },
+                                            ],
+                                        },
+                                    },
+                                },
+                            ],
+                        },
+                    ],
+                });
+            })
+                .setActions((actions) => {
+                actions.cancel('@general:actions.cancel.title').submit('@general:actions.save.title');
+            })
+                .onAction(async (dialogRef) => {
+                if (dialogRef.action() === 'cancel') {
+                    return { success: false };
+                }
+                const context = dialogRef.context();
+                const workStepTypeId = String(context.workStepTypeId ?? '').trim();
+                if (!workStepTypeId) {
+                    return { success: false };
+                }
+                return {
+                    success: true,
+                    kind: 'object',
+                    value: {
+                        workStepTypeId,
+                        workStepType: context.workStepType,
+                    },
+                };
+            });
+        })
+            .show();
+        if (!result?.success || !result.value?.workStepTypeId) {
+            return null;
+        }
+        const loaded = await this.loadWorkStepType(result.value.workStepTypeId);
+        if (!loaded) {
+            await this.toastWorkStepRequired();
+            return null;
+        }
+        return loaded;
+    }
+    sectionContextFromBuilderSection(section) {
+        const sectionTypeId = String(section['sectionTypeId'] ?? '').trim();
+        if (!sectionTypeId) {
+            return null;
+        }
+        return {
+            sectionTypeId,
+            sectionType: enrichSectionTypeSnapshot(sectionTypeId, section['sectionType']),
+            workStepTypeId: typeof section['workStepTypeId'] === 'string' ? section['workStepTypeId'].trim() : undefined,
+            workStepType: section['workStepType'],
+            columns: normalizeStepTableColumns(section['columns']),
+        };
+    }
+    //#endregion
+    //#region ----- Catalog item selector -----
+    resolveSectionIndex(sectionId, builderValue) {
+        const orderedSections = [...builderValue.sections].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+        return orderedSections.findIndex((section) => section.id === sectionId);
+    }
+    async loadHazardRiskRecords(hazardRiskIds) {
+        if (!hazardRiskIds.length) {
+            return [];
+        }
+        const entityKey = `${RootConfig.module.name}.${RootConfig.entities.hazardRisk.name}`;
+        const accessor = this.entityService.withEntity(entityKey);
+        const results = await Promise.all(hazardRiskIds.map((id) => accessor.data().byKey(id).catch(() => null)));
+        return results
+            .filter((record) => record != null)
+            .map((record) => record);
+    }
+    async resolveItemFilterForSection(sectionTypeId, sectionId, builderValue) {
+        const orderedSections = [...builderValue.sections].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+        const sectionIndex = this.resolveSectionIndex(sectionId, builderValue);
+        if (sectionIndex < 0) {
+            return null;
+        }
+        const sections = this.fromBuilderValue({ sections: orderedSections }).sections;
+        return resolveSafetyPlanSectionItemFilterAsync(sectionTypeId, sections, sectionIndex, (ids) => this.loadHazardRiskRecords(ids));
+    }
+    async openItemDataSelector(mode, seed, sectionId, builderValue, section, allowMultiple) {
+        const sectionContext = this.sectionContextFromBuilderSection(section);
+        if (!sectionContext) {
+            return null;
+        }
+        const entityKey = resolveSafetyPlanSectionItemEntityKey(sectionContext.sectionTypeId, sectionContext.sectionType);
+        if (!entityKey) {
+            return null;
+        }
+        const dotIndex = entityKey.indexOf('.');
+        if (dotIndex <= 0) {
+            return null;
+        }
+        const entity = await this.entityRegistry.resolve(entityKey.substring(0, dotIndex), entityKey.substring(dotIndex + 1));
+        if (!entity) {
+            return null;
+        }
+        const filter = await this.resolveItemFilterForSection(sectionContext.sectionTypeId, sectionId, builderValue);
+        const columns = resolveSafetyPlanSectionItemColumns(sectionContext.sectionTypeId);
+        const selectedItemIds = (seed?.itemIds ?? []).filter((id) => typeof id === 'string' && id.length > 0);
+        const titleKey = mode === 'create'
+            ? '@workplacesafety-management:safety-plan-sections.entities.safety-plan-section.actions.add-item.title'
+            : '@general:actions.edit.title';
+        const title = (await this.translationService.translateAsync(titleKey)) || (mode === 'create' ? 'Add Item' : 'Edit');
+        const result = await this.entityDataSelector.open({
+            entity,
+            title,
+            allowMultiple,
+            selectedItemIds: selectedItemIds.length > 0 ? selectedItemIds : undefined,
+            columns,
+            filters: filter ?? undefined,
+            allowCreate: 'none',
+            showCategoryFilter: false,
+        });
+        if (!result) {
+            return null;
+        }
+        if (!result.items?.length) {
+            return mode === 'edit' ? { itemIds: [], items: [] } : null;
+        }
+        const items = mapSafetyPlanSectionSelectedItems(sectionContext.sectionTypeId, result.items);
+        return dedupeSafetyPlanSectionItemSelection({
+            id: `${sectionId}__item_1`,
+            itemIds: items.map((item) => item.id),
+            items,
+        });
+    }
+    //#endregion
+    //#region ----- Builder value mapping -----
+    mapItemToView(item) {
+        const stepTableRow = item['stepTableRow'];
+        if (stepTableRow) {
+            const code = String(stepTableRow.code ?? '').trim();
+            return {
+                icon: 'fa-light fa-table-rows',
+                title: String(stepTableRow.title ?? item['title'] ?? '').trim() || 'Row',
+                name: code || undefined,
+                badges: [],
+            };
+        }
+        const snapshot = Array.isArray(item['items'])
+            ? item['items'][0]
+            : undefined;
+        const title = String(item['title'] ?? snapshot?.title ?? '').trim();
+        const code = String(item['name'] ?? snapshot?.code ?? '').trim();
+        return {
+            icon: 'fa-light fa-list-check',
+            title,
+            name: code || undefined,
+            badges: [],
+        };
+    }
+    toBuilderValue(value) {
+        return {
+            sections: value.sections.map((section, sectionIndex) => ({
+                id: section.id,
+                order: sectionIndex,
+                name: section.id,
+                sectionTypeId: section.sectionTypeId,
+                sectionType: enrichSectionTypeSnapshot(section.sectionTypeId, section.sectionType),
+                title: section.title,
+                description: section.description ?? '',
+                code: section.code,
+                safetyPlanId: section.safetyPlanId ?? this.safetyPlanId() ?? '',
+                sourceSafetyPlanTypeSectionId: section.sourceSafetyPlanTypeSectionId,
+                sortOrder: section.sortOrder ?? sectionIndex + 1,
+                required: section.required === true,
+                workStepTypeId: section.workStepTypeId,
+                workStepType: section.workStepType,
+                columns: normalizeStepTableColumns(section.columns),
+                items: this.expandSectionItemsToBuilderRows(section.id, section.items, section),
+            })),
+        };
+    }
+    fromBuilderValue(value) {
+        return normalizeSafetyPlanSectionBuilderValue({
+            sections: value.sections.map((section, sectionIndex) => ({
+                id: section.id,
+                sectionTypeId: String(section['sectionTypeId'] ?? ''),
+                sectionType: enrichSectionTypeSnapshot(String(section['sectionTypeId'] ?? ''), section['sectionType']),
+                title: String(section['title'] ?? ''),
+                description: String(section['description'] ?? ''),
+                code: typeof section['code'] === 'string' ? section['code'] : undefined,
+                safetyPlanId: String(section['safetyPlanId'] ?? this.safetyPlanId() ?? ''),
+                sourceSafetyPlanTypeSectionId: typeof section['sourceSafetyPlanTypeSectionId'] === 'string'
+                    ? section['sourceSafetyPlanTypeSectionId']
+                    : undefined,
+                sortOrder: typeof section['sortOrder'] === 'number' ? section['sortOrder'] : sectionIndex + 1,
+                required: section['required'] === true,
+                workStepTypeId: typeof section['workStepTypeId'] === 'string' ? section['workStepTypeId'] : undefined,
+                workStepType: section['workStepType'],
+                columns: normalizeStepTableColumns(section['columns']),
+                items: this.collapseBuilderRowsToStorageItems(section.id, section.items, section),
+            })),
+        });
+    }
+    expandSectionItemsToBuilderRows(sectionId, items, section) {
+        if (isStepTableSectionType(section.sectionTypeId, section.sectionType) ||
+            items.some((item) => item.stepTableRow)) {
+            const columns = normalizeStepTableColumns(section.columns);
+            return items
+                .filter((item) => item.stepTableRow)
+                .map((item, order) => this.toBuilderItemFromStepTableRow({
+                ...item.stepTableRow,
+                title: item.stepTableRow.title ||
+                    summarizeStepTableRow(item.stepTableRow.cells ?? [], columns),
+            }, order, item.id));
+        }
+        const linked = this.flattenLinkedEntities(items);
+        return linked.map((entry, order) => this.toBuilderItemFromEntity(sectionId, entry, order));
+    }
+    collapseBuilderRowsToStorageItems(sectionId, items, section) {
+        const ordered = [...items].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+        const sectionTypeId = String(section['sectionTypeId'] ?? '');
+        const sectionType = section['sectionType'];
+        if (isStepTableSectionType(sectionTypeId, sectionType) || ordered.some((item) => item['stepTableRow'])) {
+            const columns = normalizeStepTableColumns(section['columns']);
+            const stepItems = [];
+            ordered.forEach((item, index) => {
+                const stepTableRow = item['stepTableRow'];
+                if (!stepTableRow) {
+                    return;
+                }
+                const stepId = typeof item.id === 'string' && item.id && !String(item.id).includes('__entity_')
+                    ? String(item.id)
+                    : AXPDataGenerator.uuid();
+                const title = stepTableRow.title?.trim() ||
+                    summarizeStepTableRow(stepTableRow.cells ?? [], columns) ||
+                    'Row';
+                stepItems.push({
+                    id: stepId,
+                    itemIds: [stepId],
+                    items: [{ id: stepId, title, code: stepTableRow.code }],
+                    stepTableRow: {
+                        ...stepTableRow,
+                        title,
+                        sortOrder: index + 1,
+                    },
+                });
+            });
+            return stepItems;
+        }
+        const itemIds = [];
+        const snapshots = [];
+        for (const item of ordered) {
+            const entityId = this.resolveBuilderItemEntityId(item);
+            if (!entityId || itemIds.includes(entityId)) {
+                continue;
+            }
+            itemIds.push(entityId);
+            const snapshot = Array.isArray(item['items'])
+                ? item['items'][0]
+                : undefined;
+            snapshots.push({
+                id: entityId,
+                title: (typeof snapshot?.title === 'string' && snapshot.title) ||
+                    (typeof item['title'] === 'string' ? item['title'] : undefined),
+                code: (typeof snapshot?.code === 'string' && snapshot.code) ||
+                    (typeof item['name'] === 'string' ? item['name'] : undefined),
+            });
+        }
+        if (!itemIds.length) {
+            return [];
+        }
+        return [
+            dedupeSafetyPlanSectionItemSelection({
+                id: `${sectionId}__item_1`,
+                itemIds,
+                items: snapshots,
+            }),
+        ];
+    }
+    flattenLinkedEntities(items) {
+        const linked = [];
+        const seen = new Set();
+        for (const slot of items) {
+            const ids = Array.isArray(slot.itemIds) ? slot.itemIds : [];
+            const snapshots = Array.isArray(slot.items) ? slot.items : [];
+            for (let index = 0; index < ids.length; index += 1) {
+                const id = String(ids[index] ?? '').trim();
+                if (!id || seen.has(id)) {
+                    continue;
+                }
+                seen.add(id);
+                const snapshot = snapshots.find((entry) => entry?.id === id) ?? snapshots[index];
+                linked.push({
+                    id,
+                    title: snapshot?.title,
+                    code: snapshot?.code,
+                });
+            }
+        }
+        return linked;
+    }
+    expandDialogSelectionToLinkedEntities(dialogValue) {
+        return this.flattenLinkedEntities([
+            {
+                id: 'dialog',
+                itemIds: [...(dialogValue.itemIds ?? [])],
+                items: dialogValue.items ? [...dialogValue.items] : [],
+            },
+        ]);
+    }
+    collectEntityIdsFromBuilderItems(items) {
+        const ids = new Set();
+        for (const item of items) {
+            const entityId = this.resolveBuilderItemEntityId(item);
+            if (entityId) {
+                ids.add(entityId);
+            }
+        }
+        return ids;
+    }
+    resolveBuilderItemEntityId(item) {
+        if (typeof item['entityId'] === 'string' && item['entityId'].trim()) {
+            return item['entityId'].trim();
+        }
+        if (Array.isArray(item['itemIds']) && typeof item['itemIds'][0] === 'string' && item['itemIds'][0].trim()) {
+            return item['itemIds'][0].trim();
+        }
+        const snapshot = Array.isArray(item['items'])
+            ? item['items'][0]
+            : undefined;
+        if (typeof snapshot?.id === 'string' && snapshot.id.trim()) {
+            return snapshot.id.trim();
+        }
+        return null;
+    }
+    toBuilderItemFromEntity(sectionId, entry, order) {
+        const title = String(entry.title ?? '').trim();
+        const code = String(entry.code ?? '').trim();
+        return {
+            id: `${sectionId}__entity_${entry.id}`,
+            order,
+            entityId: entry.id,
+            itemIds: [entry.id],
+            items: [{ id: entry.id, title: title || undefined, code: code || undefined }],
+            title,
+            name: code,
+        };
+    }
+    toBuilderItemFromStepTableRow(row, order, id) {
+        const stepId = typeof id === 'string' && id.trim() && !id.includes('__item_') && !id.includes('__entity_')
+            ? id.trim()
+            : AXPDataGenerator.uuid();
+        const title = String(row.title ?? '').trim() || 'Row';
+        const code = String(row.code ?? '').trim();
+        return {
+            id: stepId,
+            order,
+            entityId: stepId,
+            itemIds: [stepId],
+            items: [{ id: stepId, title, code: code || undefined }],
+            title,
+            name: code,
+            stepTableRow: {
+                ...row,
+                title,
+                sortOrder: order + 1,
+            },
+        };
+    }
+    //#endregion
+    //#region ----- Step Table row dialog -----
+    async promptStepTableRowForm(mode, sectionContext, seed, options) {
+        const columns = sortStepTableColumns(sectionContext.columns);
+        const requireTitle = options?.requireTitle === true;
+        const titleKey = mode === 'create'
+            ? '@workplacesafety-management:safety-plan-sections.entities.safety-plan-section.actions.add-row.title'
+            : '@general:actions.edit.title';
+        const dialogTitle = (await this.translationService.translateAsync(titleKey)) ||
+            (mode === 'create' ? 'Add Row' : 'Edit');
+        const result = await this.layoutBuilder
+            .create()
+            .dialog((dialog) => {
+            dialog
+                .setTitle(dialogTitle)
+                .setSize('lg')
+                .setCloseButton(true)
+                .setContext({ ...seed })
+                .content((layout) => {
+                layout.mode('edit');
+                layout.dynamicForm(this.buildStepTableRowFormDefinition(columns, { includeTitle: requireTitle }));
+            })
+                .setActions((actions) => {
+                actions.cancel('@general:actions.cancel.title').submit('@general:actions.save.title');
+            })
+                .onAction((dialogRef) => {
+                if (dialogRef.action() === 'cancel') {
+                    return { success: false };
+                }
+                const context = dialogRef.context();
+                const customTitle = String(context['title'] ?? '').trim();
+                if (requireTitle && !customTitle) {
+                    return { success: false };
+                }
+                const cells = this.dialogValueToCells(context, columns);
+                if (!this.validateRequiredStepTableCells(cells, columns)) {
+                    return { success: false };
+                }
+                return {
+                    success: true,
+                    kind: 'object',
+                    value: {
+                        cells,
+                        title: customTitle || summarizeStepTableRow(cells, columns),
+                    },
+                };
+            });
+        })
+            .show();
+        return result?.success && result.value ? result.value : null;
+    }
+    buildStepTableRowFormDefinition(columns, options) {
+        const ordered = sortStepTableColumns(columns);
+        const parameters = [];
+        if (options?.includeTitle) {
+            parameters.push({
+                path: 'title',
+                title: '@workplacesafety-management:safety-plan-sections.entities.safety-plan-section.fields.title.title',
+                widget: {
+                    path: 'title',
+                    type: AXPWidgetsCatalog.text,
+                    options: {
+                        placeholder: '@workplacesafety-management:safety-plan-sections.entities.safety-plan-section.fields.title.placeholder',
+                    },
+                },
+            });
+        }
+        for (const column of ordered) {
+            const key = stepTableColumnKey(column);
+            const lookupEntity = resolveStepTableColumnLookupEntity(column);
+            const multi = isStepTableColumnMultiLookup(column);
+            parameters.push({
+                path: key,
+                title: stepTableColumnTitle(column),
+                widget: lookupEntity
+                    ? {
+                        path: key,
+                        type: AXPWidgetsCatalog.lookup,
+                        options: {
+                            look: multi ? 'lookup' : 'select',
+                            entity: lookupEntity,
+                            textField: 'title',
+                            valueField: 'id',
+                            columns: ['code', 'title'],
+                            ...(multi ? { multiple: true } : {}),
+                            expose: multi
+                                ? [
+                                    { source: 'id', target: `${key}Refs.{id}` },
+                                    { source: 'title', target: `${key}Refs.{title}` },
+                                    { source: 'code', target: `${key}Refs.{code}` },
+                                ]
+                                : [
+                                    { source: 'id', target: `${key}Ref.id` },
+                                    { source: 'title', target: `${key}Ref.title` },
+                                    { source: 'code', target: `${key}Ref.code` },
+                                ],
+                        },
+                    }
+                    : {
+                        path: key,
+                        type: AXPWidgetsCatalog.text,
+                    },
+            });
+        }
+        return {
+            groups: [
+                {
+                    name: 'step-table-row',
+                    title: '@workplacesafety-management:safety-plan-work-steps.entities.safety-plan-work-step.groups.table-content',
+                    parameters,
+                },
+            ],
+        };
+    }
+    validateRequiredStepTableCells(cells, columns) {
+        for (const column of columns) {
+            if (column.required !== true) {
+                continue;
+            }
+            const key = stepTableColumnKey(column);
+            const cell = cells.find((entry) => entry.columnKey === key);
+            if (!cell) {
+                return false;
+            }
+            const lookupEntity = resolveStepTableColumnLookupEntity(column);
+            if (lookupEntity) {
+                if (!(cell.refIds?.length)) {
+                    return false;
+                }
+            }
+            else if (!cell.textValue?.trim()) {
+                return false;
+            }
+        }
+        return true;
+    }
+    cellsToDialogValue(cells, columns) {
+        const ordered = sortStepTableColumns(columns);
+        const normalized = normalizeStepTableRows([{ id: 'row', sortOrder: 1, cells }], ordered)[0];
+        const dialogRow = {};
+        for (const column of ordered) {
+            const key = stepTableColumnKey(column);
+            const cell = normalized?.cells.find((entry) => entry.columnKey === key);
+            if (!cell) {
+                continue;
+            }
+            const lookupEntity = resolveStepTableColumnLookupEntity(column);
+            if (!lookupEntity) {
+                dialogRow[key] = cell.textValue ?? '';
+                continue;
+            }
+            if (isStepTableColumnMultiLookup(column)) {
+                dialogRow[key] = cell.refIds ?? [];
+                dialogRow[`${key}Refs`] = cell.refs ?? [];
+            }
+            else {
+                dialogRow[key] = cell.refIds?.[0];
+                dialogRow[`${key}Ref`] = cell.refs?.[0];
+            }
+        }
+        return dialogRow;
+    }
+    dialogValueToCells(row, columns) {
+        const ordered = sortStepTableColumns(columns);
+        return ordered.map((column) => {
+            const key = stepTableColumnKey(column);
+            const lookupEntity = resolveStepTableColumnLookupEntity(column);
+            if (!lookupEntity) {
+                return {
+                    columnKey: key,
+                    textValue: typeof row[key] === 'string' ? String(row[key]) : '',
+                };
+            }
+            if (isStepTableColumnMultiLookup(column)) {
+                const refs = Array.isArray(row[`${key}Refs`])
+                    ? row[`${key}Refs`]
+                    : [];
+                const ids = Array.isArray(row[key])
+                    ? row[key].filter((value) => typeof value === 'string')
+                    : refs
+                        .map((ref) => (typeof ref?.id === 'string' ? ref.id : ''))
+                        .filter(Boolean);
+                return {
+                    columnKey: key,
+                    refIds: ids,
+                    refs: ids.map((idValue) => {
+                        const ref = refs.find((entry) => entry?.id === idValue);
+                        return { id: idValue, title: ref?.title, code: ref?.code };
+                    }),
+                };
+            }
+            const ref = row[`${key}Ref`];
+            const idValue = (typeof row[key] === 'string' && String(row[key])) ||
+                (typeof ref?.id === 'string' ? ref.id : '');
+            return {
+                columnKey: key,
+                refIds: idValue ? [idValue] : [],
+                refs: idValue ? [{ id: idValue, title: ref?.title, code: ref?.code }] : [],
+            };
+        });
+    }
+    async loadWorkStepType(workStepTypeId) {
+        try {
+            const entityKey = `${RootConfig.module.name}.${RootConfig.entities.workStepType.name}`;
+            const row = await this.entityService.withEntity(entityKey).data().byKey(workStepTypeId);
+            if (!row) {
+                return null;
+            }
+            const record = row;
+            return {
+                id: String(record.id ?? workStepTypeId),
+                title: record.title,
+                code: record.code,
+                columns: normalizeStepTableColumns(record.columns),
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMSafetyPlanSectionBuilderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.8", type: AXMSafetyPlanSectionBuilderComponent, isStandalone: true, selector: "axm-safety-plan-section-builder", inputs: { value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null }, safetyPlanId: { classPropertyName: "safetyPlanId", publicName: "safetyPlanId", isSignal: true, isRequired: false, transformFunction: null }, options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { valueChange: "valueChange" }, viewQueries: [{ propertyName: "standardRef", first: true, predicate: AXPStandardSectionItemsBuilderComponent, descendants: true, isSignal: true }], ngImport: i0, template: "<div class=\"axm-safety-plan-section-builder\">\n  @if (!readonly() && !hideHeaderActions() && allowAddSection()) {\n    <div class=\"__header\">\n      <div class=\"__header-left\"></div>\n      <div class=\"__header-right\">\n        <ax-button\n          class=\"ax-sm\"\n          [text]=\"\n            '@workplacesafety-management:safety-plan-sections.entities.safety-plan-section.actions.add-section.title'\n              | translate\n              | async\n          \"\n          [color]=\"'primary'\"\n          (onClick)=\"addSection()\"\n        >\n          <ax-prefix>\n            <ax-icon icon=\"fa-light fa-layer-group\"></ax-icon>\n          </ax-prefix>\n        </ax-button>\n      </div>\n    </div>\n  }\n\n  <axp-standard-section-items-builder\n    class=\"block min-h-[200px]\"\n    [value]=\"builderValue()\"\n    [config]=\"standardConfig()\"\n    [readonly]=\"readonly()\"\n    (valueChange)=\"onBuilderValueChange($event)\"\n  />\n</div>\n", styles: [".axm-safety-plan-section-builder .__header{margin-bottom:calc(var(--spacing, .25rem) * 3);display:flex;align-items:center;justify-content:space-between}\n/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: AXButtonModule }, { kind: "component", type: i1.AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "iconOnly", "type", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "loadingTextChange"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i2.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }, { kind: "component", type: i2.AXDecoratorGenericComponent, selector: "ax-footer, ax-header, ax-content, ax-divider, ax-form-hint, ax-prefix, ax-suffix, ax-text, ax-title, ax-subtitle, ax-placeholder, ax-overlay" }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "component", type: AXPStandardSectionItemsBuilderComponent, selector: "axp-standard-section-items-builder", inputs: ["value", "config", "readonly"], outputs: ["valueChange"] }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }, { kind: "pipe", type: i3$1.AXTranslatorPipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMSafetyPlanSectionBuilderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axm-safety-plan-section-builder', changeDetection: ChangeDetectionStrategy.OnPush, imports: [CommonModule, AXButtonModule, AXDecoratorModule, AXTranslationModule, AXPStandardSectionItemsBuilderComponent], template: "<div class=\"axm-safety-plan-section-builder\">\n  @if (!readonly() && !hideHeaderActions() && allowAddSection()) {\n    <div class=\"__header\">\n      <div class=\"__header-left\"></div>\n      <div class=\"__header-right\">\n        <ax-button\n          class=\"ax-sm\"\n          [text]=\"\n            '@workplacesafety-management:safety-plan-sections.entities.safety-plan-section.actions.add-section.title'\n              | translate\n              | async\n          \"\n          [color]=\"'primary'\"\n          (onClick)=\"addSection()\"\n        >\n          <ax-prefix>\n            <ax-icon icon=\"fa-light fa-layer-group\"></ax-icon>\n          </ax-prefix>\n        </ax-button>\n      </div>\n    </div>\n  }\n\n  <axp-standard-section-items-builder\n    class=\"block min-h-[200px]\"\n    [value]=\"builderValue()\"\n    [config]=\"standardConfig()\"\n    [readonly]=\"readonly()\"\n    (valueChange)=\"onBuilderValueChange($event)\"\n  />\n</div>\n", styles: [".axm-safety-plan-section-builder .__header{margin-bottom:calc(var(--spacing, .25rem) * 3);display:flex;align-items:center;justify-content:space-between}\n/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */\n"] }]
+        }], propDecorators: { value: [{ type: i0.Input, args: [{ isSignal: true, alias: "value", required: false }] }], safetyPlanId: [{ type: i0.Input, args: [{ isSignal: true, alias: "safetyPlanId", required: false }] }], options: [{ type: i0.Input, args: [{ isSignal: true, alias: "options", required: false }] }], valueChange: [{ type: i0.Output, args: ["valueChange"] }], standardRef: [{ type: i0.ViewChild, args: [i0.forwardRef(() => AXPStandardSectionItemsBuilderComponent), { isSignal: true }] }] } });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Constants   ----
+const SAFETY_PLAN_SECTIONS_ADD_SECTION_COMMAND = 'SafetyPlan:Sections:AddSection';
+const SAFETY_PLAN_SECTIONS_DISCARD_COMMAND = 'SafetyPlan:Sections:Discard';
+const SAFETY_PLAN_SECTIONS_CHANGE_PLAN_TYPE_COMMAND = 'SafetyPlan:Sections:ChangePlanType';
+const SAFETY_PLAN_SECTION_ENTITY = `${RootConfig.module.name}.${RootConfig.entities.safetyPlanSection.name}`;
+const SAFETY_PLAN_WORK_STEP_ENTITY = `${RootConfig.module.name}.${RootConfig.entities.safetyPlanWorkStep.name}`;
+const SAFETY_PLAN_TYPE_SECTION_ENTITY = `${RootConfig.module.name}.${RootConfig.entities.safetyPlanTypeSection.name}`;
+const SAFETY_PLAN_TYPE_ENTITY = RootConfig.entities.safetyPlanType.source;
+const SECTION_TYPE_ENTITY = `${RootConfig.module.name}.${RootConfig.entities.sectionType.name}`;
+//#endregion
+//#region ----   Component   ----
+class AXMSafetyPlanSectionsPageComponent extends AXPPageLayoutBaseComponent {
+    constructor() {
+        super(...arguments);
+        this.rootContext = input({}, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "rootContext" }] : /* istanbul ignore next */ []));
+        this.pageConfig = input(/* @ts-ignore */
+        ...(ngDevMode ? [undefined, { debugName: "pageConfig" }] : /* istanbul ignore next */ []));
+        this.options = input({}, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "options" }] : /* istanbul ignore next */ []));
+        this.builderRef = viewChild('builderRef', /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "builderRef" }] : /* istanbul ignore next */ []));
+        this.commandService = inject(AXPCommandService);
+        this.entityService = inject(AXPEntityService);
+        this.dialogService = inject(AXDialogService);
+        this.layoutBuilder = inject(AXPLayoutBuilderService);
+        this.hooks = inject(AXPHookService);
+        this.hostPageLayout = inject(AXPPageLayoutBase, { optional: true, skipSelf: true });
+        this.baselineValue = signal(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "baselineValue" }] : /* istanbul ignore next */ []));
+        this.committedValue = signal(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "committedValue" }] : /* istanbul ignore next */ []));
+        this.isLoadingStructure = signal(false, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "isLoadingStructure" }] : /* istanbul ignore next */ []));
+        /** Prevents re-entrant sync loops when applyStructure mutates shared form context. */
+        this.lastSyncedKey = signal(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "lastSyncedKey" }] : /* istanbul ignore next */ []));
+        /** In-flight sync key — blocks concurrent loads for the same pair without blocking retries after cancel. */
+        this.inflightSyncKey = signal(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "inflightSyncKey" }] : /* istanbul ignore next */ []));
+        this.appliedPlanTypeId = signal(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "appliedPlanTypeId" }] : /* istanbul ignore next */ []));
+        /** Keeps plan type in sync after Change Plan Type when parent form context is mutated in place. */
+        this.planTypeOverride = signal(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "planTypeOverride" }] : /* istanbul ignore next */ []));
+        this.safetyPlanId = computed(() => {
+            const raw = this.rootContext()?.['id'];
+            return typeof raw === 'string' && raw.length > 0 ? raw : null;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "safetyPlanId" }] : /* istanbul ignore next */ []));
+        this.planTypeId = computed(() => {
+            const override = this.planTypeOverride();
+            if (override) {
+                return override;
+            }
+            const ctx = this.rootContext() ?? {};
+            return (resolveEntityRefId(ctx['safetyPlanTypeId']) ??
+                resolveEntityRefId(ctx['safetyPlanType']?.id) ??
+                resolveEntityRefId(ctx['safetyPlanType']));
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "planTypeId" }] : /* istanbul ignore next */ []));
+        this.hasPlanType = computed(() => !!this.planTypeId(), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "hasPlanType" }] : /* istanbul ignore next */ []));
+        this.isDraftPlan = computed(() => {
+            const status = this.rootContext()?.['status'];
+            return !status || status === AXPSystemStatusType.Draft;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "isDraftPlan" }] : /* istanbul ignore next */ []));
+        this.builderOptions = computed(() => ({
+            hideHeaderActions: true,
+            readonly: !this.isDraftPlan() || this.isLoadingStructure(),
+            allowAddSection: this.isDraftPlan() && !this.isLoadingStructure(),
+            allowAddItems: this.isDraftPlan() && !this.isLoadingStructure(),
+            allowReorderSections: this.isDraftPlan() && !this.isLoadingStructure(),
+            ...(this.pageConfig() ?? {}),
+            ...(this.options() ?? {}),
+            allowEditSection: false,
+            allowEditItem: false,
+        }), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "builderOptions" }] : /* istanbul ignore next */ []));
+        this.isDirty = computed(() => {
+            return !isEqual(this.baselineValue() ?? { sections: [] }, this.committedValue() ?? { sections: [] });
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "isDirty" }] : /* istanbul ignore next */ []));
+        this.#syncFromContext = effect((onCleanup) => {
+            const planId = this.safetyPlanId();
+            const typeId = this.planTypeId();
+            const syncKey = `${planId ?? ''}|${typeId ?? ''}`;
+            // Already applied or already loading for this plan/type pair.
+            if (untracked(() => this.lastSyncedKey()) === syncKey ||
+                untracked(() => this.inflightSyncKey()) === syncKey) {
+                return;
+            }
+            this.inflightSyncKey.set(syncKey);
+            let cancelled = false;
+            const clearInflight = () => {
+                if (untracked(() => this.inflightSyncKey()) === syncKey) {
+                    this.inflightSyncKey.set(null);
+                }
+            };
+            const markSynced = () => {
+                this.lastSyncedKey.set(syncKey);
+                clearInflight();
+            };
+            const run = async () => {
+                if (cancelled) {
+                    return;
+                }
+                const repeatableSectionTypeIds = await this.loadRepeatableSectionTypeIds();
+                if (cancelled) {
+                    return;
+                }
+                // Edit: load independent saved sections once — never append type defaults on top.
+                if (planId) {
+                    this.isLoadingStructure.set(true);
+                    try {
+                        const loaded = await this.fetchSectionsFromBackend(planId, repeatableSectionTypeIds);
+                        if (cancelled)
+                            return;
+                        if (loaded.sections.length > 0) {
+                            // Replace UI from backend (deduped). Never append defaults on top of saved rows.
+                            this.applyStructure(loaded, { asBaseline: true });
+                            this.appliedPlanTypeId.set(typeId);
+                            markSynced();
+                            return;
+                        }
+                        // No saved rows yet — fall through to type defaults when type is known.
+                    }
+                    catch {
+                        if (cancelled)
+                            return;
+                        clearInflight();
+                        await this.showStructureLoadError();
+                        return;
+                    }
+                    finally {
+                        if (!cancelled) {
+                            this.isLoadingStructure.set(false);
+                        }
+                    }
+                    if (cancelled) {
+                        return;
+                    }
+                }
+                if (!typeId) {
+                    this.appliedPlanTypeId.set(null);
+                    this.applyStructure({ sections: [] }, { asBaseline: true });
+                    markSynced();
+                    return;
+                }
+                const previousTypeId = untracked(() => this.appliedPlanTypeId());
+                const currentSections = untracked(() => this.committedValue()?.sections ?? []);
+                if (previousTypeId && previousTypeId !== typeId && currentSections.length > 0) {
+                    const confirmed = await this.confirmReplaceStructure();
+                    if (cancelled)
+                        return;
+                    if (!confirmed) {
+                        // Keep previous structure; mark new type as handled so we do not loop.
+                        this.appliedPlanTypeId.set(typeId);
+                        markSynced();
+                        return;
+                    }
+                }
+                this.isLoadingStructure.set(true);
+                try {
+                    const defaults = await this.loadDefaultsForPlanType(typeId, repeatableSectionTypeIds);
+                    if (cancelled)
+                        return;
+                    // Replace (never append) the current collection with type defaults.
+                    this.applyStructure(defaults, { asBaseline: true });
+                    this.appliedPlanTypeId.set(typeId);
+                    markSynced();
+                }
+                catch {
+                    if (cancelled)
+                        return;
+                    clearInflight();
+                    await this.showStructureLoadError();
+                }
+                finally {
+                    if (!cancelled) {
+                        this.isLoadingStructure.set(false);
+                    }
+                }
+            };
+            void run();
+            onCleanup(() => {
+                cancelled = true;
+                clearInflight();
+            });
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "#syncFromContext" }] : /* istanbul ignore next */ []));
+    }
+    #syncFromContext;
+    onValueChange(value) {
+        const withOrder = normalizeSafetyPlanSectionBuilderValue({
+            sections: value.sections.map((section, index) => ({
+                ...section,
+                sortOrder: index + 1,
+            })),
+        });
+        this.committedValue.set(withOrder);
+        this.updateRootContextField('sectionStructure', withOrder);
+        this.updateRootContextField('sections', withOrder);
+        this.recompute();
+    }
+    getWizardStepContext() {
+        const value = this.committedValue();
+        if (!value) {
+            return null;
+        }
+        const cloned = cloneDeep(value);
+        return { sectionStructure: cloned, sections: cloned };
+    }
+    hasUnsavedChanges() {
+        return this.isDirty();
+    }
+    async getPrimaryMenuItems() {
+        if (!this.isDraftPlan() || this.isLoadingStructure()) {
+            return [];
+        }
+        const actions = [
+            {
+                title: '@workplacesafety-management:safety-plan-sections.entities.safety-plan-section.actions.add-section.title',
+                icon: 'fa-light fa-layer-group',
+                zone: 'header',
+                priority: 'primary',
+                color: 'primary',
+                command: { name: SAFETY_PLAN_SECTIONS_ADD_SECTION_COMMAND, options: {} },
+            },
+            {
+                title: '@workplacesafety-management:safety-plans.actions.change-plan-type.title',
+                icon: 'fa-light fa-arrow-right-arrow-left',
+                zone: 'header',
+                priority: 'secondary',
+                color: 'default',
+                visible: this.isDraftPlan() && (!!this.planTypeId() || !!this.safetyPlanId()),
+                command: { name: SAFETY_PLAN_SECTIONS_CHANGE_PLAN_TYPE_COMMAND, options: {} },
+            },
+        ];
+        if (this.safetyPlanId()) {
+            actions.push({
+                title: '@general:actions.discard.title',
+                icon: 'fa-light fa-rotate-left',
+                zone: 'footer',
+                priority: 'secondary',
+                color: 'default',
+                visible: this.isDirty(),
+                command: { name: SAFETY_PLAN_SECTIONS_DISCARD_COMMAND, options: {} },
+            }, {
+                title: '@general:actions.save.title',
+                icon: 'fa-light fa-floppy-disk',
+                zone: 'footer',
+                priority: 'primary',
+                color: 'primary',
+                visible: this.isDirty(),
+                command: { name: SAFETY_PLAN_SECTIONS_SAVE_COMMAND, options: {} },
+            });
+        }
+        return actions;
+    }
+    async execute(command) {
+        if (command.name === SAFETY_PLAN_SECTIONS_ADD_SECTION_COMMAND) {
+            await this.builderRef()?.addSection();
+            return;
+        }
+        if (command.name === SAFETY_PLAN_SECTIONS_CHANGE_PLAN_TYPE_COMMAND) {
+            await this.handleChangePlanType();
+            return;
+        }
+        if (command.name === SAFETY_PLAN_SECTIONS_DISCARD_COMMAND) {
+            this.handleDiscard();
+            return;
+        }
+        if (command.name !== SAFETY_PLAN_SECTIONS_SAVE_COMMAND)
+            return;
+        await this.handleSave({ silent: false });
+    }
+    async handleChangePlanType() {
+        if (!this.isDraftPlan()) {
+            this.toastService.show({
+                color: 'warning',
+                title: await this.translateService.translateAsync('@general:messages.generic.error.title'),
+                content: await this.translateService.translateAsync('@workplacesafety-management:safety-plans.messages.section-structure.draft-only'),
+            });
+            return;
+        }
+        const selection = await this.promptChangePlanTypeDialog();
+        if (!selection) {
+            return;
+        }
+        const currentTypeId = this.planTypeId();
+        if (currentTypeId && currentTypeId === selection.safetyPlanTypeId) {
+            this.toastService.show({
+                color: 'warning',
+                title: await this.translateService.translateAsync('@general:messages.generic.error.title'),
+                content: await this.translateService.translateAsync('@workplacesafety-management:safety-plans.messages.section-structure.same-plan-type'),
+            });
+            return;
+        }
+        const confirmed = await this.confirmChangePlanType();
+        if (!confirmed) {
+            return;
+        }
+        const planId = this.safetyPlanId();
+        this.isLoadingStructure.set(true);
+        try {
+            if (planId) {
+                await this.applyPersistedPlanTypeChange(planId, selection);
+            }
+            else {
+                await this.applyWizardPlanTypeChange(selection);
+            }
+        }
+        catch {
+            this.toastService.show({
+                color: 'danger',
+                title: await this.translateService.translateAsync('@general:messages.generic.error.title'),
+                content: await this.translateService.translateAsync('@workplacesafety-management:safety-plans.messages.section-structure.change-plan-type-failed'),
+            });
+        }
+        finally {
+            this.isLoadingStructure.set(false);
+        }
+    }
+    async promptChangePlanTypeDialog() {
+        const ctx = this.rootContext() ?? {};
+        const currentType = ctx['safetyPlanType'] ?? {};
+        const currentTypeId = this.planTypeId() ?? '';
+        const result = await this.layoutBuilder
+            .create()
+            .dialog((dialog) => {
+            dialog
+                .setTitle('@workplacesafety-management:safety-plans.actions.change-plan-type.dialog.title')
+                .setSize('md')
+                .setCloseButton(true)
+                .setContext({
+                safetyPlanTypeId: currentTypeId,
+                safetyPlanType: currentTypeId
+                    ? {
+                        id: currentTypeId,
+                        title: typeof currentType.title === 'string' ? currentType.title : undefined,
+                        code: typeof currentType.code === 'string' ? currentType.code : undefined,
+                    }
+                    : undefined,
+            })
+                .content((flex) => {
+                flex
+                    .setDirection('column')
+                    .setGap('12px')
+                    .formField('@workplacesafety-management:safety-plans.actions.change-plan-type.dialog.fields.plan-type.title', (field) => {
+                    field.path('safetyPlanTypeId');
+                    field.lookupBox({
+                        entity: SAFETY_PLAN_TYPE_ENTITY,
+                        look: 'select',
+                        searchable: true,
+                        textField: 'title',
+                        valueField: 'id',
+                        columns: ['code', 'title'],
+                        expose: [
+                            { source: 'id', target: 'safetyPlanType.id' },
+                            { source: 'title', target: 'safetyPlanType.title' },
+                            { source: 'code', target: 'safetyPlanType.code' },
+                        ],
+                        validations: [{ rule: 'required' }],
+                    });
+                });
+            })
+                .setActions((actions) => {
+                actions
+                    .cancel('@general:actions.cancel.title')
+                    .submit('@workplacesafety-management:safety-plans.actions.change-plan-type.dialog.actions.continue');
+            })
+                .onAction(async (dialogRef) => {
+                if (dialogRef.action() === 'cancel') {
+                    return null;
+                }
+                const context = dialogRef.context();
+                const safetyPlanTypeId = resolveEntityRefId(context.safetyPlanTypeId);
+                if (!safetyPlanTypeId) {
+                    throw new Error((await this.translateService.translateAsync('@workplacesafety-management:safety-plans.actions.change-plan-type.dialog.fields.plan-type.placeholder')) || 'Select a Plan Type');
+                }
+                return {
+                    safetyPlanTypeId,
+                    safetyPlanType: context.safetyPlanType?.id
+                        ? context.safetyPlanType
+                        : { id: safetyPlanTypeId },
+                };
+            });
+        })
+            .show();
+        return resolveLayoutBuilderDialogResult(result);
+    }
+    async confirmChangePlanType() {
+        const title = (await this.translateService.translateAsync('@workplacesafety-management:safety-plans.messages.section-structure.confirm-change-plan-type.title')) || 'Change Plan Type?';
+        const message = (await this.translateService.translateAsync('@workplacesafety-management:safety-plans.messages.section-structure.confirm-change-plan-type.message')) ||
+            'Changing the Plan Type will discard all existing sections and their selected values. The default sections for the new Plan Type will be loaded. Do you want to continue?';
+        const dialogResult = await this.dialogService.confirm(title, message, 'danger', 'horizontal');
+        return dialogResult.result === true;
+    }
+    async applyPersistedPlanTypeChange(planId, selection) {
+        const payload = await this.hooks.runAsync(AXPRuntimeRemoteHookKeys.CommandExecute, {
+            name: AXMWorkplaceSafetyManagementCommandKeys.SafetyPlan.ChangeType,
+            input: {
+                id: planId,
+                safetyPlanTypeId: selection.safetyPlanTypeId,
+                safetyPlanType: selection.safetyPlanType,
+            },
+        });
+        if (!payload.handled || !payload.result?.success) {
+            const text = payload.result?.message?.text;
+            this.toastService.show({
+                color: 'danger',
+                title: await this.translateService.translateAsync('@general:messages.generic.error.title'),
+                content: typeof text === 'string' && text.startsWith('@')
+                    ? await this.translateService.translateAsync(text)
+                    : await this.translateService.translateAsync('@workplacesafety-management:safety-plans.messages.section-structure.change-plan-type-failed'),
+            });
+            return;
+        }
+        const data = payload.result.data;
+        const nextTypeId = data?.safetyPlanTypeId ?? selection.safetyPlanTypeId;
+        const nextType = data?.safetyPlanType ?? selection.safetyPlanType ?? { id: nextTypeId };
+        const repeatableSectionTypeIds = await this.loadRepeatableSectionTypeIds();
+        const saved = dedupeSafetyPlanSectionStructure(safetyPlanSectionsToBuilderValue((data?.sections ?? [])), { repeatableSectionTypeIds });
+        this.planTypeOverride.set(nextTypeId);
+        this.updateRootContextField('safetyPlanTypeId', nextTypeId);
+        this.updateRootContextField('safetyPlanType', nextType);
+        this.appliedPlanTypeId.set(nextTypeId);
+        this.lastSyncedKey.set(`${planId}|${nextTypeId}`);
+        this.inflightSyncKey.set(null);
+        this.applyStructure(saved, { asBaseline: true });
+        this.builderRef()?.syncAfterSave(saved);
+        this.recompute();
+        this.toastService.show({
+            color: 'success',
+            title: await this.translateService.translateAsync('@general:messages.generic.success.title'),
+            content: await this.translateService.translateAsync('@workplacesafety-management:safety-plans.actions.change-plan-type.dialog.success'),
+        });
+    }
+    async applyWizardPlanTypeChange(selection) {
+        const repeatableSectionTypeIds = await this.loadRepeatableSectionTypeIds();
+        const defaults = await this.loadDefaultsForPlanType(selection.safetyPlanTypeId, repeatableSectionTypeIds);
+        this.planTypeOverride.set(selection.safetyPlanTypeId);
+        this.updateRootContextField('safetyPlanTypeId', selection.safetyPlanTypeId);
+        this.updateRootContextField('safetyPlanType', selection.safetyPlanType ?? { id: selection.safetyPlanTypeId });
+        this.appliedPlanTypeId.set(selection.safetyPlanTypeId);
+        this.lastSyncedKey.set(`|${selection.safetyPlanTypeId}`);
+        this.inflightSyncKey.set(null);
+        this.applyStructure(defaults, { asBaseline: true });
+        this.builderRef()?.syncAfterSave(defaults);
+        this.recompute();
+        this.toastService.show({
+            color: 'success',
+            title: await this.translateService.translateAsync('@general:messages.generic.success.title'),
+            content: await this.translateService.translateAsync('@workplacesafety-management:safety-plans.actions.change-plan-type.dialog.success'),
+        });
+    }
+    async handleSave(options) {
+        const silent = options?.silent === true;
+        const id = this.safetyPlanId();
+        const value = this.committedValue() ?? { sections: [] };
+        if (!id) {
+            if (!silent) {
+                this.toastService.show({
+                    color: 'danger',
+                    title: await this.translateService.translateAsync('@general:messages.generic.error.title'),
+                    content: await this.translateService.translateAsync('@workplacesafety-management:safety-plans.entities.safety-plan.pages.sections.save-plan-first'),
+                });
+            }
+            return;
+        }
+        const result = await this.commandService.execute(SAFETY_PLAN_SECTIONS_SAVE_COMMAND, { id, value });
+        if (result?.success) {
+            // Always reload from backend after save so UI never keeps a stale/appended local list.
+            const repeatableSectionTypeIds = await this.loadRepeatableSectionTypeIds();
+            const saved = await this.fetchSectionsFromBackend(id, repeatableSectionTypeIds);
+            this.applyStructure(saved, { asBaseline: true });
+            this.lastSyncedKey.set(`${id}|${this.planTypeId() ?? ''}`);
+            this.inflightSyncKey.set(null);
+            this.builderRef()?.syncAfterSave(saved);
+            this.recompute();
+            if (!silent) {
+                this.toastService.show({
+                    color: 'success',
+                    title: await this.translateService.translateAsync('@general:messages.generic.success.title'),
+                    content: await this.translateService.translateAsync('@general:messages.generic.success.description'),
+                });
+            }
+            return;
+        }
+        this.toastService.show({
+            color: 'danger',
+            title: await this.translateService.translateAsync('@general:messages.generic.error.title'),
+            content: typeof result?.message?.text === 'string' && result.message.text.startsWith('@')
+                ? await this.translateService.translateAsync(result.message.text)
+                : await this.translateService.translateAsync('@general:messages.entity.update-failed'),
+        });
+    }
+    recompute() {
+        super.recompute();
+        const layout = this.hostPageLayout;
+        layout?.recompute?.();
+    }
+    handleDiscard() {
+        const baseline = this.baselineValue() ?? { sections: [] };
+        this.committedValue.set(baseline);
+        this.updateRootContextField('sectionStructure', baseline);
+        this.updateRootContextField('sections', baseline);
+        this.builderRef()?.resetAfterDiscard();
+        this.recompute();
+    }
+    applyStructure(value, options) {
+        const normalized = normalizeSafetyPlanSectionBuilderValue(value);
+        if (options.asBaseline) {
+            this.baselineValue.set(normalized);
+        }
+        this.committedValue.set(normalized);
+        // Keep both form fields in sync with the same replaced value (never merge/append).
+        this.updateRootContextField('sectionStructure', normalized);
+        this.updateRootContextField('sections', normalized);
+        // Defer host recompute so it cannot re-enter the sync effect synchronously.
+        queueMicrotask(() => {
+            untracked(() => this.recompute());
+        });
+    }
+    /** Query plan sections from storage and return a deduped builder value (replace, never append). */
+    async fetchSectionsFromBackend(planId, repeatableSectionTypeIds = []) {
+        const result = await this.entityService.withEntity(SAFETY_PLAN_SECTION_ENTITY).data().query({
+            skip: 0,
+            take: 1000,
+            filter: {
+                logic: 'and',
+                filters: [{ field: 'safetyPlanId', operator: { type: 'equal' }, value: planId }],
+            },
+        });
+        const rawLoaded = safetyPlanSectionsToBuilderValue((result.items ?? []));
+        const deduped = dedupeSafetyPlanSectionStructure(rawLoaded, { repeatableSectionTypeIds });
+        const workStepsResult = await this.entityService.withEntity(SAFETY_PLAN_WORK_STEP_ENTITY).data().query({
+            skip: 0,
+            take: 2000,
+            filter: {
+                logic: 'and',
+                filters: [{ field: 'safetyPlanId', operator: { type: 'equal' }, value: planId }],
+            },
+        });
+        const columnsByWorkStepTypeId = await this.loadWorkStepTypeColumns(deduped.sections
+            .map((section) => section.workStepTypeId)
+            .filter((id) => typeof id === 'string' && id.length > 0));
+        return hydrateStepTableSectionsWithWorkSteps(deduped, (workStepsResult.items ?? []), columnsByWorkStepTypeId);
+    }
+    async loadWorkStepTypeColumns(workStepTypeIds) {
+        const uniqueIds = [...new Set(workStepTypeIds)];
+        const columnsById = new Map();
+        if (!uniqueIds.length) {
+            return columnsById;
+        }
+        const entityKey = `${RootConfig.module.name}.${RootConfig.entities.workStepType.name}`;
+        const accessor = this.entityService.withEntity(entityKey);
+        await Promise.all(uniqueIds.map(async (id) => {
+            try {
+                const row = await accessor.data().byKey(id);
+                if (!row) {
+                    return;
+                }
+                const record = row;
+                columnsById.set(id, normalizeStepTableColumns(record.columns));
+            }
+            catch {
+                // Leave missing types without columns; hydrate falls back to row snapshots.
+            }
+        }));
+        return columnsById;
+    }
+    async loadRepeatableSectionTypeIds() {
+        const builtIn = collectBuiltInRepeatableSectionTypeIds();
+        try {
+            const result = await this.entityService.withEntity(SECTION_TYPE_ENTITY).data().query({
+                skip: 0,
+                take: 1000,
+            });
+            const fromQuery = (result.items ?? [])
+                .filter((row) => row.isRepeatable === true)
+                .map((row) => resolveEntityRefId(row.id))
+                .filter((id) => !!id);
+            return [...new Set([...fromQuery, ...builtIn])];
+        }
+        catch {
+            return builtIn;
+        }
+    }
+    async loadDefaultsForPlanType(typeId, repeatableSectionTypeIds = []) {
+        const result = await this.entityService.withEntity(SAFETY_PLAN_TYPE_SECTION_ENTITY).data().query({
+            skip: 0,
+            take: 1000,
+            sort: [{ field: 'sortOrder', dir: 'asc' }],
+            filter: {
+                logic: 'and',
+                filters: [
+                    { field: 'safetyPlanTypeId', operator: { type: 'equal' }, value: typeId },
+                    { field: 'isArchived', operator: { type: 'equal' }, value: false },
+                ],
+            },
+        });
+        const typeSections = (result.items ?? []).filter((row) => resolveEntityRefId(row.safetyPlanTypeId) === typeId);
+        const structure = dedupeSafetyPlanSectionStructure(buildSectionStructureFromTypeSections(typeSections, {
+            createId: () => AXPDataGenerator.uuid(),
+        }), { repeatableSectionTypeIds });
+        return toBuilderValueFromStructure(await this.enrichSectionTitlesFromSectionTypes(structure));
+    }
+    /**
+     * Fills missing section titles from SectionType records when type-section snapshots omit them.
+     */
+    async enrichSectionTitlesFromSectionTypes(structure) {
+        const missingIds = [
+            ...new Set(structure.sections
+                .filter((section) => !section.sectionType?.title || section.title === section.sectionTypeId)
+                .map((section) => section.sectionTypeId)
+                .filter((id) => !!id)),
+        ];
+        if (!missingIds.length) {
+            return structure;
+        }
+        const sectionTypeEntity = `${RootConfig.module.name}.${RootConfig.entities.sectionType.name}`;
+        const result = await this.entityService.withEntity(sectionTypeEntity).data().query({
+            skip: 0,
+            take: Math.max(missingIds.length, 1),
+            filter: {
+                logic: 'or',
+                filters: missingIds.map((id) => ({
+                    field: 'id',
+                    operator: { type: 'equal' },
+                    value: id,
+                })),
+            },
+        });
+        const byId = new Map();
+        for (const row of result.items ?? []) {
+            const record = row;
+            const id = resolveEntityRefId(record['id']);
+            if (!id)
+                continue;
+            const title = record['title'];
+            const code = record['code'];
+            byId.set(id, {
+                title: typeof title === 'string' ? title : undefined,
+                code: typeof code === 'string' ? code : undefined,
+            });
+        }
+        return {
+            sections: structure.sections.map((section) => {
+                const meta = byId.get(section.sectionTypeId);
+                if (!meta?.title && !meta?.code) {
+                    return section;
+                }
+                const title = (meta.title ?? meta.code ?? section.title).trim();
+                return {
+                    ...section,
+                    title,
+                    sectionType: {
+                        id: section.sectionTypeId,
+                        title: meta.title ?? section.sectionType?.title,
+                        code: meta.code ?? section.sectionType?.code,
+                    },
+                };
+            }),
+        };
+    }
+    async confirmReplaceStructure() {
+        const title = (await this.translateService.translateAsync('@workplacesafety-management:safety-plans.messages.section-structure.confirm-change-plan-type.title')) || 'Change Plan Type?';
+        const message = (await this.translateService.translateAsync('@workplacesafety-management:safety-plans.messages.section-structure.confirm-change-plan-type.message')) ||
+            'Changing the Plan Type will discard all existing sections and their selected values. The default sections for the new Plan Type will be loaded. Do you want to continue?';
+        const dialogResult = await this.dialogService.confirm(title, message, 'danger', 'horizontal');
+        return dialogResult.result === true;
+    }
+    async showStructureLoadError() {
+        this.toastService.show({
+            color: 'danger',
+            title: await this.translateService.translateAsync('@general:messages.generic.error.title'),
+            content: await this.translateService.translateAsync('@workplacesafety-management:safety-plans.messages.section-structure.load-failed'),
+        });
+    }
+    updateRootContextField(field, value) {
+        const ctx = this.rootContext();
+        if (!ctx || typeof ctx !== 'object') {
+            return;
+        }
+        ctx[field] = cloneDeep(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMSafetyPlanSectionsPageComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.8", type: AXMSafetyPlanSectionsPageComponent, isStandalone: true, selector: "axm-safety-plan-sections-page", inputs: { rootContext: { classPropertyName: "rootContext", publicName: "rootContext", isSignal: true, isRequired: false, transformFunction: null }, pageConfig: { classPropertyName: "pageConfig", publicName: "pageConfig", isSignal: true, isRequired: false, transformFunction: null }, options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, host: { classAttribute: "block w-full min-h-0" }, providers: [
+            {
+                provide: AXPPageLayoutBase,
+                useExisting: AXMSafetyPlanSectionsPageComponent,
+            },
+        ], viewQueries: [{ propertyName: "builderRef", first: true, predicate: ["builderRef"], descendants: true, isSignal: true }], usesInheritance: true, ngImport: i0, template: `
+    @if (isLoadingStructure()) {
+      <p class="text-muted p-4">
+        {{
+          '@workplacesafety-management:safety-plans.entities.safety-plan.pages.sections.loading'
+            | translate
+            | async
+        }}
+      </p>
+    } @else if (safetyPlanId() || hasPlanType()) {
+      <axm-safety-plan-section-builder
+        #builderRef
+        [value]="committedValue()"
+        [safetyPlanId]="safetyPlanId() ?? undefined"
+        [options]="builderOptions()"
+        (valueChange)="onValueChange($event)"
+      />
+    } @else {
+      <p class="text-muted p-4">
+        {{
+          '@workplacesafety-management:safety-plans.entities.safety-plan.pages.sections.select-plan-type-first'
+            | translate
+            | async
+        }}
+      </p>
+    }
+  `, isInline: true, dependencies: [{ kind: "component", type: AXMSafetyPlanSectionBuilderComponent, selector: "axm-safety-plan-section-builder", inputs: ["value", "safetyPlanId", "options"], outputs: ["valueChange"] }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "pipe", type: i3$1.AXTranslatorPipe, name: "translate" }, { kind: "pipe", type: AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMSafetyPlanSectionsPageComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'axm-safety-plan-sections-page',
+                    standalone: true,
+                    imports: [AXMSafetyPlanSectionBuilderComponent, AXTranslationModule, AsyncPipe],
+                    template: `
+    @if (isLoadingStructure()) {
+      <p class="text-muted p-4">
+        {{
+          '@workplacesafety-management:safety-plans.entities.safety-plan.pages.sections.loading'
+            | translate
+            | async
+        }}
+      </p>
+    } @else if (safetyPlanId() || hasPlanType()) {
+      <axm-safety-plan-section-builder
+        #builderRef
+        [value]="committedValue()"
+        [safetyPlanId]="safetyPlanId() ?? undefined"
+        [options]="builderOptions()"
+        (valueChange)="onValueChange($event)"
+      />
+    } @else {
+      <p class="text-muted p-4">
+        {{
+          '@workplacesafety-management:safety-plans.entities.safety-plan.pages.sections.select-plan-type-first'
+            | translate
+            | async
+        }}
+      </p>
+    }
+  `,
+                    host: {
+                        class: 'block w-full min-h-0',
+                    },
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    providers: [
+                        {
+                            provide: AXPPageLayoutBase,
+                            useExisting: AXMSafetyPlanSectionsPageComponent,
+                        },
+                    ],
+                }]
+        }], propDecorators: { rootContext: [{ type: i0.Input, args: [{ isSignal: true, alias: "rootContext", required: false }] }], pageConfig: [{ type: i0.Input, args: [{ isSignal: true, alias: "pageConfig", required: false }] }], options: [{ type: i0.Input, args: [{ isSignal: true, alias: "options", required: false }] }], builderRef: [{ type: i0.ViewChild, args: ['builderRef', { isSignal: true }] }] } });
+
+var safetyPlanSectionsPage_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMSafetyPlanSectionsPageComponent: AXMSafetyPlanSectionsPageComponent
+});
+
+//#endregion
+//#region ----   Safety plan sections page provider   ----
+class AXMSafetyPlanSectionsPageComponentProvider {
+    async components() {
+        return [
+            {
+                key: SAFETY_PLAN_SECTIONS_PAGE_COMPONENT_KEY,
+                loader: () => Promise.resolve().then(function () { return safetyPlanSectionsPage_component; }).then((m) => m.AXMSafetyPlanSectionsPageComponent),
+            },
+        ];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMSafetyPlanSectionsPageComponentProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMSafetyPlanSectionsPageComponentProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMSafetyPlanSectionsPageComponentProvider, decorators: [{
+            type: Injectable
+        }] });
+
+export { AXMSafetyPlanSectionBuilderComponent, AXMSafetyPlanSectionsPageComponent, AXMSafetyPlanSectionsPageComponentProvider, SAFETY_PLAN_SECTIONS_SAVE_COMMAND };
+//# sourceMappingURL=acorex-platform-module-workplacesafety-management-client-index-kF37zgd4.mjs.map