@acorex-platform/module-workplacesafety-management-client 0.0.38 → 0.0.46

package/fesm2022/acorex-platform-module-workplacesafety-management-client-contracts-entities-safety-plan-activity.mjs

@@ -0,0 +1,1516 @@
+import { createRandomUuid, AXPWidgetsList } from '@acorex-platform/framework-shared/core';
+import { createAllQueryView, entityMasterCrudActions, entityMasterRecordActions } from '@acorex-platform/framework-shared/entity';
+
+const config = {
+    i18n: 'workplacesafety-management',
+    module: 'WorkplaceSafetyManagement',
+};
+const RootConfig = {
+    config,
+    module: {
+        name: config.module,
+        title: `@${config.i18n}:module.title`,
+        icon: 'fa-light fa-building-shield',
+    },
+    entities: {
+        hazard: {
+            name: 'Hazard',
+            source: `${config.module}.Hazard`,
+            title: `@${config.i18n}:hazards.entities.hazard.title`,
+            titlePlural: `@${config.i18n}:hazards.entities.hazard.plural`,
+            icon: 'fa-light fa-triangle-exclamation',
+        },
+        hazardRegister: {
+            name: 'HazardRegister',
+            source: `${config.module}.HazardRegister`,
+            title: `@${config.i18n}:hazard-registers.entities.hazard-register.title`,
+            titlePlural: `@${config.i18n}:hazard-registers.entities.hazard-register.plural`,
+            icon: 'fa-light fa-clipboard-list',
+        },
+        ppeItem: {
+            name: 'PpeItem',
+            source: `${config.module}.PpeItem`,
+            title: `@${config.i18n}:ppe-items.entities.ppe-item.title`,
+            titlePlural: `@${config.i18n}:ppe-items.entities.ppe-item.plural`,
+            icon: 'fa-light fa-helmet-safety',
+        },
+        hazardPpeRule: {
+            name: 'HazardPpeRule',
+            source: `${config.module}.HazardPpeRule`,
+            title: `@${config.i18n}:hazard-ppe-rules.entities.hazard-ppe-rule.title`,
+            titlePlural: `@${config.i18n}:hazard-ppe-rules.entities.hazard-ppe-rule.plural`,
+            icon: 'fa-light fa-user-helmet-safety',
+        },
+        hazardRisk: {
+            name: 'HazardRisk',
+            source: `${config.module}.HazardRisk`,
+            title: `@${config.i18n}:hazard-risks.entities.hazard-risk.title`,
+            titlePlural: `@${config.i18n}:hazard-risks.entities.hazard-risk.plural`,
+            icon: 'fa-light fa-shield-exclamation',
+        },
+        controlHierarchyLevels: {
+            name: 'ControlHierarchyLevels',
+            source: `${config.module}.ControlHierarchyLevels`,
+            title: `@${config.i18n}:control-measure-types.entities.control-measure-type.title`,
+            titlePlural: `@${config.i18n}:control-measure-types.entities.control-measure-type.plural`,
+            icon: 'fa-light fa-layer-group',
+        },
+        controlMeasure: {
+            name: 'ControlMeasure',
+            source: `${config.module}.ControlMeasure`,
+            title: `@${config.i18n}:control-measures.entities.control-measure.title`,
+            titlePlural: `@${config.i18n}:control-measures.entities.control-measure.plural`,
+            icon: 'fa-light fa-shield-check',
+        },
+        safetyPlan: {
+            name: 'SafetyPlan',
+            source: `${config.module}.SafetyPlan`,
+            title: `@${config.i18n}:safety-plans.entities.safety-plan.title`,
+            titlePlural: `@${config.i18n}:safety-plans.entities.safety-plan.plural`,
+            icon: 'fa-light fa-file-shield',
+        },
+        safetyPlanType: {
+            name: 'SafetyPlanType',
+            source: `${config.module}.SafetyPlanType`,
+            title: `@${config.i18n}:safety-plan-types.entities.safety-plan-type.title`,
+            titlePlural: `@${config.i18n}:safety-plan-types.entities.safety-plan-type.plural`,
+            icon: 'fa-light fa-file-lines',
+        },
+        safetyPlanTypeSection: {
+            name: 'SafetyPlanTypeSection',
+            source: `${config.module}.SafetyPlanTypeSection`,
+            title: `@${config.i18n}:safety-plan-type-sections.entities.safety-plan-type-section.title`,
+            titlePlural: `@${config.i18n}:safety-plan-type-sections.entities.safety-plan-type-section.plural`,
+            icon: 'fa-light fa-list-ol',
+        },
+        sectionType: {
+            name: 'SectionType',
+            source: `${config.module}.SectionType`,
+            title: `@${config.i18n}:section-types.entities.section-type.title`,
+            titlePlural: `@${config.i18n}:section-types.entities.section-type.plural`,
+            icon: 'fa-light fa-list-tree',
+        },
+        safetyTemplate: {
+            name: 'SafetyTemplate',
+            source: `${config.module}.SafetyTemplate`,
+            title: `@${config.i18n}:safety-templates.entities.safety-template.title`,
+            titlePlural: `@${config.i18n}:safety-templates.entities.safety-template.plural`,
+            icon: 'fa-light fa-file-lines',
+        },
+        safetyPlanSection: {
+            name: 'SafetyPlanSection',
+            source: `${config.module}.SafetyPlanSection`,
+            title: `@${config.i18n}:safety-plan-sections.entities.safety-plan-section.title`,
+            titlePlural: `@${config.i18n}:safety-plan-sections.entities.safety-plan-section.plural`,
+            icon: 'fa-light fa-list-ol',
+        },
+        workStepType: {
+            name: 'WorkStepType',
+            source: `${config.module}.WorkStepType`,
+            title: `@${config.i18n}:work-step-types.entities.work-step-type.title`,
+            titlePlural: `@${config.i18n}:work-step-types.entities.work-step-type.plural`,
+            icon: 'fa-light fa-list-tree',
+        },
+        safetyPlanActivity: {
+            name: 'SafetyPlanActivity',
+            source: `${config.module}.SafetyPlanActivity`,
+            title: `@${config.i18n}:safety-plan-activities.entities.safety-plan-activity.title`,
+            titlePlural: `@${config.i18n}:safety-plan-activities.entities.safety-plan-activity.plural`,
+            icon: 'fa-light fa-list-check',
+        },
+    },
+    queries: {
+        dashboard: {
+            openHazardsKpi: `${config.module}:Dashboard:OpenHazardsKpi`,
+            highRisksKpi: `${config.module}:Dashboard:HighRisksKpi`,
+            activeSafetyPlansKpi: `${config.module}:Dashboard:ActiveSafetyPlansKpi`,
+            take5ChecklistsKpi: `${config.module}:Dashboard:Take5ChecklistsKpi`,
+            take5CompletedKpi: `${config.module}:Dashboard:Take5CompletedKpi`,
+            hazardsByCategoryDonut: `${config.module}:Dashboard:HazardsByCategoryDonut`,
+            risksByRatingBar: `${config.module}:Dashboard:RisksByRatingBar`,
+            plansByTypeBar: `${config.module}:Dashboard:PlansByTypeBar`,
+            hazardsByStatusBar: `${config.module}:Dashboard:HazardsByStatusBar`,
+            ppeCoverageDonut: `${config.module}:Dashboard:PpeCoverageDonut`,
+        },
+    },
+};
+
+/** Risk matrix entity key in the risk-management module. */
+const RISK_MANAGEMENT_RISK_MATRIX_ENTITY = 'RiskManagement.RiskMatrix';
+/** Hazard catalog scope for risk matrix lookup filtering. */
+const RISK_MANAGEMENT_HAZARD_CATALOG_SCOPE = 'risk-management.hazard';
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Built-in section type IDs   ----
+/** Stable IDs for seeded built-in section types (shared by server mocks and client lookups). */
+const WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS = {
+    hazard: 'c1d2e3f4-a5b6-4789-c001-000000000001',
+    hazardRisk: 'c1d2e3f4-a5b6-4789-c001-000000000002',
+    ppe: 'c1d2e3f4-a5b6-4789-c001-000000000003',
+    control: 'c1d2e3f4-a5b6-4789-c001-000000000004',
+    hierarchyLevel: 'c1d2e3f4-a5b6-4789-c001-000000000005',
+    custom: 'c1d2e3f4-a5b6-4789-c001-000000000006',
+    ppeHazards: 'c1d2e3f4-a5b6-4789-c001-000000000007',
+    riskMatrix: 'c1d2e3f4-a5b6-4789-c001-000000000008',
+    hazardRiskPpe: 'c1d2e3f4-a5b6-4789-c001-000000000009',
+    activity: 'c1d2e3f4-a5b6-4789-c001-00000000000a',
+};
+const moduleName = RootConfig.module.name;
+/** Maps section type codes to the entity that supplies selectable items. */
+const WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_BY_CODE = {
+    Hazard: `${moduleName}.${RootConfig.entities.hazard.name}`,
+    HazardRisk: `${moduleName}.${RootConfig.entities.hazardRisk.name}`,
+    Ppe: `${moduleName}.${RootConfig.entities.ppeItem.name}`,
+    PpeHazards: `${moduleName}.${RootConfig.entities.hazardPpeRule.name}`,
+    HazardRiskPpe: undefined,
+    Control: `${moduleName}.${RootConfig.entities.controlMeasure.name}`,
+    HierarchyLevel: `${moduleName}.${RootConfig.entities.controlHierarchyLevels.name}`,
+    RiskMatrix: RISK_MANAGEMENT_RISK_MATRIX_ENTITY,
+    Custom: undefined,
+    /** Host section for Activity rows (managed by the section builder, not a catalog picker). */
+    Activity: undefined,
+};
+/** Built-in section types resolved by stable section type id. */
+const WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_BY_ID = {
+    [WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.hazard]: {
+        sectionTypeKey: 'Hazard',
+        itemEntityName: WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_BY_CODE.Hazard,
+    },
+    [WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.hazardRisk]: {
+        sectionTypeKey: 'HazardRisk',
+        itemEntityName: WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_BY_CODE.HazardRisk,
+    },
+    [WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.ppe]: {
+        sectionTypeKey: 'Ppe',
+        itemEntityName: WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_BY_CODE.Ppe,
+    },
+    [WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.ppeHazards]: {
+        sectionTypeKey: 'PpeHazards',
+        itemEntityName: WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_BY_CODE.PpeHazards,
+    },
+    [WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.hazardRiskPpe]: {
+        sectionTypeKey: 'HazardRiskPpe',
+        itemEntityName: WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_BY_CODE.HazardRiskPpe,
+    },
+    [WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.control]: {
+        sectionTypeKey: 'Control',
+        itemEntityName: WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_BY_CODE.Control,
+    },
+    [WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.hierarchyLevel]: {
+        sectionTypeKey: 'HierarchyLevel',
+        itemEntityName: WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_BY_CODE.HierarchyLevel,
+    },
+    [WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.riskMatrix]: {
+        sectionTypeKey: 'RiskMatrix',
+        itemEntityName: WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_BY_CODE.RiskMatrix,
+    },
+    [WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.custom]: {
+        sectionTypeKey: 'Custom',
+        itemEntityName: WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_BY_CODE.Custom,
+        isRepeatable: true,
+    },
+    [WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.activity]: {
+        sectionTypeKey: 'Activity',
+        itemEntityName: WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_BY_CODE.Activity,
+        isRepeatable: true,
+    },
+};
+/** Default entity so the lookup widget mounts before a section type is chosen. */
+const WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_FALLBACK = `${moduleName}.${RootConfig.entities.hazard.name}`;
+//#endregion
+//#region ----   Snapshot helpers   ----
+function resolveSectionTypeKey(sectionTypeId, snapshot) {
+    const fromSnapshot = snapshot?.sectionTypeKey;
+    if (typeof fromSnapshot === 'string' && fromSnapshot.length > 0) {
+        return fromSnapshot;
+    }
+    if (!sectionTypeId) {
+        return undefined;
+    }
+    return WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_BY_ID[sectionTypeId]
+        ?.sectionTypeKey;
+}
+/**
+ * Human-readable titles for built-in section type keys (matches seeded SectionType titles).
+ * Used when snapshots lack `title` (common after id-only enrichment).
+ */
+const SECTION_TYPE_KEY_DISPLAY_TITLES = {
+    Hazard: 'Hazard',
+    HazardRisk: 'Hazard Risk',
+    Ppe: 'PPE',
+    PpeHazards: 'Hazard PPE Items',
+    HazardRiskPpe: 'Hazard Risk PPE',
+    Control: 'Control',
+    HierarchyLevel: 'Hierarchy Level',
+    RiskMatrix: 'Risk Matrix',
+    Custom: 'Custom',
+    Activity: 'Activity',
+};
+/** Formats a section type key for display (e.g. `HierarchyLevel` → `Hierarchy Level`). */
+function formatSectionTypeKeyAsTitle(key) {
+    if (!key) {
+        return '';
+    }
+    const known = SECTION_TYPE_KEY_DISPLAY_TITLES[key];
+    if (known) {
+        return known;
+    }
+    return key.replace(/([a-z\d])([A-Z])/g, '$1 $2').trim();
+}
+/**
+ * Resolves a section type label for UI/preview: snapshot title → key display title → spaced code.
+ */
+function resolveSectionTypeDisplayTitle(sectionTypeId, snapshot) {
+    if (typeof snapshot?.title === 'string' && snapshot.title.trim()) {
+        return snapshot.title.trim();
+    }
+    const key = resolveSectionTypeKey(sectionTypeId, snapshot ?? undefined);
+    const fromKey = formatSectionTypeKeyAsTitle(key);
+    if (fromKey) {
+        return fromKey;
+    }
+    if (typeof snapshot?.code === 'string' && snapshot.code.trim()) {
+        return formatSectionTypeKeyAsTitle(snapshot.code.trim()) || snapshot.code.trim();
+    }
+    return '';
+}
+function resolveSectionItemEntityName(sectionTypeId, snapshot) {
+    const fromSnapshot = snapshot?.itemEntityName;
+    if (typeof fromSnapshot === 'string' && fromSnapshot.length > 0) {
+        return fromSnapshot;
+    }
+    if (!sectionTypeId) {
+        return undefined;
+    }
+    return WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_BY_ID[sectionTypeId]
+        ?.itemEntityName;
+}
+/** Adds runtime lookup metadata (`sectionTypeKey`, `itemEntityName`) from built-in id map. */
+function enrichSectionTypeSnapshot(sectionTypeId, snapshot) {
+    if (!sectionTypeId) {
+        return snapshot;
+    }
+    return {
+        ...snapshot,
+        id: sectionTypeId,
+        sectionTypeKey: resolveSectionTypeKey(sectionTypeId, snapshot),
+        itemEntityName: resolveSectionItemEntityName(sectionTypeId, snapshot),
+        isRepeatable: snapshot?.isRepeatable ??
+            WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_BY_ID[sectionTypeId]?.isRepeatable,
+    };
+}
+//#endregion
+//#region ----   Dynamic entity expressions   ----
+function buildSectionTypeEntityExpressionById(sectionTypeIdPath) {
+    const parts = Object.entries(WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_BY_ID)
+        .filter(([, meta]) => meta.itemEntityName)
+        .map(([id, meta]) => `context.eval('${sectionTypeIdPath}') === '${id}' ? '${meta.itemEntityName}'`);
+    return `{{ ${parts.join(' : ')} : '${WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_FALLBACK}' }}`;
+}
+function buildSectionTypeEntityExpressionWithSnapshotFallback(sectionTypeIdPath, itemEntityNamePath) {
+    const byId = buildSectionTypeEntityExpressionById(sectionTypeIdPath).slice(3, -2);
+    return `{{ context.eval('${itemEntityNamePath}') || (${byId}) }}`;
+}
+/**
+ * For repeater / nested FormField widgets — `>` walks up to the row where `sectionType` is exposed.
+ */
+const WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_EXPRESSION = buildSectionTypeEntityExpressionWithSnapshotFallback('>sectionType.id', '>sectionType.itemEntityName');
+/**
+ * Entity expression keyed by the bound `sectionTypeId` field (repeater-safe).
+ * Prefer this when expose snapshots may not live on the same path the lookup evaluates.
+ */
+function buildWorkplaceSafetySectionTypeEntityExpression(sectionTypeIdPath) {
+    return buildSectionTypeEntityExpressionById(sectionTypeIdPath);
+}
+/**
+ * For flat dialog / dynamic forms — sibling fields share the same context (no parent path).
+ */
+const WORKPLACE_SAFETY_SECTION_TYPE_ENTITY_EXPRESSION_SIBLING = buildSectionTypeEntityExpressionWithSnapshotFallback('sectionType.id', 'sectionType.itemEntityName');
+//#endregion
+
+/**
+ * Shared helpers for Safety Plan Section type identity (repeatable vs one-off).
+ * Leaf module — imports only other contract leaves (no client/server layers).
+ */
+//#region ---- Helpers ----
+function resolveRefId(raw) {
+    if (typeof raw === 'string' && raw.trim().length > 0) {
+        return raw.trim();
+    }
+    if (typeof raw === 'number' && Number.isFinite(raw)) {
+        return String(raw);
+    }
+    if (raw && typeof raw === 'object') {
+        const id = raw.id;
+        if (typeof id === 'string' && id.trim().length > 0) {
+            return id.trim();
+        }
+    }
+    return '';
+}
+/**
+ * True when this section type may appear more than once in a Safety Plan.
+ * Checks (in order): snapshot flag, explicit allow-list, built-in section type meta.
+ */
+function isSafetyPlanSectionTypeRepeatable(sectionTypeId, options) {
+    const id = resolveRefId(sectionTypeId);
+    if (!id) {
+        return false;
+    }
+    if (options?.sectionType?.isRepeatable === true) {
+        return true;
+    }
+    const allowList = new Set((options?.repeatableSectionTypeIds ?? []).map((entry) => resolveRefId(entry)).filter(Boolean));
+    if (allowList.has(id)) {
+        return true;
+    }
+    return WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_BY_ID[id]?.isRepeatable === true;
+}
+/** Built-in section type ids that are always treated as repeatable. */
+function collectBuiltInRepeatableSectionTypeIds() {
+    return Object.entries(WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_BY_ID)
+        .filter(([, meta]) => meta.isRepeatable === true)
+        .map(([id]) => id);
+}
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Display helpers   ----
+/** Coerces a stored string or locale map into a single display string. */
+function asSafetyPlanDisplayText(value) {
+    if (typeof value === 'string') {
+        return value.trim();
+    }
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        const rec = value;
+        for (const locale of ['en-US', 'en-AU', 'en', 'fa-IR']) {
+            const part = rec[locale];
+            if (typeof part === 'string' && part.trim()) {
+                return part.trim();
+            }
+        }
+        for (const part of Object.values(rec)) {
+            if (typeof part === 'string' && part.trim()) {
+                return part.trim();
+            }
+        }
+    }
+    return '';
+}
+function buildSectionTypeRelationSnapshot(sectionTypeId, snapshot) {
+    const title = asSafetyPlanDisplayText(snapshot?.title);
+    const code = asSafetyPlanDisplayText(snapshot?.code);
+    const description = asSafetyPlanDisplayText(snapshot?.description);
+    return {
+        id: sectionTypeId,
+        ...(title ? { title } : {}),
+        ...(code ? { code } : {}),
+        ...(description ? { description } : {}),
+        ...(snapshot?.isRepeatable === true ? { isRepeatable: true } : {}),
+    };
+}
+function resolveSectionTypeTitle(sectionTypeId, sectionType) {
+    const title = asSafetyPlanDisplayText(sectionType?.title);
+    if (title) {
+        return title;
+    }
+    const code = asSafetyPlanDisplayText(sectionType?.code);
+    if (code) {
+        return code;
+    }
+    const builtIn = WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_BY_ID[sectionTypeId]?.sectionTypeKey;
+    if (builtIn) {
+        return builtIn;
+    }
+    return sectionTypeId;
+}
+/**
+ * Title persisted on SafetyPlanSection. Never stores a bare UUID — the UI translate
+ * pipe treats unknown keys as empty, which made seeded section headers blank.
+ */
+function resolveSafetyPlanSectionPersistedTitle(sectionTitle, sectionTypeId, snapshot) {
+    const explicit = asSafetyPlanDisplayText(sectionTitle);
+    if (explicit && explicit !== sectionTypeId) {
+        return explicit;
+    }
+    const fromType = resolveSectionTypeTitle(sectionTypeId, snapshot);
+    if (fromType && fromType !== sectionTypeId) {
+        return fromType;
+    }
+    return 'Section';
+}
+//#endregion
+//#region ----   Ref helpers   ----
+/** True when a type-section row is marked as the plan-type default template. */
+function isSafetyPlanTypeSectionDefault(row) {
+    const value = row?.isDefault;
+    return value === true || value === 1 || value === 'true';
+}
+/**
+ * Returns the default Safety Plan Type Section (structure) for a plan type.
+ * Prefers `isDefault: true`; otherwise the first active row by sortOrder/title.
+ */
+function resolveDefaultSafetyPlanTypeSection(typeSections) {
+    const active = typeSections
+        .filter((row) => row && row.isArchived !== true)
+        .slice()
+        .sort((a, b) => (a.sortOrder ?? 0) - (b.sortOrder ?? 0) || String(a.title ?? '').localeCompare(String(b.title ?? '')));
+    if (!active.length) {
+        return null;
+    }
+    return active.find((row) => isSafetyPlanTypeSectionDefault(row)) ?? active[0] ?? null;
+}
+/**
+ * Narrows type-section rows to the selected structure when `structureId` is set.
+ * Falls back to all active rows (caller / build still applies isDefault rules).
+ */
+function pickSafetyPlanTypeSectionsForStructure(typeSections, structureId) {
+    const active = typeSections.filter((row) => row && row.isArchived !== true);
+    const id = typeof structureId === 'string' ? structureId.trim() : '';
+    if (!id) {
+        return active;
+    }
+    const selected = active.filter((row) => resolveEntityRefId(row.id) === id);
+    return selected.length ? selected : active;
+}
+/** Extracts a stable entity id from a raw lookup / context value. */
+function resolveEntityRefId(raw) {
+    if (typeof raw === 'string' && raw.trim().length > 0) {
+        return raw.trim();
+    }
+    if (typeof raw === 'number' && Number.isFinite(raw)) {
+        return String(raw);
+    }
+    if (raw && typeof raw === 'object') {
+        const id = raw.id;
+        if (typeof id === 'string' && id.trim().length > 0) {
+            return id.trim();
+        }
+    }
+    return null;
+}
+function resolveSectionTypeId(typeRow) {
+    if (!typeRow) {
+        return '';
+    }
+    return (resolveEntityRefId(typeRow.sectionTypeId) ??
+        resolveEntityRefId(typeRow.sectionType) ??
+        resolveEntityRefId(typeRow.sectionType?.id) ??
+        '');
+}
+//#endregion
+//#region ----   Build from type sections   ----
+let structureIdSeq = 0;
+function nextStructureId(prefix) {
+    structureIdSeq += 1;
+    const rand = createRandomUuid();
+    return prefix ? `${prefix}-${rand}` : rand;
+}
+/**
+ * Builds an empty editable section structure from SafetyPlanTypeSection rows for one plan type.
+ *
+ * Uses `isDefault` rows when present; otherwise falls back to all active rows for that type
+ * (so a mis-flagged template still produces a structure). One plan section per `sectionTypeIds`
+ * entry, titled from the Section Type, ordered by type-section `sortOrder` then repeater order.
+ */
+function buildSectionStructureFromTypeSections(typeSections, options) {
+    const createId = options?.createId ?? (() => nextStructureId(''));
+    const active = typeSections
+        .filter((row) => row && row.isArchived !== true)
+        .slice()
+        .sort((a, b) => (a.sortOrder ?? 0) - (b.sortOrder ?? 0) || String(a.title ?? '').localeCompare(String(b.title ?? '')));
+    const defaults = active.filter((row) => isSafetyPlanTypeSectionDefault(row));
+    const sourceRows = defaults.length > 0 ? defaults : active;
+    const sections = [];
+    const seenSourceTypePairs = new Set();
+    let sortOrder = 1;
+    for (const typeSection of sourceRows) {
+        const typeRows = Array.isArray(typeSection.sectionTypeIds) ? typeSection.sectionTypeIds : [];
+        if (!typeRows.length) {
+            continue;
+        }
+        for (const typeRow of typeRows) {
+            const sectionTypeId = resolveSectionTypeId(typeRow);
+            if (!sectionTypeId) {
+                continue;
+            }
+            // One plan section per (type-section source, section type) — prevents
+            // accidental double expansion when the same type is listed twice.
+            const sourceId = typeof typeSection.id === 'string' ? typeSection.id : '';
+            const pairKey = sourceId ? `${sourceId}|${sectionTypeId}` : sectionTypeId;
+            if (seenSourceTypePairs.has(pairKey)) {
+                continue;
+            }
+            seenSourceTypePairs.add(pairKey);
+            const sectionType = buildSectionTypeRelationSnapshot(sectionTypeId, typeRow.sectionType);
+            const sectionId = createId();
+            sections.push({
+                id: sectionId,
+                sectionTypeId,
+                sectionType,
+                title: resolveSafetyPlanSectionPersistedTitle(undefined, sectionTypeId, sectionType),
+                description: asSafetyPlanDisplayText(sectionType.description),
+                sourceSafetyPlanTypeSectionId: typeSection.id,
+                sortOrder: sortOrder++,
+                required: isSafetyPlanTypeSectionDefault(typeSection) || defaults.length === 0,
+                items: [
+                    {
+                        id: `${sectionId}__item_1`,
+                        itemIds: [],
+                        items: [],
+                    },
+                ],
+            });
+        }
+    }
+    return { sections };
+}
+/**
+ * Removes accidental ghost rows from double materialization of the same type-section
+ * source. Distinct sections of the same type are kept. Reassigns contiguous 1-based
+ * `sortOrder` to preserve display order.
+ */
+function dedupeSafetyPlanSectionStructure(structure, _options) {
+    const sections = Array.isArray(structure?.sections)
+        ? structure.sections
+        : [];
+    const seenSourceTypePairs = new Set();
+    const deduped = [];
+    for (const section of sections) {
+        const sectionTypeId = resolveEntityRefId(section.sectionTypeId) ?? String(section.sectionTypeId ?? '').trim();
+        if (!sectionTypeId) {
+            continue;
+        }
+        const sourceId = String(section.sourceSafetyPlanTypeSectionId ?? '').trim();
+        const sourcePairKey = sourceId ? `${sourceId}|${sectionTypeId}` : '';
+        // Same type-section source + section type must never appear twice (double materialization).
+        if (sourcePairKey && seenSourceTypePairs.has(sourcePairKey)) {
+            continue;
+        }
+        if (sourcePairKey) {
+            seenSourceTypePairs.add(sourcePairKey);
+        }
+        deduped.push(section);
+    }
+    return {
+        ...structure,
+        sections: deduped.map((section, index) => ({
+            ...section,
+            sortOrder: index + 1,
+        })),
+    };
+}
+function collectAllowedSectionTypeIds(typeSections) {
+    const ids = new Set();
+    for (const typeSection of typeSections) {
+        if (typeSection.isArchived === true) {
+            continue;
+        }
+        for (const row of typeSection.sectionTypeIds ?? []) {
+            const id = resolveSectionTypeId(row);
+            if (id) {
+                ids.add(id);
+            }
+        }
+    }
+    return [...ids];
+}
+function collectRequiredSourceTypeSectionIds(typeSections, options) {
+    const structureId = typeof options?.structureId === 'string' && options.structureId.trim()
+        ? options.structureId.trim()
+        : '';
+    if (structureId) {
+        const selected = typeSections.find((row) => row.isArchived !== true && resolveEntityRefId(row.id) === structureId);
+        return selected?.id && typeof selected.id === 'string' ? [selected.id] : [structureId];
+    }
+    return typeSections
+        .filter((row) => row.isArchived !== true && isSafetyPlanTypeSectionDefault(row))
+        .map((row) => row.id)
+        .filter((id) => typeof id === 'string' && id.length > 0);
+}
+/**
+ * Validates that a plan-type section template does not list the same
+ * non-repeatable section type more than once (across rows and within a single row's repeater).
+ */
+function validateSafetyPlanTypeSectionTemplate(typeSections, repeatableSectionTypeIds = []) {
+    const seen = new Map();
+    const issues = [];
+    for (const typeSection of typeSections) {
+        if (typeSection.isArchived === true) {
+            continue;
+        }
+        for (const row of typeSection.sectionTypeIds ?? []) {
+            const sectionTypeId = resolveSectionTypeId(row);
+            if (!sectionTypeId ||
+                isSafetyPlanSectionTypeRepeatable(sectionTypeId, {
+                    repeatableSectionTypeIds,
+                    sectionType: row.sectionType,
+                })) {
+                continue;
+            }
+            const sectionTypeTitle = resolveSafetyPlanSectionPersistedTitle(undefined, sectionTypeId, row.sectionType);
+            if (seen.has(sectionTypeId)) {
+                issues.push({
+                    code: 'INVALID_TYPE_SECTION_TEMPLATE',
+                    messageKey: '@workplacesafety-management:safety-plans.messages.section-structure.invalid-type-template-duplicate',
+                    details: {
+                        sectionTypeId,
+                        sectionTypeTitle,
+                        sourceSafetyPlanTypeSectionId: typeSection.id,
+                        previousSourceSafetyPlanTypeSectionId: seen.get(sectionTypeId)?.sourceSafetyPlanTypeSectionId,
+                    },
+                });
+                continue;
+            }
+            seen.set(sectionTypeId, {
+                title: sectionTypeTitle,
+                sourceSafetyPlanTypeSectionId: typeSection.id,
+            });
+        }
+    }
+    return issues;
+}
+//#endregion
+//#region ----   Validation   ----
+function validateSafetyPlanSectionStructure(structure, context) {
+    const sections = Array.isArray(structure?.sections) ? structure.sections : [];
+    const issues = [];
+    const presentSourceIds = new Set(sections
+        .map((s) => s.sourceSafetyPlanTypeSectionId)
+        .filter((id) => typeof id === 'string' && id.length > 0));
+    for (const requiredSourceId of context.requiredSourceTypeSectionIds) {
+        if (!presentSourceIds.has(requiredSourceId)) {
+            issues.push({
+                code: 'REQUIRED_SECTION_MISSING',
+                messageKey: '@workplacesafety-management:safety-plans.messages.section-structure.required-section-missing',
+                details: { sourceSafetyPlanTypeSectionId: requiredSourceId },
+            });
+        }
+    }
+    const allowed = new Set(context.allowedSectionTypeIds);
+    const sortOrders = [];
+    for (const section of sections) {
+        const sectionTypeId = resolveEntityRefId(section.sectionTypeId) ??
+            String(section.sectionTypeId ?? '').trim();
+        if (!sectionTypeId) {
+            continue;
+        }
+        const sectionType = section
+            .sectionType;
+        const sectionTypeTitle = resolveSafetyPlanSectionPersistedTitle(undefined, sectionTypeId, sectionType);
+        if (allowed.size > 0 && !allowed.has(sectionTypeId)) {
+            issues.push({
+                code: 'SECTION_TYPE_NOT_ALLOWED',
+                messageKey: '@workplacesafety-management:safety-plans.messages.section-structure.section-type-not-allowed',
+                details: { sectionTypeId, sectionTypeTitle, sectionId: section.id },
+            });
+        }
+        const sortOrder = section.sortOrder;
+        if (typeof sortOrder === 'number' && Number.isFinite(sortOrder)) {
+            sortOrders.push(sortOrder);
+        }
+    }
+    if (sortOrders.length !== sections.length) {
+        issues.push({
+            code: 'INVALID_SORT_ORDER',
+            messageKey: '@workplacesafety-management:safety-plans.messages.section-structure.invalid-sort-order',
+        });
+    }
+    else {
+        const unique = new Set(sortOrders);
+        if (unique.size !== sortOrders.length) {
+            issues.push({
+                code: 'INVALID_SORT_ORDER',
+                messageKey: '@workplacesafety-management:safety-plans.messages.section-structure.invalid-sort-order',
+                details: { reason: 'duplicate' },
+            });
+        }
+    }
+    return issues;
+}
+function toBuilderValueFromStructure(structure) {
+    return {
+        sections: structure.sections.map((section) => ({
+            id: section.id,
+            sectionTypeId: section.sectionTypeId,
+            sectionType: section.sectionType,
+            title: section.title,
+            description: section.description ?? '',
+            safetyPlanId: section.safetyPlanId,
+            code: section.code,
+            sourceSafetyPlanTypeSectionId: section.sourceSafetyPlanTypeSectionId,
+            sortOrder: section.sortOrder,
+            required: section.required,
+            items: section.items.map((item) => ({
+                id: item.id,
+                itemIds: [...(item.itemIds ?? [])],
+                items: item.items ? [...item.items] : [],
+            })),
+        })),
+    };
+}
+//#endregion
+
+//#region ----   Imports   ----
+/** Declarative section-type dependencies resolved from prior sections in plan order. */
+const WORKPLACE_SAFETY_SECTION_TYPE_DEPENDENCIES = {
+    HazardRisk: {
+        kind: 'parentFilter',
+        parentSectionTypeKey: 'Hazard',
+        filterField: 'hazardId',
+    },
+    PpeHazards: {
+        kind: 'parentFilter',
+        parentSectionTypeKey: 'Hazard',
+        filterField: 'hazardId',
+    },
+    HazardRiskPpe: {
+        kind: 'parentFilter',
+        parentSectionTypeKey: 'HazardRisk',
+        filterField: 'hazardRiskId',
+    },
+    RiskMatrix: {
+        kind: 'derivedFromParent',
+        parentSectionTypeKey: 'HazardRisk',
+        resolveField: 'riskMatrixId',
+        filterField: 'id',
+    },
+};
+/** Section types cleared when upstream hazard selections change. */
+const WORKPLACE_SAFETY_DOWNSTREAM_FROM_HAZARD = [
+    'HazardRisk',
+    'PpeHazards',
+    'HazardRiskPpe',
+    'RiskMatrix',
+];
+/** Section types cleared when upstream hazard-risk selections change. */
+const WORKPLACE_SAFETY_DOWNSTREAM_FROM_HAZARD_RISK = [
+    'HazardRiskPpe',
+    'RiskMatrix',
+];
+//#endregion
+//#region ----   Lookup helpers   ----
+const PARENT_HAZARD_IDS_CONTEXT_KEY = 'parentHazardIds';
+const PARENT_HAZARD_RISK_IDS_CONTEXT_KEY = 'parentHazardRiskIds';
+/** Expose paths when a section type is selected (shared by entity repeater and builder dialog). */
+const WORKPLACE_SAFETY_SECTION_TYPE_LOOKUP_EXPOSE = [
+    { source: 'id', target: 'sectionType.id' },
+    { source: 'title', target: 'sectionType.title' },
+    { source: 'code', target: 'sectionType.code' },
+    { source: 'description', target: 'sectionType.description' },
+    { source: 'isRepeatable', target: 'sectionType.isRepeatable' },
+];
+/** Auto-fill section description when section type is selected. */
+const WORKPLACE_SAFETY_SECTION_TYPE_DESCRIPTION_SYNC_TRIGGERS = [
+    {
+        event: "{{ events.context('sectionTypeId') }}",
+        action: "{{ const items = widget.output('selectedItems'); const selectedDescription = Array.isArray(items) ? items[0]?.description : undefined; const d = selectedDescription || context.eval('sectionType.description') || ''; context.set('sectionTypeDescription', d); const descriptionWidget = widget.find('sectionTypeDescription'); if (descriptionWidget) { descriptionWidget.setValue(d); } }}",
+    },
+    {
+        event: "{{ events.context('sectionType.description') }}",
+        action: "{{ const d = context.eval('sectionType.description') || ''; context.set('sectionTypeDescription', d); const descriptionWidget = widget.find('sectionTypeDescription'); if (descriptionWidget) { descriptionWidget.setValue(d); } }}",
+    },
+];
+/** Auto-fill section title when section type is selected. */
+const WORKPLACE_SAFETY_SECTION_TYPE_TITLE_SYNC_TRIGGERS = [
+    {
+        event: "{{ events.context('sectionTypeId') }}",
+        action: "{{ const items = widget.output('selectedItems'); const selectedTitle = Array.isArray(items) ? items[0]?.title : undefined; const t = selectedTitle || context.eval('sectionType.title') || ''; if (t) { context.set('title', t); const titleWidget = widget.find('title'); if (titleWidget) { titleWidget.setValue(t); } } }}",
+    },
+    {
+        event: "{{ events.context('sectionType.title') }}",
+        action: "{{ const t = context.eval('sectionType.title') || ''; if (t) { context.set('title', t); const titleWidget = widget.find('title'); if (titleWidget) { titleWidget.setValue(t); } } }}",
+    },
+];
+/** Shared lookup widget options for section type pickers (builder dialog and entity forms). */
+const WORKPLACE_SAFETY_SECTION_TYPE_LOOKUP_WIDGET_OPTIONS = {
+    look: 'select',
+    allowSearch: true,
+    textField: 'code',
+    textTemplate: '{code} — {description}',
+    valueField: 'id',
+    columns: ['code', 'title', 'description'],
+    expose: WORKPLACE_SAFETY_SECTION_TYPE_LOOKUP_EXPOSE,
+    triggers: [
+        ...WORKPLACE_SAFETY_SECTION_TYPE_TITLE_SYNC_TRIGGERS,
+        ...WORKPLACE_SAFETY_SECTION_TYPE_DESCRIPTION_SYNC_TRIGGERS,
+    ],
+};
+//#endregion
+//#region ----   Resolver API   ----
+function getSectionTypeDependency(sectionTypeKey) {
+    if (!sectionTypeKey) {
+        return undefined;
+    }
+    return WORKPLACE_SAFETY_SECTION_TYPE_DEPENDENCIES[sectionTypeKey];
+}
+function sectionTypeKeyFromSection(section) {
+    const sectionTypeId = section.sectionTypeId || section.sectionType?.id;
+    const key = resolveSectionTypeKey(sectionTypeId, section.sectionType);
+    return key;
+}
+function collectSectionItemIds(section, sectionTypeKey) {
+    if (!section?.items?.length || sectionTypeKeyFromSection(section) !== sectionTypeKey) {
+        return [];
+    }
+    const ids = new Set();
+    for (const item of section.items) {
+        for (const id of item.itemIds ?? []) {
+            if (typeof id === 'string' && id.length > 0) {
+                ids.add(id);
+            }
+        }
+    }
+    return [...ids];
+}
+/** Collects item IDs from sections up to `sectionIndex` whose type matches `parentSectionTypeKey`. */
+function resolveParentItemIds(sections, sectionIndex, parentSectionTypeKey) {
+    const ids = new Set();
+    const lastIndex = Math.min(sectionIndex, sections.length - 1);
+    for (let index = 0; index <= lastIndex; index += 1) {
+        collectSectionItemIds(sections[index], parentSectionTypeKey).forEach((id) => ids.add(id));
+    }
+    return [...ids];
+}
+/** Collects hazard IDs from earlier sections and Hazard rows in the current section. */
+function resolveParentHazardIds(sections, sectionIndex, parentSectionTypeKey = 'Hazard') {
+    return resolveParentItemIds(sections, sectionIndex, parentSectionTypeKey);
+}
+/** Collects hazard-risk IDs from prior HazardRisk sections up to `sectionIndex`. */
+function resolveParentHazardRiskIds(sections, sectionIndex) {
+    return resolveParentItemIds(sections, sectionIndex, 'HazardRisk');
+}
+function parentItemSignature(sections, sectionIndex, parentSectionTypeKey) {
+    return resolveParentItemIds(sections, sectionIndex, parentSectionTypeKey).sort().join('|');
+}
+function shouldClearSectionOnParentChange(section, sectionIndex, changeIndex, parentTypeKey, downstreamTypes) {
+    if (sectionIndex < changeIndex) {
+        return false;
+    }
+    const sectionKey = sectionTypeKeyFromSection(section);
+    if (!sectionKey || !downstreamTypes.includes(sectionKey)) {
+        return false;
+    }
+    if (sectionIndex === changeIndex && sectionKey === parentTypeKey) {
+        return false;
+    }
+    return section.items.some((item) => (item.itemIds?.length ?? 0) > 0);
+}
+function clearSectionItems(section) {
+    return {
+        ...section,
+        items: section.items.map((item) => ({ ...item, itemIds: [], items: [] })),
+    };
+}
+/**
+ * When upstream hazard or hazard-risk selections change, clears item rows in later dependent sections.
+ */
+function clearDependentItemsOnParentChange(previous, next) {
+    if (!next.sections.length) {
+        return next;
+    }
+    let changeIndex = next.sections.length;
+    let hazardChanged = false;
+    let hazardRiskChanged = false;
+    for (let index = 0; index < next.sections.length; index += 1) {
+        const prevHazardSig = parentItemSignature(previous.sections, index, 'Hazard');
+        const nextHazardSig = parentItemSignature(next.sections, index, 'Hazard');
+        if (prevHazardSig !== nextHazardSig) {
+            changeIndex = Math.min(changeIndex, index);
+            hazardChanged = true;
+        }
+        const prevRiskSig = parentItemSignature(previous.sections, index, 'HazardRisk');
+        const nextRiskSig = parentItemSignature(next.sections, index, 'HazardRisk');
+        if (prevRiskSig !== nextRiskSig) {
+            changeIndex = Math.min(changeIndex, index);
+            hazardRiskChanged = true;
+        }
+    }
+    if (changeIndex === next.sections.length) {
+        return next;
+    }
+    return {
+        sections: next.sections.map((section, sectionIndex) => {
+            const clearFromHazard = hazardChanged &&
+                shouldClearSectionOnParentChange(section, sectionIndex, changeIndex, 'Hazard', WORKPLACE_SAFETY_DOWNSTREAM_FROM_HAZARD);
+            const clearFromHazardRisk = hazardRiskChanged &&
+                shouldClearSectionOnParentChange(section, sectionIndex, changeIndex, 'HazardRisk', WORKPLACE_SAFETY_DOWNSTREAM_FROM_HAZARD_RISK);
+            if (!clearFromHazard && !clearFromHazardRisk) {
+                return section;
+            }
+            return clearSectionItems(section);
+        }),
+    };
+}
+function extractRiskMatrixIdsFromHazardRisks(records) {
+    const ids = new Set();
+    for (const record of records) {
+        const id = record['riskMatrixId'];
+        if (typeof id === 'string' && id.length > 0) {
+            ids.add(id);
+        }
+    }
+    return [...ids];
+}
+function buildInFilter(field, values) {
+    const unique = [...new Set(values.filter((id) => id.length > 0))];
+    if (!unique.length) {
+        return null;
+    }
+    return {
+        field,
+        operator: { type: 'in' },
+        value: unique,
+    };
+}
+/** Filter that matches no records when parent context exists but derived IDs are empty. */
+function buildEmptyResultFilter(field) {
+    return {
+        field,
+        operator: { type: 'in' },
+        value: ['00000000-0000-0000-0000-000000000000'],
+    };
+}
+function resolveSafetyPlanSectionItemFilter(sectionTypeId, parentHazardIds, parentHazardRiskIds = []) {
+    const sectionTypeKey = resolveSectionTypeKey(sectionTypeId);
+    const dependency = getSectionTypeDependency(sectionTypeKey);
+    if (!dependency || dependency.kind !== 'parentFilter') {
+        return null;
+    }
+    const parentIds = dependency.parentSectionTypeKey === 'Hazard' ? parentHazardIds : parentHazardRiskIds;
+    if (!parentIds.length) {
+        return null;
+    }
+    return buildInFilter(dependency.filterField, parentIds);
+}
+async function resolveSafetyPlanSectionItemFilterAsync(sectionTypeId, sections, sectionIndex, loadHazardRisks) {
+    const sectionTypeKey = resolveSectionTypeKey(sectionTypeId);
+    const dependency = getSectionTypeDependency(sectionTypeKey);
+    if (!dependency) {
+        return null;
+    }
+    if (dependency.kind === 'parentFilter') {
+        const parentIds = resolveParentItemIds(sections, sectionIndex, dependency.parentSectionTypeKey);
+        if (!parentIds.length) {
+            return null;
+        }
+        return buildInFilter(dependency.filterField, parentIds);
+    }
+    const parentIds = resolveParentItemIds(sections, sectionIndex, dependency.parentSectionTypeKey);
+    if (!parentIds.length) {
+        return null;
+    }
+    const records = await loadHazardRisks(parentIds);
+    const derivedIds = extractRiskMatrixIdsFromHazardRisks(records);
+    if (!derivedIds.length) {
+        return buildEmptyResultFilter(dependency.filterField);
+    }
+    return buildInFilter(dependency.filterField, derivedIds);
+}
+const defaultItemIdsPlaceholderKey = '@workplacesafety-management:safety-plan-sections.entities.safety-plan-section.fields.item-ids.placeholder';
+/** Clears item selection when section type changes in item dialog context. */
+const WORKPLACE_SAFETY_SECTION_ITEM_LOOKUP_CLEAR_ON_SECTION_TYPE_TRIGGERS = [
+    {
+        event: "{{ events.context('sectionType.id') }}",
+        action: "{{ widget.setValue([]); context.set('items', []); }}",
+    },
+    {
+        event: "{{ events.context('sectionTypeId') }}",
+        action: "{{ widget.setValue([]); context.set('items', []); }}",
+    },
+];
+/**
+ * Reloads lookup data after section type is resolved (`sectionType.id`, `itemEntityName`).
+ */
+const WORKPLACE_SAFETY_SECTION_ITEM_LOOKUP_REFRESH_ON_SECTION_TYPE_EXPOSE_TRIGGERS = [
+    {
+        event: "{{ events.context('sectionType.id') }}",
+        action: '{{ widget.refresh(); }}',
+    },
+    {
+        event: "{{ events.context('sectionType.itemEntityName') }}",
+        action: '{{ widget.refresh(); }}',
+    },
+    {
+        event: "{{ events.context('sectionTypeId') }}",
+        action: '{{ widget.refresh(); }}',
+    },
+];
+const WORKPLACE_SAFETY_SECTION_ITEM_LOOKUP_SECTION_TYPE_TRIGGERS = [
+    ...WORKPLACE_SAFETY_SECTION_ITEM_LOOKUP_CLEAR_ON_SECTION_TYPE_TRIGGERS,
+    ...WORKPLACE_SAFETY_SECTION_ITEM_LOOKUP_REFRESH_ON_SECTION_TYPE_EXPOSE_TRIGGERS,
+];
+function isPpeRuleSectionType(sectionTypeId) {
+    return (sectionTypeId === WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.ppeHazards ||
+        sectionTypeId === WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.hazardRiskPpe);
+}
+function buildSectionTypeItemTextFieldExpression(sectionTypeIdPath) {
+    const ppeHazardsId = WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.ppeHazards;
+    const hazardRiskPpeId = WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.hazardRiskPpe;
+    return `{{ [ '${ppeHazardsId}', '${hazardRiskPpeId}' ].includes(context.eval('${sectionTypeIdPath}')) ? 'ppeItem.title' : 'title' }}`;
+}
+function buildSectionTypeItemColumnsExpression(sectionTypeIdPath) {
+    const ppeHazardsId = WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.ppeHazards;
+    const hazardRiskPpeId = WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.hazardRiskPpe;
+    const riskMatrixId = WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.riskMatrix;
+    return `{{ context.eval('${sectionTypeIdPath}') === '${riskMatrixId}' ? ['code', 'title', 'matrix'] : [ '${ppeHazardsId}', '${hazardRiskPpeId}' ].includes(context.eval('${sectionTypeIdPath}')) ? ['code', 'ppeItem.title', 'requirementType'] : ['code', 'title'] }}`;
+}
+function buildSectionTypeDependentParentFilter(sectionTypeIdPath, parentIdsContextKey, parentSectionTypeKey) {
+    const dependentSectionTypeIds = Object.entries(WORKPLACE_SAFETY_SECTION_TYPE_DEPENDENCIES)
+        .filter(([, config]) => config.kind === 'parentFilter' && config.parentSectionTypeKey === parentSectionTypeKey)
+        .map(([key]) => {
+        const id = Object.entries(WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_BY_ID).find(([, meta]) => meta.sectionTypeKey === key)?.[0];
+        return id ? `'${id}'` : undefined;
+    })
+        .filter((id) => Boolean(id))
+        .join(',');
+    return {
+        field: parentSectionTypeKey === 'Hazard' ? 'hazardId' : 'hazardRiskId',
+        operator: { type: 'in' },
+        value: `{{ [${dependentSectionTypeIds}].includes(context.eval('${sectionTypeIdPath}')) ? ((context.eval('${parentIdsContextKey}') || []).length ? context.eval('${parentIdsContextKey}') : undefined) : undefined }}`,
+    };
+}
+function buildSectionTypeDependentHazardFilter(sectionTypeIdPath, parentHazardIdsContextKey) {
+    return buildSectionTypeDependentParentFilter(sectionTypeIdPath, parentHazardIdsContextKey, 'Hazard');
+}
+const sectionItemLookupExpose = [
+    { source: 'id', target: 'items.{id}' },
+    { source: 'title', target: 'items.{title}' },
+    { source: 'code', target: 'items.{code}' },
+    { source: 'ppeItem.id', target: 'items.{id}' },
+    { source: 'ppeItem.title', target: 'items.{title}' },
+    { source: 'ppeItem.code', target: 'items.{code}' },
+];
+/** Shared item lookup options for builder item dialog (`sectionType.*` in dialog context). */
+function buildSafetyPlanSectionItemLookupOptions(entityExpression, options) {
+    const sectionTypeIdPath = options?.sectionTypeIdPath ?? 'sectionType.id';
+    const lookup = {
+        entity: entityExpression,
+        look: 'lookup',
+        multiple: true,
+        allowSearch: true,
+        textField: buildSectionTypeItemTextFieldExpression(sectionTypeIdPath),
+        columns: buildSectionTypeItemColumnsExpression(sectionTypeIdPath),
+        placeholder: options?.defaultPlaceholderKey ?? defaultItemIdsPlaceholderKey,
+        expose: sectionItemLookupExpose,
+        triggers: WORKPLACE_SAFETY_SECTION_ITEM_LOOKUP_SECTION_TYPE_TRIGGERS,
+    };
+    const filters = [];
+    if (options?.parentHazardIdsContextKey) {
+        filters.push(buildSectionTypeDependentHazardFilter(sectionTypeIdPath, options.parentHazardIdsContextKey));
+    }
+    if (options?.parentHazardRiskIdsContextKey) {
+        filters.push(buildSectionTypeDependentParentFilter(sectionTypeIdPath, options.parentHazardRiskIdsContextKey, 'HazardRisk'));
+    }
+    if (filters.length === 1) {
+        lookup['filter'] = filters[0];
+    }
+    else if (filters.length > 1) {
+        lookup['filter'] = { logic: 'and', filters };
+    }
+    return lookup;
+}
+/** Lookup options with entity data-selector popup UI (`look: 'lookup'`). */
+function buildSafetyPlanSectionItemSelectorOptions(entityExpression, options) {
+    return {
+        ...buildSafetyPlanSectionItemLookupOptions(entityExpression, options),
+        look: 'lookup',
+    };
+}
+function resolveSafetyPlanSectionItemColumns(sectionTypeId) {
+    if (sectionTypeId === WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.ppeHazards) {
+        return ['code', 'ppeItem.title', 'requirementType'];
+    }
+    if (sectionTypeId === WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.hazardRiskPpe) {
+        return ['code', 'hazardRisk.title', 'ppeItem.title', 'requirementType'];
+    }
+    if (sectionTypeId === WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.riskMatrix) {
+        return [
+            'code',
+            'title',
+            'matrix',
+            { name: 'likelihoodIds', visible: false },
+            { name: 'severityIds', visible: false },
+            { name: 'likelihoodId', visible: false },
+            { name: 'severityId', visible: false },
+            { name: 'matrixOrientation', visible: false },
+        ];
+    }
+    return ['code', 'title'];
+}
+function resolveSafetyPlanSectionItemEntityKey(sectionTypeId, sectionType) {
+    return resolveSectionItemEntityName(sectionTypeId, sectionType);
+}
+function mapSafetyPlanSectionSelectedItems(sectionTypeId, selectedItems) {
+    const isPpeHazards = sectionTypeId === WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.ppeHazards;
+    const isHazardRiskPpe = sectionTypeId === WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.hazardRiskPpe;
+    return selectedItems
+        .map((item) => {
+        if (isPpeHazards || isHazardRiskPpe) {
+            const ppeItem = item['ppeItem'];
+            const id = String(ppeItem?.['id'] ?? item['id'] ?? '');
+            return {
+                id,
+                title: asSafetyPlanDisplayText(ppeItem?.['title']) || undefined,
+                code: asSafetyPlanDisplayText(ppeItem?.['code']) || undefined,
+            };
+        }
+        return {
+            id: String(item['id'] ?? ''),
+            title: asSafetyPlanDisplayText(item['title']) || undefined,
+            code: asSafetyPlanDisplayText(item['code']) || undefined,
+        };
+    })
+        .filter((item) => item.id.length > 0);
+}
+function dedupeSafetyPlanSectionItemSelection(item) {
+    const seen = new Set();
+    const itemIds = [];
+    const items = [];
+    for (let index = 0; index < (item.itemIds?.length ?? 0); index += 1) {
+        const id = item.itemIds?.[index];
+        if (typeof id !== 'string' || !id || seen.has(id)) {
+            continue;
+        }
+        seen.add(id);
+        itemIds.push(id);
+        const snapshot = item.items?.find((entry) => entry?.id === id) ??
+            (item.items?.[index]?.id === id || !item.items?.[index]?.id ? item.items?.[index] : undefined);
+        items.push({
+            id,
+            title: asSafetyPlanDisplayText(snapshot?.title) || undefined,
+            code: asSafetyPlanDisplayText(snapshot?.code) || undefined,
+        });
+    }
+    return { ...item, itemIds, items };
+}
+function isPpeRuleSectionTypeId(sectionTypeId) {
+    return isPpeRuleSectionType(sectionTypeId);
+}
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Constants   ----
+const listSortAndFilterOptions = {
+    sort: { enabled: true },
+    filter: { advance: { enabled: true }, inline: { enabled: true } },
+};
+/**
+ * Section-type picker for activity item rows — no title/description sync (those would
+ * write onto the parent SafetyPlanActivity fields), and Activity itself is excluded.
+ * Keep `expose` so `sectionType.id` updates and itemIds cascade can react.
+ */
+const ACTIVITY_ITEMS_SECTION_TYPE_LOOKUP_OPTIONS = {
+    ...WORKPLACE_SAFETY_SECTION_TYPE_LOOKUP_WIDGET_OPTIONS,
+    triggers: [],
+    filter: {
+        logic: 'and',
+        filters: [
+            {
+                field: 'id',
+                operator: { type: 'notEqual' },
+                value: WORKPLACE_SAFETY_BUILT_IN_SECTION_TYPE_IDS.activity,
+            },
+        ],
+    },
+};
+/**
+ * Bound sectionTypeId on the repeater row (parent of the itemIds lookup).
+ * `>` is required at eval time for the correct row value.
+ */
+const ACTIVITY_ITEM_SECTION_TYPE_ID_PATH = '>sectionTypeId';
+/** Maps row sectionTypeId → catalog entity (Hazard, Ppe, Control, …). */
+const ACTIVITY_ITEM_ENTITY_EXPRESSION = buildWorkplaceSafetySectionTypeEntityExpression(ACTIVITY_ITEM_SECTION_TYPE_ID_PATH);
+/**
+ * Enable itemIds once the row has a section type.
+ *
+ * `>sectionTypeId` alone does not re-trigger option updates for nested paths like
+ * `items.[n].sectionTypeId` (renderer dependency matching ignores the `>` prefix).
+ * Including bare `sectionTypeId` makes `isSegmentSuffix` treat the nested change as
+ * relevant so disabled/entity expressions re-evaluate after selection.
+ */
+const ACTIVITY_ITEM_IDS_DISABLED_EXPRESSION = "{{ !(context.eval('>sectionTypeId') || context.eval('sectionTypeId')) }}";
+/**
+ * Activity-only cascade: clear selection + refresh entity/data when section type changes.
+ * Do not use the shared section triggers — they call `context.set('items', [])`, which
+ * would wipe this entity's `items` repeater (same key as the lookup expose parent).
+ */
+const ACTIVITY_ITEM_IDS_SECTION_TYPE_TRIGGERS = [
+    {
+        event: "{{ events.context('sectionType.id') }}",
+        action: '{{ widget.setValue([]); widget.refresh(); }}',
+    },
+    {
+        event: "{{ events.context('sectionTypeId') }}",
+        action: '{{ widget.setValue([]); widget.refresh(); }}',
+    },
+];
+/** Same repeater widget tree as {@link safetyPlanSectionEntityFactory} `items`. */
+const ITEMS_REPEATER_CHILDREN = [
+    {
+        type: AXPWidgetsList.Layouts.GridLayout,
+        mode: 'edit',
+        name: 'itemRow',
+        options: {
+            grid: {
+                default: {
+                    columns: 12,
+                    gap: '1rem',
+                },
+            },
+        },
+        children: [
+            {
+                type: AXPWidgetsList.Layouts.GridItemLayout,
+                mode: 'edit',
+                options: { colSpan: 4 },
+                children: [
+                    {
+                        type: AXPWidgetsList.Layouts.FormField,
+                        mode: 'edit',
+                        options: {
+                            label: '@workplacesafety-management:safety-plan-sections.entities.safety-plan-section.fields.section-type.title',
+                            showLabel: true,
+                        },
+                        children: [
+                            {
+                                type: AXPWidgetsList.Editors.LookupBox,
+                                mode: 'edit',
+                                path: 'sectionTypeId',
+                                name: 'sectionTypeId',
+                                options: {
+                                    entity: `${RootConfig.module.name}.${RootConfig.entities.sectionType.name}`,
+                                    ...ACTIVITY_ITEMS_SECTION_TYPE_LOOKUP_OPTIONS,
+                                },
+                            },
+                        ],
+                    },
+                ],
+            },
+            {
+                type: AXPWidgetsList.Layouts.GridItemLayout,
+                mode: 'edit',
+                options: { colSpan: 8 },
+                children: [
+                    {
+                        type: AXPWidgetsList.Layouts.FormField,
+                        mode: 'edit',
+                        options: {
+                            label: '@workplacesafety-management:safety-plan-sections.entities.safety-plan-section.fields.item-ids.title',
+                            showLabel: true,
+                        },
+                        children: [
+                            {
+                                type: AXPWidgetsList.Editors.LookupBox,
+                                mode: 'edit',
+                                path: 'itemIds',
+                                name: 'itemIds',
+                                triggers: ACTIVITY_ITEM_IDS_SECTION_TYPE_TRIGGERS,
+                                options: {
+                                    ...buildSafetyPlanSectionItemSelectorOptions(ACTIVITY_ITEM_ENTITY_EXPRESSION, {
+                                        sectionTypeIdPath: ACTIVITY_ITEM_SECTION_TYPE_ID_PATH,
+                                    }),
+                                    // Shared options expose into `items.*` — that key is this entity's repeater.
+                                    expose: [],
+                                    triggers: ACTIVITY_ITEM_IDS_SECTION_TYPE_TRIGGERS,
+                                    valueField: 'id',
+                                    disabled: ACTIVITY_ITEM_IDS_DISABLED_EXPRESSION,
+                                },
+                            },
+                        ],
+                    },
+                ],
+            },
+        ],
+    },
+];
+const itemsPropertyLayout = {
+    name: 'items',
+    layout: { label: { visible: false }, order: 1, positions: { lg: { colSpan: 12 } } },
+};
+//#endregion
+//#region ----   Entity factory   ----
+async function safetyPlanActivityEntityFactory() {
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.safetyPlanActivity.name,
+        title: RootConfig.entities.safetyPlanActivity.title,
+        icon: RootConfig.entities.safetyPlanActivity.icon,
+        searchTags: [
+            'safety-plan-activity',
+            'safety plan activity',
+            'activity',
+            'work activity',
+            'plan activity',
+            'فعالیت برنامه ایمنی',
+            'فعالیت',
+            'برنامه ایمنی',
+            'ایمنی محیط کار',
+        ],
+        formats: {
+            individual: RootConfig.entities.safetyPlanActivity.title,
+            plural: RootConfig.entities.safetyPlanActivity.titlePlural,
+            searchResult: {
+                title: '{{ code }}',
+                description: '{{ description }}',
+            },
+        },
+        plugins: [
+            { name: 'identifier', options: { field: 'code', rule: 'safety-plan-activity-code' } },
+            { name: 'unique-fields', options: { fields: 'code', scope: 'global' } },
+            { name: 'archive' },
+            {
+                name: 'attachments',
+                options: {
+                    accept: '.jpg,.jpeg,.png,.pdf,.doc,.docx',
+                    fileEditable: true,
+                    display: 'page',
+                },
+            },
+        ],
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'basic-info',
+                title: '@workplacesafety-management:safety-plan-activities.entities.safety-plan-activity.groups.basic-info',
+            },
+            {
+                id: 'items',
+                title: '@workplacesafety-management:safety-plan-activities.entities.safety-plan-activity.groups.items',
+            },
+        ],
+        properties: [
+            {
+                name: 'id',
+                title: '@general:terms.common.id',
+                groupId: 'basic-info',
+                schema: { dataType: 'uuid', visible: false, nullable: false, readonly: true, unique: { enabled: true } },
+            },
+            {
+                name: 'code',
+                title: '@workplacesafety-management:safety-plan-activities.entities.safety-plan-activity.fields.code.title',
+                groupId: 'basic-info',
+                options: listSortAndFilterOptions,
+                schema: {
+                    dataType: 'string',
+                    unique: { enabled: true },
+                    interface: {
+                        type: AXPWidgetsList.Editors.TextBox,
+                        options: {
+                            disabled: true,
+                            placeholder: '@workplacesafety-management:safety-plan-activities.entities.safety-plan-activity.fields.code.placeholder',
+                        },
+                    },
+                },
+                validations: [{ rule: 'required' }],
+            },
+            {
+                name: 'title',
+                title: '@workplacesafety-management:safety-plan-activities.entities.safety-plan-activity.fields.title.title',
+                groupId: 'basic-info',
+                options: listSortAndFilterOptions,
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsList.Editors.TextBox,
+                        options: {
+                            placeholder: '@workplacesafety-management:safety-plan-activities.entities.safety-plan-activity.fields.title.placeholder',
+                        },
+                    },
+                },
+                validations: [{ rule: 'required' }],
+            },
+            {
+                name: 'description',
+                title: '@workplacesafety-management:safety-plan-activities.entities.safety-plan-activity.fields.description.title',
+                groupId: 'basic-info',
+                options: {
+                    sort: { enabled: false },
+                    filter: { advance: { enabled: true }, inline: { enabled: false } },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsList.Editors.LargeTextBox,
+                        options: {
+                            rows: 2,
+                            placeholder: '@workplacesafety-management:safety-plan-activities.entities.safety-plan-activity.fields.description.placeholder',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'items',
+                title: '',
+                groupId: 'items',
+                schema: {
+                    defaultValue: [],
+                    dataType: 'array',
+                    nullable: true,
+                    interface: {
+                        type: AXPWidgetsList.Layouts.RepeaterLayout,
+                        options: { hasControls: true, allowReorder: true },
+                        children: [...ITEMS_REPEATER_CHILDREN],
+                    },
+                },
+            },
+        ],
+        columns: [
+            { name: 'code', options: { width: '120px', order: 1 } },
+            { name: 'title', options: { width: '200px', order: 2 } },
+            { name: 'description', options: { width: '280px', order: 3 } },
+        ],
+        interfaces: {
+            master: {
+                create: {
+                    sections: [{ id: 'basic-info' }, { id: 'items' }],
+                    properties: [
+                        { name: 'code', layout: { positions: { lg: { colSpan: 6, order: 1 } } } },
+                        { name: 'title', layout: { positions: { lg: { colSpan: 12, order: 2 } } } },
+                        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
+                        itemsPropertyLayout,
+                    ],
+                },
+                update: {
+                    sections: [{ id: 'basic-info' }, { id: 'items' }],
+                    properties: [
+                        { name: 'code', layout: { positions: { lg: { colSpan: 6, order: 1 } } } },
+                        { name: 'title', layout: { positions: { lg: { colSpan: 12, order: 2 } } } },
+                        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
+                        itemsPropertyLayout,
+                    ],
+                },
+                single: {
+                    title: '{{ title }}',
+                    sections: [
+                        { id: 'basic-info', layout: { positions: { lg: { colSpan: 12 } } } },
+                        { id: 'items', layout: { positions: { lg: { colSpan: 12 } } } },
+                    ],
+                    properties: [
+                        { name: 'code', layout: { positions: { lg: { colSpan: 6, order: 1 } } } },
+                        { name: 'title', layout: { positions: { lg: { colSpan: 12, order: 2 } } } },
+                        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
+                        itemsPropertyLayout,
+                    ],
+                    actions: [...entityMasterRecordActions()],
+                },
+                list: {
+                    actions: [...entityMasterCrudActions()],
+                    views: [createAllQueryView({ sorts: [{ name: 'code', dir: 'asc' }] })],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+//#endregion
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { safetyPlanActivityEntityFactory };
+//# sourceMappingURL=acorex-platform-module-workplacesafety-management-client-contracts-entities-safety-plan-activity.mjs.map