@acorex/platform 21.0.0-next.85 → 21.0.0-next.88

package/fesm2022/acorex-platform-layout-entity-contracts.mjs

@@ -0,0 +1,1114 @@
+import { AXPSystemActionType } from '@acorex/platform/contracts';
+import { omit } from 'lodash-es';
+
+//#region ---- Entity actions ----
+var AXPEntityCommandScope;
+(function (AXPEntityCommandScope) {
+    AXPEntityCommandScope["TypeLevel"] = "typeLevel";
+    AXPEntityCommandScope["Selected"] = "selected";
+    AXPEntityCommandScope["Individual"] = "individual";
+    AXPEntityCommandScope["Section"] = "section";
+})(AXPEntityCommandScope || (AXPEntityCommandScope = {}));
+var AXPEntityQueryType;
+(function (AXPEntityQueryType) {
+    AXPEntityQueryType["Single"] = "single";
+    AXPEntityQueryType["List"] = "list";
+})(AXPEntityQueryType || (AXPEntityQueryType = {}));
+//#endregion
+
+//#region ---- Entity properties ----
+//#endregion
+
+//#region ---- Entity definition ----
+var AXPRelationshipKind;
+(function (AXPRelationshipKind) {
+    AXPRelationshipKind[AXPRelationshipKind["Association"] = 0] = "Association";
+    AXPRelationshipKind[AXPRelationshipKind["Composition"] = 1] = "Composition";
+    AXPRelationshipKind[AXPRelationshipKind["Aggregation"] = 2] = "Aggregation";
+})(AXPRelationshipKind || (AXPRelationshipKind = {}));
+var AXPRelationshipCardinality;
+(function (AXPRelationshipCardinality) {
+    AXPRelationshipCardinality[AXPRelationshipCardinality["OneToOne"] = 0] = "OneToOne";
+    AXPRelationshipCardinality[AXPRelationshipCardinality["OneToMany"] = 1] = "OneToMany";
+    AXPRelationshipCardinality[AXPRelationshipCardinality["ManyToMany"] = 2] = "ManyToMany";
+})(AXPRelationshipCardinality || (AXPRelationshipCardinality = {}));
+function kebabCase(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
+        .replace(/[\s_]+/g, '-')
+        .replace(/-+/g, '-')
+        .toLowerCase();
+}
+function getEntityInfo(entity) {
+    return {
+        source: `${entity.module}.${entity.name}`,
+        module: {
+            route: kebabCase(entity.module),
+        },
+        entity: {
+            route: kebabCase(entity.name),
+        },
+    };
+}
+var AXPEntityType;
+(function (AXPEntityType) {
+    AXPEntityType[AXPEntityType["Entity"] = 0] = "Entity";
+    AXPEntityType[AXPEntityType["AggregateRoot"] = 1] = "AggregateRoot";
+    AXPEntityType[AXPEntityType["ValueObject"] = 2] = "ValueObject";
+})(AXPEntityType || (AXPEntityType = {}));
+//#endregion
+
+//#region ---- Entity model & DTO types ----
+//#endregion
+
+//#endregion
+
+//#region ---- Entity formats ----
+//#endregion
+
+//#region ---- Entity property list options ----
+//#endregion
+
+//#region ---- Entity display fields ----
+//#endregion
+
+//#region ---- Entity card fields ----
+/** Whether the card field is shown as a header badge (not in the card body). */
+function isCardFieldBadgeDisplay(display) {
+    if (display === 'badge') {
+        return true;
+    }
+    return typeof display === 'object' && display !== null && display.type === 'badge';
+}
+/** Resolves static badge color config from {@link AXPCardField.display} and legacy {@link AXPCardField.badgeColor}. */
+function resolveCardFieldBadgeColor(field) {
+    if (typeof field.display === 'object' && field.display.type === 'badge') {
+        return field.display.options?.color ?? field.badgeColor;
+    }
+    if (field.display === 'badge') {
+        return field.badgeColor;
+    }
+    return undefined;
+}
+//#endregion
+
+//#region ---- Entity query views ----
+function createQueryView(name, title, fixed, params = {
+    columns: [],
+    conditions: [],
+    sorts: [],
+}) {
+    params = Object.assign({ columns: [], sorts: [], conditions: [] }, params);
+    return {
+        name,
+        title,
+        fixed,
+        columns: params.columns ?? [],
+        conditions: params.conditions ?? [],
+        sorts: params.sorts ?? [],
+    };
+}
+function createAllQueryView(params = {
+    columns: [],
+    sorts: [],
+    conditions: [],
+}) {
+    params = Object.assign({ columns: [], sorts: [], conditions: [] }, params);
+    return createQueryView('all', '@general:terms.interface.selection.all-items', true, {
+        columns: params.columns ?? [],
+        conditions: params.conditions ?? [],
+        sorts: params.sorts ?? [],
+    });
+}
+//#endregion
+
+//#region ---- Entity master list views ----
+/** Resolves master list layouts that are currently enabled. */
+function resolveEnabledMasterListLayouts(layouts) {
+    if (!layouts) {
+        return ['table'];
+    }
+    const enabled = [];
+    if (layouts.table?.enabled !== false) {
+        enabled.push('table');
+    }
+    if (layouts.card && layouts.card.enabled !== false) {
+        enabled.push('card');
+    }
+    return enabled.length > 0 ? enabled : ['table'];
+}
+/** First enabled layout; used as the default when no user preference is stored. */
+function resolveDefaultMasterListLayout(layouts) {
+    return resolveEnabledMasterListLayouts(layouts)[0];
+}
+//#endregion
+
+//#region ---- Entity detail list views ----
+//#endregion
+
+//#region ---- Entity layout views ----
+//#endregion
+
+//#region ---- Related entity layout ----
+//#endregion
+
+//#region ---- Entity list filters ----
+/** Encodes a dotted storage path as a flat filter context key (e.g. `person.lastName` → `person__lastName`). */
+function encodeEntityListFilterContextField(queryField) {
+    return queryField.replace(/\./g, '__');
+}
+/**
+ * Resolves the flat context key used by query-filters / widget binding for a filter definition.
+ */
+function resolveEntityListFilterContextField(filter) {
+    const explicit = filter.contextField?.trim();
+    if (explicit) {
+        return explicit;
+    }
+    const field = filter.field?.trim();
+    if (!field) {
+        return '';
+    }
+    return field.includes('.') ? encodeEntityListFilterContextField(field) : field;
+}
+/**
+ * Maps an entity list filter definition to the storage query field.
+ * Inline `contains` filters on lookup/select use `inlineQueryField` (display text path).
+ */
+function resolveEntityListFilterQueryField(filter, operator) {
+    const operatorType = operator?.type ?? filter.operator?.type;
+    if (operatorType === 'contains' && filter.inlineQueryField) {
+        return filter.inlineQueryField;
+    }
+    return filter.field;
+}
+//#endregion
+
+//#region ---- Types barrel ----
+//#endregion
+
+//#region ---- Entity action helpers (pure data, no Angular) ----
+//#region Master
+function entityMasterCreateAction() {
+    return {
+        title: '@general:actions.create.title',
+        command: {
+            name: 'Entity:Create',
+        },
+        priority: 'primary',
+        type: AXPSystemActionType.Create,
+        scope: AXPEntityCommandScope.TypeLevel,
+    };
+}
+function entityMasterEditAction() {
+    return {
+        title: '@general:actions.edit.title',
+        command: 'Entity:Update',
+        priority: 'secondary',
+        type: AXPSystemActionType.Update,
+        scope: AXPEntityCommandScope.Individual,
+        default: true,
+    };
+}
+function entityMasterBulkDeleteAction() {
+    return {
+        title: '@general:actions.delete-items.title',
+        command: 'delete-entity',
+        priority: 'primary',
+        type: AXPSystemActionType.Delete,
+        scope: AXPEntityCommandScope.Selected,
+        order: 100,
+    };
+}
+function entityMasterViewAction() {
+    return {
+        title: '@general:actions.view.title',
+        command: 'open-entity',
+        priority: 'secondary',
+        type: AXPSystemActionType.View,
+        scope: AXPEntityCommandScope.Individual,
+        default: true,
+    };
+}
+function entityMasterDeleteAction() {
+    return {
+        title: '@general:actions.delete.title',
+        command: 'delete-entity',
+        priority: 'secondary',
+        type: AXPSystemActionType.Delete,
+        scope: AXPEntityCommandScope.Individual,
+        order: 100,
+        shortcuts: ['ctrl+shift+delete'],
+    };
+}
+function entityMasterCrudActions(options) {
+    const opts = {
+        create: true,
+        delete: true,
+        view: true,
+        edit: false,
+        ...options,
+    };
+    const actions = [];
+    if (opts.create) {
+        actions.push(entityMasterCreateAction());
+    }
+    if (opts.delete) {
+        actions.push(entityMasterBulkDeleteAction());
+        actions.push(entityMasterDeleteAction());
+    }
+    if (opts.view) {
+        actions.push(entityMasterViewAction());
+    }
+    if (opts.edit) {
+        actions.push(entityMasterEditAction());
+    }
+    return actions;
+}
+function entityMasterRecordActions() {
+    return [entityMasterDeleteAction()];
+}
+//#endregion
+//#region Details
+function entityDetailsCreateActions(parentId) {
+    return {
+        title: '@general:actions.create.title',
+        command: {
+            name: 'Entity:Create',
+            options: {
+                process: {
+                    redirect: false,
+                    canCreateNewOne: true,
+                    data: {
+                        [parentId]: '{{context.eval("id")}}',
+                    },
+                },
+            },
+        },
+        priority: 'primary',
+        type: AXPSystemActionType.Create,
+        scope: AXPEntityCommandScope.TypeLevel,
+    };
+}
+function entityDetailsCreateActionsDeferredParent() {
+    return {
+        title: '@general:actions.create.title',
+        command: {
+            name: 'Entity:Create',
+            options: {
+                process: {
+                    redirect: false,
+                    canCreateNewOne: true,
+                    data: {},
+                },
+            },
+        },
+        priority: 'primary',
+        type: AXPSystemActionType.Create,
+        scope: AXPEntityCommandScope.TypeLevel,
+    };
+}
+function mergeForeignKeyFieldIntoCreateActions(foreignKeyField, actions) {
+    if (!foreignKeyField || !actions?.length) {
+        return actions ?? [];
+    }
+    return actions.map((a) => {
+        const cmd = a.command;
+        if (typeof cmd !== 'object' ||
+            !cmd ||
+            cmd.name !== 'Entity:Create' ||
+            a.scope !== AXPEntityCommandScope.TypeLevel) {
+            return a;
+        }
+        const opts = (cmd.options ?? {});
+        const proc = (opts['process'] ?? {});
+        const data = { ...(proc['data'] ?? {}) };
+        if (data[foreignKeyField] === undefined || data[foreignKeyField] === null || data[foreignKeyField] === '') {
+            data[foreignKeyField] = '{{ context.eval("id") }}';
+        }
+        return {
+            ...a,
+            command: {
+                ...cmd,
+                options: { ...opts, process: { ...proc, data } },
+            },
+        };
+    });
+}
+function collectNestedCreateHiddenProperties(relatedEntity) {
+    const fk = relatedEntity.persistence?.foreignKeyField;
+    const merged = [...(relatedEntity.excludeProperties ?? [])];
+    if (fk) {
+        merged.push(fk);
+    }
+    const unique = [...new Set(merged)];
+    return unique.length ? unique : undefined;
+}
+function entityDetailsSimpleCondition(fk) {
+    return {
+        name: fk,
+        operator: { type: 'equal' },
+        value: '{{context.eval("id")}}',
+    };
+}
+function entityDetailsReferenceCondition(type) {
+    return [
+        {
+            name: 'reference.id',
+            operator: { type: 'equal' },
+            value: '{{context.eval("id")}}',
+        },
+        {
+            name: 'reference.type',
+            operator: { type: 'equal' },
+            value: type,
+        },
+    ];
+}
+function entityDetailsEditAction() {
+    return {
+        title: '@general:actions.edit.title',
+        command: 'Entity:Update',
+        priority: 'secondary',
+        type: AXPSystemActionType.Update,
+        default: true,
+        scope: AXPEntityCommandScope.Individual,
+    };
+}
+function entityDetailsNewEditAction() {
+    return {
+        title: 'New Edit',
+        command: {
+            name: 'Entity:Update',
+        },
+        priority: 'secondary',
+        type: AXPSystemActionType.Update,
+        default: true,
+        scope: AXPEntityCommandScope.Individual,
+    };
+}
+function entityOverrideDetailsViewAction() {
+    return {
+        title: '@general:actions.view.title',
+        command: 'open-entity',
+        priority: 'secondary',
+        hidden: true,
+        type: AXPSystemActionType.View,
+        scope: AXPEntityCommandScope.Individual,
+    };
+}
+function entityDetailsCrudActions(parentId, options) {
+    const opts = {
+        create: true,
+        delete: true,
+        view: true,
+        edit: true,
+        ...options,
+    };
+    const actions = [];
+    if (opts.create) {
+        if (parentId) {
+            actions.push(entityDetailsCreateActions(parentId));
+        }
+        else {
+            actions.push(entityDetailsCreateActionsDeferredParent());
+        }
+    }
+    if (opts.edit) {
+        actions.push(entityDetailsEditAction());
+    }
+    if (opts.view) {
+        actions.push(entityOverrideDetailsViewAction());
+    }
+    return actions;
+}
+function entityDetailsReferenceCreateActions(type) {
+    return [
+        {
+            title: '@general:actions.create.title',
+            command: {
+                name: 'Entity:Create',
+                options: {
+                    process: {
+                        redirect: false,
+                        canCreateNewOne: true,
+                        data: {
+                            reference: {
+                                id: '{{context.eval("id")}}',
+                                type: type,
+                            },
+                        },
+                    },
+                },
+            },
+            priority: 'primary',
+            type: AXPSystemActionType.Create,
+            scope: AXPEntityCommandScope.TypeLevel,
+        },
+        entityDetailsEditAction(),
+        entityOverrideDetailsViewAction(),
+    ];
+}
+//#endregion
+
+//#region ---- Helpers barrel ----
+//#endregion
+
+//#region ---- Template normalization ----
+/**
+ * Normalizes display templates before expression evaluation.
+ * Converts simple dot paths (e.g. `{{ position.title }}`) to `context.eval("position.title")`.
+ */
+function normalizeExpressionTemplate(template) {
+    let normalized = template.replace(/\{\{\s*context\.eval\(['"]([^'"]+)['"]\)\s*\}\}/g, '{{ context.eval("$1") }}');
+    if (!normalized.includes('{{')) {
+        normalized = normalized.replace(/\{/g, '{{').replace(/\}/g, '}}');
+    }
+    return normalized.replace(/\{\{\s*(?!context\.)([\w]+(?:\.[\w]+)*)\s*\}\}/g, '{{ context.eval("$1") }}');
+}
+/** @see normalizeExpressionTemplate */
+const normalizeEntityDisplayTemplate = normalizeExpressionTemplate;
+/** True when formatted text still contains unresolved template markers. */
+function isUnresolvedEntityDisplayTemplate(value) {
+    return /\{\{/.test(value) || /context\.eval\s*\(/.test(value) || value === '[object Object]';
+}
+/**
+ * Strips literal `undefined` / `null` tokens produced when expression segments are missing.
+ */
+function sanitizeResolvedEntityDisplayTitle(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return '';
+    }
+    const withoutLiterals = trimmed
+        .replace(/\bundefined\b/gi, ' ')
+        .replace(/\bnull\b/gi, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    return withoutLiterals
+        .replace(/^[\s\-–—·|/,()+]+|[\s\-–—·|/,()+]+$/g, '')
+        .trim();
+}
+/** True when a resolved title is non-empty and safe to show in search or entity chrome. */
+function isMeaningfulEntityDisplayTitle(value) {
+    const sanitized = sanitizeResolvedEntityDisplayTitle(value);
+    return sanitized.length > 0 && !isUnresolvedEntityDisplayTemplate(sanitized);
+}
+function isRowBoundEntityDisplayTemplate(template) {
+    const trimmed = template.trim();
+    if (!trimmed || trimmed.startsWith('@')) {
+        return false;
+    }
+    return trimmed.includes('{{') || trimmed.includes('{');
+}
+//#endregion
+
+//#endregion
+//#region ---- Expose parsing ----
+/**
+ * Parses lookup/select `expose` entries from a property interface options object.
+ */
+function parsePropertyExposeEntries(options) {
+    const expose = options?.['expose'];
+    if (!Array.isArray(expose)) {
+        return [];
+    }
+    return expose.filter((row) => row != null &&
+        typeof row === 'object' &&
+        typeof row.source === 'string' &&
+        typeof row.target === 'string');
+}
+/**
+ * Collects all non-empty `expose[].target` paths from a property.
+ */
+function collectPropertyExposeTargetPaths(property) {
+    const opts = property.schema?.interface?.options;
+    if (!opts || typeof opts !== 'object') {
+        return [];
+    }
+    const paths = new Set();
+    for (const entry of parsePropertyExposeEntries(opts)) {
+        const target = entry.target.trim();
+        if (target) {
+            paths.add(target);
+        }
+    }
+    return [...paths];
+}
+/**
+ * Resolves list column `options.dataPath` for a property when explicitly set.
+ */
+function resolveEntityColumnDataPath(entity, propertyName) {
+    const column = entity?.columns?.find((c) => c.name === propertyName);
+    const rawDataPath = column?.options?.['dataPath'];
+    if (typeof rawDataPath !== 'string') {
+        return undefined;
+    }
+    const dataPath = rawDataPath.trim();
+    if (!dataPath || dataPath === propertyName) {
+        return undefined;
+    }
+    return dataPath;
+}
+/**
+ * Resolves the lodash-get path for lookup/select display text from expose metadata.
+ */
+function resolvePropertyExposeDisplayTarget(options) {
+    if (!options) {
+        return undefined;
+    }
+    const textField = typeof options['textField'] === 'string' ? options['textField'].trim() : '';
+    const valueField = typeof options['valueField'] === 'string' ? options['valueField'].trim() : 'id';
+    const entries = parsePropertyExposeEntries(options);
+    if (textField) {
+        const match = entries.find((entry) => entry.source === textField);
+        if (match?.target.trim()) {
+            return match.target.trim();
+        }
+    }
+    const displayEntry = entries.find((entry) => entry.source !== valueField && entry.source !== 'id' && entry.target.trim());
+    return displayEntry?.target.trim();
+}
+/**
+ * Resolves the lodash-get path used for inline `contains` filters on lookup/select properties.
+ * Prefers list column `dataPath`, then lookup `expose` target for `textField` (or first non-id expose).
+ * Returns `undefined` when the property name should be used as-is (e.g. plain text fields).
+ */
+function resolveEntityPropertyInlineFilterField(entity, property) {
+    if (!entity || !property?.name) {
+        return undefined;
+    }
+    const dataPath = resolveEntityColumnDataPath(entity, property.name);
+    if (dataPath) {
+        return dataPath;
+    }
+    const opts = property.schema?.interface?.options;
+    if (!opts || typeof opts !== 'object') {
+        return undefined;
+    }
+    return resolvePropertyExposeDisplayTarget(opts);
+}
+//#endregion
+
+//#endregion
+//#region ---- Entity metadata ----
+const DEFAULT_DISPLAY_FIELD_CANDIDATES = [
+    'title',
+    'name',
+    'code',
+    'fullName',
+    'displayName',
+    'subject',
+    'description',
+];
+function entityHasProperty(entity, path) {
+    const root = path.split('.')[0];
+    return entity.properties?.some((property) => property.name === root) ?? false;
+}
+function resolveEntityDisplayPropertyPaths(entity) {
+    const paths = [];
+    const add = (path) => {
+        const trimmed = path?.trim();
+        if (!trimmed || trimmed.includes('{') || paths.includes(trimmed)) {
+            return;
+        }
+        if (entityHasProperty(entity, trimmed)) {
+            paths.push(trimmed);
+        }
+    };
+    const lookupFormat = entity.formats?.lookup?.trim();
+    if (lookupFormat && !lookupFormat.includes('{')) {
+        add(lookupFormat);
+    }
+    for (const candidate of DEFAULT_DISPLAY_FIELD_CANDIDATES) {
+        add(candidate);
+    }
+    const identifierPlugin = entity.plugins?.find((plugin) => plugin.name === 'identifier');
+    const identifierField = identifierPlugin?.options?.['field'];
+    if (typeof identifierField === 'string') {
+        add(identifierField);
+    }
+    if (paths.length === 0) {
+        const firstStringProperty = entity.properties?.find((property) => property.schema?.dataType === 'string' && property.name !== 'id');
+        add(firstStringProperty?.name);
+    }
+    return paths;
+}
+/**
+ * Builds entity-scoped fallback metadata for global search (registered on each entity search definition).
+ */
+function buildEntitySearchTitleContext(entity, primaryTemplate) {
+    const fallbackTemplates = [];
+    const normalizedPrimary = primaryTemplate?.trim()
+        ? normalizeEntityDisplayTemplate(primaryTemplate.trim())
+        : undefined;
+    const addTemplate = (raw) => {
+        const trimmed = raw?.trim();
+        if (!trimmed || !isRowBoundEntityDisplayTemplate(trimmed)) {
+            return;
+        }
+        const normalized = normalizeEntityDisplayTemplate(trimmed);
+        if (!normalized || normalized === normalizedPrimary || fallbackTemplates.includes(normalized)) {
+            return;
+        }
+        fallbackTemplates.push(normalized);
+    };
+    addTemplate(entity.interfaces?.master?.single?.title);
+    addTemplate(entity.formats?.lookup);
+    addTemplate(entity.formats?.individual);
+    return {
+        fallbackTemplates,
+        fallbackFields: resolveEntityDisplayPropertyPaths(entity),
+    };
+}
+/**
+ * Row title template chain aligned with entity layouts.
+ * Priority: `interfaces.master.single.title` → `formats.searchResult.title` → `formats.individual`.
+ */
+function resolveEntityRowTitleTemplate(entity) {
+    if (!entity) {
+        return undefined;
+    }
+    const singleTitle = entity.interfaces?.master?.single?.title?.trim();
+    if (singleTitle && isRowBoundEntityDisplayTemplate(singleTitle)) {
+        return normalizeEntityDisplayTemplate(singleTitle);
+    }
+    const searchTitle = entity.formats?.searchResult?.title?.trim();
+    if (searchTitle && isRowBoundEntityDisplayTemplate(searchTitle)) {
+        return normalizeEntityDisplayTemplate(searchTitle);
+    }
+    const lookupFormat = entity.formats?.lookup?.trim();
+    if (lookupFormat && isRowBoundEntityDisplayTemplate(lookupFormat)) {
+        return normalizeEntityDisplayTemplate(lookupFormat);
+    }
+    const individual = entity.formats?.individual?.trim();
+    if (individual && isRowBoundEntityDisplayTemplate(individual)) {
+        return normalizeEntityDisplayTemplate(individual);
+    }
+    return undefined;
+}
+/**
+ * Record title template for modify popups: `interfaces.master.update.title` → `single.title`.
+ */
+function resolveEntityModifyRecordTitleTemplate(entity) {
+    if (!entity) {
+        return undefined;
+    }
+    const updateTitle = entity.interfaces?.master?.update?.title?.trim();
+    if (updateTitle && isRowBoundEntityDisplayTemplate(updateTitle)) {
+        return normalizeEntityDisplayTemplate(updateTitle);
+    }
+    const singleTitle = entity.interfaces?.master?.single?.title?.trim();
+    if (singleTitle && isRowBoundEntityDisplayTemplate(singleTitle)) {
+        return normalizeEntityDisplayTemplate(singleTitle);
+    }
+    return undefined;
+}
+//#endregion
+
+//#endregion
+//#region ---- Quick search: schema-driven field paths ----
+const NON_TEXT_DATATYPES = new Set([
+    'number',
+    'integer',
+    'int',
+    'long',
+    'float',
+    'double',
+    'decimal',
+    'money',
+    'currency',
+    'boolean',
+    'bool',
+    'date',
+    'datetime',
+    'time',
+    'object',
+    'array',
+    'json',
+    'image',
+    'file',
+    'binary',
+]);
+/**
+ * Whether an entity property likely stores free text worth a `contains` quick-search clause.
+ */
+function isTextLikeDataType(dataType) {
+    const dt = (dataType ?? 'string').toLowerCase().trim();
+    if (!dt || NON_TEXT_DATATYPES.has(dt)) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Lodash-get paths for quick search from a single entity definition: string-like property names
+ * plus lookup `expose[].target` paths (e.g. `brand.title`).
+ */
+function collectQuickSearchPathsFromSingleEntityDefinition(entity) {
+    if (!entity?.properties?.length) {
+        return [];
+    }
+    const paths = new Set();
+    for (const property of entity.properties) {
+        if (isTextLikeDataType(property.schema?.dataType)) {
+            paths.add(property.name);
+        }
+        for (const target of collectPropertyExposeTargetPaths(property)) {
+            paths.add(target);
+        }
+    }
+    return [...paths];
+}
+//#endregion
+//#region ---- Column-derived nested paths ----
+/**
+ * Adds dotted paths from master columns (`name` or `options.dataPath`), e.g. `person.fullName`, `jobDefinition.title`.
+ */
+function collectNestedFieldPathsFromEntityColumns(entity) {
+    if (!entity?.columns?.length) {
+        return [];
+    }
+    const paths = new Set();
+    for (const col of entity.columns) {
+        const name = col.name.trim();
+        if (name.includes('.')) {
+            paths.add(name);
+        }
+        const rawDp = col.options?.['dataPath'];
+        if (typeof rawDp === 'string') {
+            const dp = rawDp.trim();
+            if (dp.includes('.')) {
+                paths.add(dp);
+            }
+        }
+    }
+    return [...paths];
+}
+//#endregion
+//#region ---- Related merge-detail paths ----
+function parseRelatedEntityFullName$1(fullName) {
+    const t = fullName.trim();
+    const idx = t.indexOf('.');
+    if (idx <= 0 || idx >= t.length - 1) {
+        return null;
+    }
+    return {
+        moduleName: t.slice(0, idx),
+        entityName: t.slice(idx + 1),
+    };
+}
+//#endregion
+//#region ---- Public API ----
+/**
+ * Collects lodash-get field paths used for mock/API quick search (`contains` / OR filters):
+ * host properties and lookup expose targets, dotted column paths, and merge-detail related entities
+ * prefixed with the related entity merge `persistence.dataPath` (e.g. `person.firstName`).
+ */
+async function collectEntityQuickSearchFieldPaths(entity, resolveRelatedDefinition) {
+    if (!entity) {
+        return [];
+    }
+    const paths = new Set();
+    for (const p of collectQuickSearchPathsFromSingleEntityDefinition(entity)) {
+        paths.add(p);
+    }
+    for (const p of collectNestedFieldPathsFromEntityColumns(entity)) {
+        paths.add(p);
+    }
+    const related = entity.relatedEntities ?? [];
+    for (const rel of related) {
+        const dataPath = rel.persistence?.dataPath?.trim();
+        if (!dataPath || rel.layout?.type !== 'merge-detail') {
+            continue;
+        }
+        const parsed = rel.entity ? parseRelatedEntityFullName$1(rel.entity) : null;
+        if (!parsed) {
+            continue;
+        }
+        const relatedDef = await resolveRelatedDefinition(parsed.moduleName, parsed.entityName);
+        if (!relatedDef) {
+            continue;
+        }
+        for (const p of collectQuickSearchPathsFromSingleEntityDefinition(relatedDef)) {
+            paths.add(`${dataPath}.${p}`);
+        }
+        for (const p of collectNestedFieldPathsFromEntityColumns(relatedDef)) {
+            paths.add(`${dataPath}.${p}`);
+        }
+    }
+    return [...paths];
+}
+//#endregion
+
+//#endregion
+//#region ---- Property filter helpers ----
+function isPropertyFilterEnabled(property) {
+    const filter = property.options?.filter;
+    return !!(filter?.advance?.enabled ||
+        filter?.inline?.enabled ||
+        filter?.preload?.enabled);
+}
+function parseRelatedEntityFullName(fullName) {
+    const trimmed = fullName.trim();
+    const idx = trimmed.indexOf('.');
+    if (idx <= 0 || idx >= trimmed.length - 1) {
+        return null;
+    }
+    return {
+        moduleName: trimmed.slice(0, idx),
+        entityName: trimmed.slice(idx + 1),
+    };
+}
+//#endregion
+//#region ---- Merge-detail property discovery ----
+/**
+ * Resolves related property names eligible for host list filters:
+ * host columns under `dataPath`, optional `related.properties` allowlist, minus `excludeProperties`.
+ */
+function collectMergeDetailFilterPropertyNames(hostEntity, dataPath, relatedEntity) {
+    const names = new Set();
+    const prefix = `${dataPath}.`;
+    if (relatedEntity.properties?.length) {
+        for (const name of relatedEntity.properties) {
+            const trimmed = name.trim();
+            if (trimmed) {
+                names.add(trimmed);
+            }
+        }
+    }
+    for (const column of hostEntity.columns ?? []) {
+        const columnName = column.name.trim();
+        if (columnName.startsWith(prefix)) {
+            const tail = columnName.slice(prefix.length);
+            const leaf = tail.split('.')[0]?.trim();
+            if (leaf) {
+                names.add(leaf);
+            }
+        }
+        const rawDataPath = column.options?.['dataPath'];
+        if (typeof rawDataPath === 'string') {
+            const dp = rawDataPath.trim();
+            if (dp.startsWith(prefix)) {
+                const tail = dp.slice(prefix.length);
+                const leaf = tail.split('.')[0]?.trim();
+                if (leaf) {
+                    names.add(leaf);
+                }
+            }
+        }
+    }
+    const excluded = new Set((relatedEntity.excludeProperties ?? []).map((n) => n.trim()).filter(Boolean));
+    for (const name of excluded) {
+        names.delete(name);
+    }
+    return names;
+}
+function resolveMergedRelatedInlineFilterField(dataPath, relatedEntityDef, property) {
+    const columnDataPath = resolveEntityColumnDataPath(relatedEntityDef, property.name);
+    if (columnDataPath) {
+        return `${dataPath}.${columnDataPath}`;
+    }
+    const exposeTarget = resolvePropertyExposeDisplayTarget(property.schema?.interface?.options);
+    if (exposeTarget) {
+        return `${dataPath}.${exposeTarget}`;
+    }
+    return undefined;
+}
+//#endregion
+//#region ---- Filter definition builder ----
+function buildFilterDefinitionFromProperty(hostEntity, property, options, deps) {
+    if (!isPropertyFilterEnabled(property)) {
+        return null;
+    }
+    const iface = property.schema.interface ?? {};
+    const interfaceType = iface.type;
+    const widgetConfig = interfaceType ? deps?.resolveWidget?.(interfaceType) : undefined;
+    const type = (property.options?.filter?.advance?.widgetType ||
+        widgetConfig?.defaultFilterWidgetName ||
+        interfaceType);
+    const inlineQueryField = options.inlineQueryField ??
+        resolveEntityPropertyInlineFilterField(hostEntity, property);
+    const preloadRequired = property.options?.filter?.preload?.required;
+    const validations = preloadRequired
+        ? [
+            {
+                rule: 'required',
+                message: 'This field is required',
+                options: {},
+            },
+        ]
+        : [];
+    const widgetOptions = {
+        ...(iface.options ?? {}),
+        ...(validations.length ? { validations } : {}),
+    };
+    const contextField = options.field.includes('.')
+        ? encodeEntityListFilterContextField(options.field)
+        : undefined;
+    return {
+        title: property.title,
+        field: options.field,
+        ...(contextField ? { contextField } : {}),
+        ...(inlineQueryField && inlineQueryField !== options.field ? { inlineQueryField } : {}),
+        operator: {
+            type: 'contains',
+        },
+        widget: {
+            ...omit(iface, 'triggers'),
+            path: contextField ?? options.field,
+            type,
+            options: widgetOptions,
+        },
+        filters: [],
+        isParametric: false,
+        icon: widgetConfig?.icon,
+        filterType: {
+            advance: property.options?.filter?.advance?.enabled ?? false,
+            inline: property.options?.filter?.inline?.enabled ?? false,
+            preload: property.options?.filter?.preload,
+        },
+        triggers: iface.triggers,
+    };
+}
+async function collectHostPropertyFilterDefinitions(entity, deps) {
+    const definitions = [];
+    for (const property of entity.properties ?? []) {
+        const definition = buildFilterDefinitionFromProperty(entity, property, { field: property.name }, deps);
+        if (definition) {
+            definitions.push(definition);
+        }
+    }
+    return definitions;
+}
+async function collectMergeDetailFilterDefinitions(hostEntity, resolveRelatedDefinition, deps) {
+    const definitions = [];
+    for (const related of hostEntity.relatedEntities ?? []) {
+        if (related.layout?.type !== 'merge-detail') {
+            continue;
+        }
+        if (related.filter?.enabled === false) {
+            continue;
+        }
+        const dataPath = related.persistence?.dataPath?.trim();
+        if (!dataPath) {
+            continue;
+        }
+        const parsed = related.entity ? parseRelatedEntityFullName(related.entity) : null;
+        if (!parsed) {
+            continue;
+        }
+        const relatedDef = await resolveRelatedDefinition(parsed.moduleName, parsed.entityName);
+        if (!relatedDef) {
+            continue;
+        }
+        const propertyNames = collectMergeDetailFilterPropertyNames(hostEntity, dataPath, related);
+        if (propertyNames.size === 0) {
+            continue;
+        }
+        for (const propertyName of propertyNames) {
+            const property = relatedDef.properties?.find((p) => p.name === propertyName);
+            if (!property) {
+                continue;
+            }
+            const queryField = `${dataPath}.${propertyName}`;
+            const inlineQueryField = resolveMergedRelatedInlineFilterField(dataPath, relatedDef, property);
+            const definition = buildFilterDefinitionFromProperty(hostEntity, property, {
+                field: queryField,
+                inlineQueryField,
+            }, deps);
+            if (definition) {
+                definitions.push(definition);
+            }
+        }
+    }
+    return definitions;
+}
+//#endregion
+//#region ---- Public API ----
+/**
+ * Builds master-list filter definitions from host properties and merge-detail related entities.
+ * Related filters use `{dataPath}.{property}` query fields (e.g. `person.firstName`).
+ */
+async function collectEntityListFilterDefinitions(entity, resolveRelatedDefinition, deps) {
+    if (!entity) {
+        return [];
+    }
+    const hostDefinitions = await collectHostPropertyFilterDefinitions(entity, deps);
+    const relatedDefinitions = await collectMergeDetailFilterDefinitions(entity, resolveRelatedDefinition, deps);
+    return [...hostDefinitions, ...relatedDefinitions];
+}
+//#endregion
+
+//#region ---- Workflow record helpers ----
+/** Entity query filter field for {@link AXPRecordWorkflowInfo.instanceId}. */
+const AXP_RECORD_WORKFLOW_INFO_INSTANCE_ID_FIELD = 'workflowInfo.instanceId';
+/** Entity query filter field for {@link AXPRecordWorkflowInfo.correlationId}. */
+const AXP_RECORD_WORKFLOW_INFO_CORRELATION_ID_FIELD = 'workflowInfo.correlationId';
+/** Entity query filter field for {@link AXPRecordWorkflowInfo.definitionId}. */
+const AXP_RECORD_WORKFLOW_INFO_DEFINITION_ID_FIELD = 'workflowInfo.definitionId';
+/** Returns a trimmed workflow instance id from a record, if present. */
+function getRecordWorkflowInstanceId(record) {
+    const id = record?.workflowInfo?.instanceId?.trim();
+    return id && id.length > 0 ? id : null;
+}
+/** Returns a trimmed workflow correlation id from a record, if present. */
+function getRecordWorkflowCorrelationId(record) {
+    const id = record?.workflowInfo?.correlationId?.trim();
+    return id && id.length > 0 ? id : null;
+}
+/** Builds canonical workflow metadata for a domain record (engine / middleware). */
+function buildAXPRecordWorkflowInfo(params) {
+    const instanceId = params.instanceId?.trim();
+    if (!instanceId) {
+        return {};
+    }
+    const definitionId = params.definitionId?.trim();
+    const correlationId = params.correlationId?.trim();
+    return {
+        instanceId,
+        ...(definitionId ? { definitionId } : { definitionId: null }),
+        ...(correlationId ? { correlationId } : { correlationId: null }),
+        ...(params.pinnedVersion != null ? { pinnedVersion: params.pinnedVersion } : {}),
+    };
+}
+//#endregion
+
+//#region ---- Utils barrel ----
+//#endregion
+
+//#region ---- Entity display constants ----
+/** Row path used when context carries a nested entity layout title. */
+const ENTITY_LAYOUT_SINGLE_TITLE_PATH = 'entity.layout.single.title';
+/** Widget option for a pre-evaluated or template entity row title (entity list column mappers). */
+const ENTITY_ROW_POPUP_TITLE_OPTION = 'popupTitle';
+/** Widget option alias for entity row title templates in view/edit forms. */
+const ENTITY_ROW_TITLE_TEMPLATE_OPTION = 'titleTemplate';
+//#endregion
+
+//#region ---- Entity datasource keys ----
+/** Platform entity layout datasource registry names. */
+const AXPEntityDataSourceKeys = {
+    Entities: 'entities',
+};
+//#endregion
+
+//#region ---- Entity events ----
+const AXPEntityEventsKeys = {
+    REFRESH_LAYOUT: 'entity:refresh-layout',
+    REFRESH_DATA: 'entity:refresh-data',
+};
+//#endregion
+
+//#region ---- Constants barrel ----
+//#endregion
+
+//#region ---- Barrel ----
+//#endregion
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXPEntityCommandScope, AXPEntityDataSourceKeys, AXPEntityEventsKeys, AXPEntityQueryType, AXPEntityType, AXPRelationshipCardinality, AXPRelationshipKind, AXP_RECORD_WORKFLOW_INFO_CORRELATION_ID_FIELD, AXP_RECORD_WORKFLOW_INFO_DEFINITION_ID_FIELD, AXP_RECORD_WORKFLOW_INFO_INSTANCE_ID_FIELD, ENTITY_LAYOUT_SINGLE_TITLE_PATH, ENTITY_ROW_POPUP_TITLE_OPTION, ENTITY_ROW_TITLE_TEMPLATE_OPTION, buildAXPRecordWorkflowInfo, buildEntitySearchTitleContext, collectEntityListFilterDefinitions, collectEntityQuickSearchFieldPaths, collectNestedCreateHiddenProperties, collectNestedFieldPathsFromEntityColumns, collectPropertyExposeTargetPaths, collectQuickSearchPathsFromSingleEntityDefinition, createAllQueryView, createQueryView, encodeEntityListFilterContextField, entityDetailsCreateActions, entityDetailsCreateActionsDeferredParent, entityDetailsCrudActions, entityDetailsEditAction, entityDetailsNewEditAction, entityDetailsReferenceCondition, entityDetailsReferenceCreateActions, entityDetailsSimpleCondition, entityMasterBulkDeleteAction, entityMasterCreateAction, entityMasterCrudActions, entityMasterDeleteAction, entityMasterEditAction, entityMasterRecordActions, entityMasterViewAction, entityOverrideDetailsViewAction, getEntityInfo, getRecordWorkflowCorrelationId, getRecordWorkflowInstanceId, isCardFieldBadgeDisplay, isMeaningfulEntityDisplayTitle, isRowBoundEntityDisplayTemplate, isUnresolvedEntityDisplayTemplate, mergeForeignKeyFieldIntoCreateActions, normalizeEntityDisplayTemplate, normalizeExpressionTemplate, parsePropertyExposeEntries, resolveCardFieldBadgeColor, resolveDefaultMasterListLayout, resolveEnabledMasterListLayouts, resolveEntityColumnDataPath, resolveEntityListFilterContextField, resolveEntityListFilterQueryField, resolveEntityModifyRecordTitleTemplate, resolveEntityPropertyInlineFilterField, resolveEntityRowTitleTemplate, resolvePropertyExposeDisplayTarget, sanitizeResolvedEntityDisplayTitle };
+//# sourceMappingURL=acorex-platform-layout-entity-contracts.mjs.map