@memberjunction/ng-base-forms 6.1.0-edge.1 → 6.1.0-edge.3

package/dist/lib/base-form-component.js

@@ -7,6 +7,8 @@ import { BaseRecordComponent } from './base-record-component';
 import { BaseFormSectionInfo } from './base-form-section-info';
 import { MjCollapsiblePanelComponent } from './panel/collapsible-panel.component';
 import { FormStateService } from './form-state.service';
+import { CollectFormPanelRegistrations } from './panel-slot/collect-form-panel-registrations';
+import { ContributionHiddenSectionKeys } from './panel-slot/form-contribution';
 import * as i0 from "@angular/core";
 /**
  * Abstract base class for all entity record forms in MemberJunction.
@@ -26,6 +28,7 @@ import * as i0 from "@angular/core";
  */
 export class BaseFormComponent extends BaseRecordComponent {
     EditMode = false;
+    IsRefreshing = false;
     FavoriteInitDone = false;
     /**
      * Per-instance presentation config (toolbar visibility, related-entity
@@ -90,6 +93,83 @@ export class BaseFormComponent extends BaseRecordComponent {
         // No-op — host application can override
     }
     _pendingRecords = [];
+    _registeredToolbarItems = new Map();
+    _toolbarItemOverrides = new Map();
+    /**
+     * Registers a dynamic toolbar action item / button.
+     * Can be called during ngOnInit or at runtime.
+     */
+    RegisterToolbarItem(item) {
+        this._registeredToolbarItems.set(item.Key, { ...item });
+        this.cdr?.markForCheck();
+    }
+    /**
+     * Unregisters a previously registered dynamic toolbar item by key.
+     */
+    UnregisterToolbarItem(key) {
+        if (this._registeredToolbarItems.delete(key)) {
+            this.cdr?.markForCheck();
+        }
+    }
+    /**
+     * Configures overrides for any toolbar item (standard built-in items like 'edit',
+     * 'delete', 'favorite', 'history', etc., or custom items).
+     * Allows dynamically changing visibility, disabled state, tooltips, order, icon, etc.
+     */
+    ConfigureToolbarItem(key, overrides) {
+        const existing = this._toolbarItemOverrides.get(key) || {};
+        this._toolbarItemOverrides.set(key, { ...existing, ...overrides });
+        this.cdr?.markForCheck();
+    }
+    /**
+     * Dynamically hides a toolbar item by key.
+     */
+    HideToolbarItem(key) {
+        this.ConfigureToolbarItem(key, { Visible: false });
+    }
+    /**
+     * Dynamically shows a toolbar item by key.
+     */
+    ShowToolbarItem(key) {
+        this.ConfigureToolbarItem(key, { Visible: true });
+    }
+    /**
+     * Dynamically disables a toolbar item by key, with an optional reason string for the tooltip.
+     */
+    DisableToolbarItem(key, reason) {
+        this.ConfigureToolbarItem(key, { Disabled: reason ?? true });
+    }
+    /**
+     * Dynamically enables a toolbar item by key.
+     */
+    EnableToolbarItem(key) {
+        this.ConfigureToolbarItem(key, { Disabled: false });
+    }
+    /**
+     * Sets the numeric display order for a toolbar item (lower numbers appear earlier).
+     */
+    SetToolbarItemOrder(key, order) {
+        this.ConfigureToolbarItem(key, { Order: order });
+    }
+    /**
+     * Returns all dynamically registered toolbar items.
+     */
+    get RegisteredToolbarItems() {
+        return Array.from(this._registeredToolbarItems.values());
+    }
+    /**
+     * Returns the map of toolbar item overrides.
+     */
+    get ToolbarItemOverrides() {
+        return this._toolbarItemOverrides;
+    }
+    /**
+     * Hook invoked when a custom or dynamic toolbar item is clicked.
+     * Subclasses can override this method to handle custom button clicks.
+     */
+    OnCustomToolbarButtonClick(event) {
+        // Subclasses can override
+    }
     // #region Injected Dependencies (no constructor params)
     elementRef = inject(ElementRef);
     cdr = inject(ChangeDetectorRef);
@@ -102,6 +182,8 @@ export class BaseFormComponent extends BaseRecordComponent {
     Notification = new EventEmitter();
     /** Emitted after a record is saved successfully */
     RecordSaved = new EventEmitter();
+    /** Emitted after a record is refreshed from the database successfully */
+    RecordRefreshed = new EventEmitter();
     /** Emitted after a record is deleted successfully */
     RecordDeleted = new EventEmitter();
     /** Emitted when a record save fails */
@@ -171,6 +253,20 @@ export class BaseFormComponent extends BaseRecordComponent {
     get PendingRecords() {
         return this._pendingRecords;
     }
+    /**
+     * Unsaved changes a form holds OUTSIDE its record's fields and pending records.
+     *
+     * A form whose sections own editors — a flow canvas, a designer, a grid — accumulates edits that
+     * neither `record.Dirty` nor `PendingRecordsDirty()` can see, because nothing on the entity
+     * changed. Without this the toolbar reports "no changes" while the user is looking at their own
+     * work, and the navigate-away guard lets them lose it silently.
+     *
+     * Default `false`, so no existing form changes behaviour. Override to consult whatever holds the
+     * extra state.
+     */
+    get HasAdditionalUnsavedChanges() {
+        return false;
+    }
     PendingRecordsDirty() {
         this.PopulatePendingRecords();
         const pendingRecords = this.PendingRecords;
@@ -340,6 +436,77 @@ export class BaseFormComponent extends BaseRecordComponent {
             }
         }
     }
+    /**
+     * Re-fetches the current record from the database, updating field values
+     * in-place and resetting dirty flags. No-op in edit mode or on an unsaved
+     * record. Related-entity grids are notified via the form container's
+     * {@link FormRecordRefreshCoordinator} after this emits {@link RecordRefreshed}.
+     *
+     * @returns true if the record was reloaded from the database.
+     */
+    async RefreshRecord() {
+        if (!this.canRefreshRecord()) {
+            return false;
+        }
+        this.IsRefreshing = true;
+        this.cdr.markForCheck();
+        try {
+            return await this.executeRecordRefresh();
+        }
+        finally {
+            this.IsRefreshing = false;
+            this.cdr.markForCheck();
+        }
+    }
+    canRefreshRecord() {
+        return !!this.record && this.record.IsSaved && !this.EditMode;
+    }
+    async executeRecordRefresh() {
+        const record = this.record;
+        if (!record) {
+            return false;
+        }
+        try {
+            const ok = await record.Refresh();
+            if (!ok) {
+                this.Notification.emit({
+                    Message: 'Failed to refresh record from database',
+                    Type: 'error',
+                    Duration: 5000,
+                });
+                return false;
+            }
+            await this.reloadFavoriteStatusAfterRefresh(record);
+            this.Notification.emit({
+                Message: 'Record refreshed from database',
+                Type: 'info',
+                Duration: 2000,
+            });
+            this.RecordRefreshed.emit({
+                EntityName: record.EntityInfo.Name,
+                Record: record,
+            });
+            return true;
+        }
+        catch (e) {
+            const detail = e instanceof Error ? e.message : String(e);
+            this.Notification.emit({
+                Message: 'Error refreshing record: ' + detail,
+                Type: 'error',
+                Duration: 5000,
+            });
+            return false;
+        }
+    }
+    async reloadFavoriteStatusAfterRefresh(record) {
+        const md = this.ProviderToUse;
+        try {
+            this._isFavorite = await md.GetRecordFavoriteStatus(md.CurrentUser.ID, record.EntityInfo.Name, record.PrimaryKey);
+        }
+        catch {
+            // Non-critical — favorite status remains as is
+        }
+    }
     async InternalSaveRecord() {
         if (this.record) {
             if (this._pendingRecords.length > 0) {
@@ -439,6 +606,14 @@ export class BaseFormComponent extends BaseRecordComponent {
         else
             return {};
     }
+    /**
+     * One grid over several FKs to the same related entity (Bill-To OR Ship-To).
+     */
+    BuildRelationshipViewParamsForJoinFields(relatedEntityName, joinFields) {
+        if (!this.record)
+            return {};
+        return EntityInfo.BuildRelationshipViewParamsForJoinFields(this.record, relatedEntityName, joinFields);
+    }
     GetEntityRelationshipByRelatedEntityName(relatedEntityName, relatedEntityJoinField) {
         if (this.record) {
             const r = this.record;
@@ -457,12 +632,36 @@ export class BaseFormComponent extends BaseRecordComponent {
         }
         return undefined;
     }
-    NewRecordValues(relatedEntityName) {
-        const eri = this.GetEntityRelationshipByRelatedEntityName(relatedEntityName);
-        if (eri)
-            return this.NewRecordValuesByEntityRelationship(eri);
-        else
+    /**
+     * Default values for a new related-entity record so it links back here.
+     * Pass `relatedEntityJoinField` when more than one relationship targets the
+     * same entity (Bill-To vs Ship-To). When omitted and several matches exist,
+     * every matching FK is set — same fields the related grid is filtering on.
+     */
+    NewRecordValues(relatedEntityName, relatedEntityJoinField) {
+        if (!this.record)
+            return {};
+        if (relatedEntityJoinField) {
+            const eri = this.GetEntityRelationshipByRelatedEntityName(relatedEntityName, relatedEntityJoinField);
+            if (eri)
+                return this.NewRecordValuesByEntityRelationship(eri);
+            return EntityInfo.BuildRelationshipNewRecordValuesForJoinFields(this.record, [relatedEntityJoinField]);
+        }
+        const matches = this.record.EntityInfo.RelatedEntities.filter((x) => x.RelatedEntity.trim().toLowerCase() === relatedEntityName.trim().toLowerCase());
+        if (matches.length === 0)
             return {};
+        if (matches.length === 1)
+            return this.NewRecordValuesByEntityRelationship(matches[0]);
+        return EntityInfo.BuildRelationshipNewRecordValuesForJoinFields(this.record, matches.map((m) => m.RelatedEntityJoinField));
+    }
+    /**
+     * Default values for a new related record, setting every listed join field
+     * to this record's key. Pair with {@link BuildRelationshipViewParamsForJoinFields}.
+     */
+    NewRecordValuesForJoinFields(relatedEntityName, joinFields) {
+        if (!this.record || !relatedEntityName)
+            return {};
+        return EntityInfo.BuildRelationshipNewRecordValuesForJoinFields(this.record, joinFields);
     }
     NewRecordValuesByEntityRelationship(item) {
         return EntityInfo.BuildRelationshipNewRecordValues(this.record, item);
@@ -607,11 +806,28 @@ export class BaseFormComponent extends BaseRecordComponent {
             collapsibleSections: this.Config?.CollapsibleSections,
             enableRecordLinks: this.Config?.EnableRecordLinks,
             showRelatedEntities: this.Config?.ShowRelatedEntities,
-            hiddenSectionKeys: this.Config?.HiddenSectionKeys,
+            hiddenSectionKeys: this.resolveHiddenSectionKeys(),
             visibleSectionKeys: this.Config?.VisibleSectionKeys,
             allowSectionReorder: this.resolveAllowSectionReorder()
         };
     }
+    /**
+     * Config HiddenSectionKeys plus section keys winning contributions asked
+     * to hide (related-entity claims and `replacesSectionKey` field panels).
+     */
+    resolveHiddenSectionKeys() {
+        const claimed = this.contributionHiddenSectionKeys();
+        const configured = this.Config?.HiddenSectionKeys;
+        if (claimed.length === 0)
+            return configured;
+        return [...(configured ?? []), ...claimed];
+    }
+    contributionHiddenSectionKeys() {
+        const entity = this.record?.EntityInfo;
+        if (!entity)
+            return [];
+        return ContributionHiddenSectionKeys(entity.Name, entity.RelatedEntities, entity.ChildEntities.map((child) => child.ID), CollectFormPanelRegistrations());
+    }
     /**
      * Resolves whether section drag-reorder is allowed for the current Config.
      * When no toolbar is rendered (dialog/slide-in, `Config.Toolbar === null`)
@@ -680,10 +896,19 @@ export class BaseFormComponent extends BaseRecordComponent {
         return section?.rowCount;
     }
     SetSectionRowCount(sectionKey, rowCount) {
-        const section = this.sectionMap.get(sectionKey);
-        if (section) {
+        let section = this.sectionMap.get(sectionKey);
+        if (!section) {
+            // Contribution panels use their own SectionKey (e.g. 'orders') which
+            // is never seeded by generated initSections(). Upsert so the left-nav
+            // rail badge can read the count the same way baked grids do.
+            section = new BaseFormSectionInfo(sectionKey, sectionKey, false, rowCount);
+            this.sections.push(section);
+            this.sectionMap.set(sectionKey, section);
+        }
+        else {
             section.rowCount = rowCount;
         }
+        this.cdr.markForCheck();
     }
     GetSectionPanelHeight(sectionKey) {
         const entityName = this.getEntityName();
@@ -828,6 +1053,24 @@ export class BaseFormComponent extends BaseRecordComponent {
         }
         return false;
     }
+    getMoreSectionKeys() {
+        const entityName = this.getEntityName();
+        if (!entityName)
+            return [];
+        return this.formStateService.getMoreSectionKeys(entityName) ?? [];
+    }
+    getFirstClassSectionKeys() {
+        const entityName = this.getEntityName();
+        if (!entityName)
+            return [];
+        return this.formStateService.getFirstClassSectionKeys(entityName) ?? [];
+    }
+    setChromeMembership(moreSectionKeys, firstClassSectionKeys) {
+        const entityName = this.getEntityName();
+        if (entityName) {
+            this.formStateService.setChromeMembership(entityName, moreSectionKeys, firstClassSectionKeys);
+        }
+    }
     getSectionDisplayOrder(sectionKey) {
         const order = this.getSectionOrder();
         const index = order.indexOf(sectionKey);
@@ -900,7 +1143,7 @@ export class BaseFormComponent extends BaseRecordComponent {
         } if (rf & 2) {
             let _t;
             i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.collapsiblePanels = _t);
-        } }, outputs: { Navigate: "Navigate", Notification: "Notification", RecordSaved: "RecordSaved", RecordDeleted: "RecordDeleted", RecordSaveFailed: "RecordSaveFailed", RecordDeleteFailed: "RecordDeleteFailed", ValidationFailed: "ValidationFailed", RecordReady: "RecordReady" }, features: [i0.ɵɵInheritDefinitionFeature] });
+        } }, outputs: { Navigate: "Navigate", Notification: "Notification", RecordSaved: "RecordSaved", RecordRefreshed: "RecordRefreshed", RecordDeleted: "RecordDeleted", RecordSaveFailed: "RecordSaveFailed", RecordDeleteFailed: "RecordDeleteFailed", ValidationFailed: "ValidationFailed", RecordReady: "RecordReady" }, features: [i0.ɵɵInheritDefinitionFeature] });
 }
 (() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(BaseFormComponent, [{
         type: Directive
@@ -910,6 +1153,8 @@ export class BaseFormComponent extends BaseRecordComponent {
             type: Output
         }], RecordSaved: [{
             type: Output
+        }], RecordRefreshed: [{
+            type: Output
         }], RecordDeleted: [{
             type: Output
         }], RecordSaveFailed: [{