@memberjunction/ng-base-forms 5.36.0 → 5.38.0

package/dist/lib/panel-slot/base-form-panel.d.ts

@@ -0,0 +1,97 @@
+import { BaseEntity, ValidationResult } from '@memberjunction/core';
+import { BaseFormComponent } from '../base-form-component';
+import { FormContext } from '../types/form-types';
+import * as i0 from "@angular/core";
+/**
+ * Well-known slot positions where panels can be injected into a generated
+ * entity form. Used as the `slot` field in a panel's registration metadata.
+ *
+ * Slot positions inside the form, top to bottom:
+ *
+ *   ┌─ <mj-record-form-container>
+ *   │     [top-area slot]            ← CodeGen-emitted; rare (entities with top-area section)
+ *   │     [before-fields slot]       ← CodeGen-emitted; banners / warnings above field panels
+ *   │     <connection details>
+ *   │     <other generated field panels>
+ *   │     [after-fields slot]        ← CodeGen-emitted; typed config knobs, secondary settings — most common slot
+ *   │     <content items grid>
+ *   │     <other related-entity grids>
+ *   │     [after-related slot]       ← CodeGen-emitted; bottom-of-form addenda
+ *   │     [after-everything slot]    ← Container-emitted; ALWAYS present (fallback target)
+ *   └─ </mj-record-form-container>
+ *
+ * Pick the slot that matches the panel's role. `after-fields` is the default
+ * for most "additional settings" panels — it sits in the field column, before
+ * the related-entity grids.
+ *
+ * **Fallback behavior** — see `FormSlotCoordinator`. If the registered slot is
+ * missing in the current form (CodeGen hasn't been rerun against the new
+ * template emitter), the panel walks forward in the chain until it finds an
+ * existing slot. `after-everything` is always emitted by the container, so
+ * fallback never dead-ends. Pre-CodeGen-regen forms show every panel at the
+ * bottom of the form; post-regen forms show them in the preferred position.
+ */
+export type FormPanelSlot = 'top-area' | 'before-fields' | 'after-fields' | 'after-related' | 'after-everything';
+/**
+ * Shape of the `metadata` object every BaseFormPanel registration MUST attach
+ * via `@RegisterClass(BaseFormPanel, { metadata: {...} })`. The
+ * `<mj-form-panel-slot>` host filters registrations by matching against this
+ * shape — registrations without it are silently ignored.
+ *
+ *   - `entity` — the `MJContentSourceEntity_IContentSourceConfiguration`-style
+ *                entity name. Must match the entity-form's record entity exactly
+ *                (case-sensitive trim-equality enforced by the slot host).
+ *   - `slot`   — which slot the panel renders into.
+ *   - `sortKey`— higher = earlier within the slot. Defaults to 0 if omitted.
+ *                Use ranges (e.g., 100/50/10) so future panels can wedge in
+ *                without recomputing every neighbor's sort.
+ */
+export interface FormPanelRegistrationMetadata extends Record<string, unknown> {
+    entity: string;
+    slot: FormPanelSlot;
+    sortKey?: number;
+}
+/**
+ * Abstract base for every dynamically-injectable form panel.
+ *
+ * Subclasses are standalone Angular components decorated with
+ * `@RegisterClass(BaseFormPanel, { metadata: { entity, slot, sortKey? } })`.
+ * At runtime, `<mj-form-panel-slot>` discovers matching registrations via
+ * `ClassFactory.GetAllRegistrationsByMetadata`, instantiates each via
+ * `ViewContainerRef.createComponent`, and wires `Record` + `FormComponent` +
+ * `FormContext` into the inputs.
+ *
+ * Lifecycle hooks: standard Angular `ngOnInit` / `ngOnDestroy` work as usual.
+ * `Record` is guaranteed to be set before the first change-detection pass.
+ *
+ * Optional `validate()` returns a synchronous validation result; the parent
+ * `BaseFormComponent.Save()` path will surface it via the existing validation
+ * pipeline when called. Panels that don't validate anything beyond what the
+ * record itself does can leave this method off.
+ */
+export declare abstract class BaseFormPanel<TRecord extends BaseEntity = BaseEntity> {
+    /** The entity record being edited. Set by the slot host before view init. */
+    Record: TRecord;
+    /** The host form component (use for EditMode, dirty notifications, etc). Set by the slot host. */
+    FormComponent: BaseFormComponent;
+    /** Optional form context — same shape the collapsible-panel chrome expects. Set by the slot host. */
+    FormContext?: FormContext;
+    /**
+     * Convenience getter for read-only / edit-mode rendering. Falls back to
+     * `false` when the panel is shown outside a `BaseFormComponent` host (e.g.,
+     * a dashboard quick-edit dialog reusing the same panel — see the
+     * "composable panel" docs).
+     */
+    get EditMode(): boolean;
+    /**
+     * Override to add per-panel validation that should block the parent form's
+     * Save(). Return `{ Success: true, Errors: [] }` when valid, or include
+     * `ValidationErrorInfo` entries to surface field-level errors. The default
+     * implementation reports valid (panels that don't need extra validation
+     * can leave this method off).
+     */
+    validate(): ValidationResult;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseFormPanel<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseFormPanel<any>, never, never, { "Record": { "alias": "Record"; "required": false; }; "FormComponent": { "alias": "FormComponent"; "required": false; }; "FormContext": { "alias": "FormContext"; "required": false; }; }, {}, never, never, true, never>;
+}
+//# sourceMappingURL=base-form-panel.d.ts.map

package/dist/lib/panel-slot/base-form-panel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-form-panel.d.ts","sourceRoot":"","sources":["../../../src/lib/panel-slot/base-form-panel.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,MAAM,aAAa,GACnB,UAAU,GACV,eAAe,GACf,cAAc,GACd,eAAe,GACf,kBAAkB,CAAC;AAEzB;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,6BAA8B,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC1E,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,aAAa,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,8BACsB,aAAa,CAAC,OAAO,SAAS,UAAU,GAAG,UAAU;IACvE,6EAA6E;IACpE,MAAM,EAAG,OAAO,CAAC;IAC1B,kGAAkG;IACzF,aAAa,EAAG,iBAAiB,CAAC;IAC3C,qGAAqG;IAC5F,WAAW,CAAC,EAAE,WAAW,CAAC;IAEnC;;;;;OAKG;IACH,IAAW,QAAQ,IAAI,OAAO,CAE7B;IAED;;;;;;OAMG;IACI,QAAQ,IAAI,gBAAgB;yCAzBjB,aAAa;2CAAb,aAAa;CAgClC"}

package/dist/lib/panel-slot/base-form-panel.js

@@ -0,0 +1,64 @@
+import { Directive, Input } from '@angular/core';
+import { ValidationResult } from '@memberjunction/core';
+import * as i0 from "@angular/core";
+/**
+ * Abstract base for every dynamically-injectable form panel.
+ *
+ * Subclasses are standalone Angular components decorated with
+ * `@RegisterClass(BaseFormPanel, { metadata: { entity, slot, sortKey? } })`.
+ * At runtime, `<mj-form-panel-slot>` discovers matching registrations via
+ * `ClassFactory.GetAllRegistrationsByMetadata`, instantiates each via
+ * `ViewContainerRef.createComponent`, and wires `Record` + `FormComponent` +
+ * `FormContext` into the inputs.
+ *
+ * Lifecycle hooks: standard Angular `ngOnInit` / `ngOnDestroy` work as usual.
+ * `Record` is guaranteed to be set before the first change-detection pass.
+ *
+ * Optional `validate()` returns a synchronous validation result; the parent
+ * `BaseFormComponent.Save()` path will surface it via the existing validation
+ * pipeline when called. Panels that don't validate anything beyond what the
+ * record itself does can leave this method off.
+ */
+export class BaseFormPanel {
+    /** The entity record being edited. Set by the slot host before view init. */
+    Record;
+    /** The host form component (use for EditMode, dirty notifications, etc). Set by the slot host. */
+    FormComponent;
+    /** Optional form context — same shape the collapsible-panel chrome expects. Set by the slot host. */
+    FormContext;
+    /**
+     * Convenience getter for read-only / edit-mode rendering. Falls back to
+     * `false` when the panel is shown outside a `BaseFormComponent` host (e.g.,
+     * a dashboard quick-edit dialog reusing the same panel — see the
+     * "composable panel" docs).
+     */
+    get EditMode() {
+        return this.FormComponent?.EditMode ?? false;
+    }
+    /**
+     * Override to add per-panel validation that should block the parent form's
+     * Save(). Return `{ Success: true, Errors: [] }` when valid, or include
+     * `ValidationErrorInfo` entries to surface field-level errors. The default
+     * implementation reports valid (panels that don't need extra validation
+     * can leave this method off).
+     */
+    validate() {
+        // Inline construction — ValidationResult is a class in @memberjunction/core,
+        // not a plain interface, so callers can construct via `new`.
+        const result = new ValidationResult();
+        result.Success = true;
+        return result;
+    }
+    static ɵfac = function BaseFormPanel_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || BaseFormPanel)(); };
+    static ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: BaseFormPanel, inputs: { Record: "Record", FormComponent: "FormComponent", FormContext: "FormContext" } });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(BaseFormPanel, [{
+        type: Directive
+    }], null, { Record: [{
+            type: Input
+        }], FormComponent: [{
+            type: Input
+        }], FormContext: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=base-form-panel.js.map

package/dist/lib/panel-slot/base-form-panel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-form-panel.js","sourceRoot":"","sources":["../../../src/lib/panel-slot/base-form-panel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAc,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;;AA4DpE;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,OAAgB,aAAa;IAC/B,6EAA6E;IACpE,MAAM,CAAW;IAC1B,kGAAkG;IACzF,aAAa,CAAqB;IAC3C,qGAAqG;IAC5F,WAAW,CAAe;IAEnC;;;;;OAKG;IACH,IAAW,QAAQ;QACf,OAAO,IAAI,CAAC,aAAa,EAAE,QAAQ,IAAI,KAAK,CAAC;IACjD,CAAC;IAED;;;;;;OAMG;IACI,QAAQ;QACX,6EAA6E;QAC7E,6DAA6D;QAC7D,MAAM,MAAM,GAAG,IAAI,gBAAgB,EAAE,CAAC;QACtC,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC;QACtB,OAAO,MAAM,CAAC;IAClB,CAAC;uGA/BiB,aAAa;6DAAb,aAAa;;iFAAb,aAAa;cADlC,SAAS;;kBAGL,KAAK;;kBAEL,KAAK;;kBAEL,KAAK","sourcesContent":["import { Directive, Input } from '@angular/core';\nimport { BaseEntity, ValidationResult } from '@memberjunction/core';\nimport { BaseFormComponent } from '../base-form-component';\nimport { FormContext } from '../types/form-types';\n\n/**\n * Well-known slot positions where panels can be injected into a generated\n * entity form. Used as the `slot` field in a panel's registration metadata.\n *\n * Slot positions inside the form, top to bottom:\n *\n *   ┌─ <mj-record-form-container>\n *   │     [top-area slot]            ← CodeGen-emitted; rare (entities with top-area section)\n *   │     [before-fields slot]       ← CodeGen-emitted; banners / warnings above field panels\n *   │     <connection details>\n *   │     <other generated field panels>\n *   │     [after-fields slot]        ← CodeGen-emitted; typed config knobs, secondary settings — most common slot\n *   │     <content items grid>\n *   │     <other related-entity grids>\n *   │     [after-related slot]       ← CodeGen-emitted; bottom-of-form addenda\n *   │     [after-everything slot]    ← Container-emitted; ALWAYS present (fallback target)\n *   └─ </mj-record-form-container>\n *\n * Pick the slot that matches the panel's role. `after-fields` is the default\n * for most \"additional settings\" panels — it sits in the field column, before\n * the related-entity grids.\n *\n * **Fallback behavior** — see `FormSlotCoordinator`. If the registered slot is\n * missing in the current form (CodeGen hasn't been rerun against the new\n * template emitter), the panel walks forward in the chain until it finds an\n * existing slot. `after-everything` is always emitted by the container, so\n * fallback never dead-ends. Pre-CodeGen-regen forms show every panel at the\n * bottom of the form; post-regen forms show them in the preferred position.\n */\nexport type FormPanelSlot =\n    | 'top-area'\n    | 'before-fields'\n    | 'after-fields'\n    | 'after-related'\n    | 'after-everything';\n\n/**\n * Shape of the `metadata` object every BaseFormPanel registration MUST attach\n * via `@RegisterClass(BaseFormPanel, { metadata: {...} })`. The\n * `<mj-form-panel-slot>` host filters registrations by matching against this\n * shape — registrations without it are silently ignored.\n *\n *   - `entity` — the `MJContentSourceEntity_IContentSourceConfiguration`-style\n *                entity name. Must match the entity-form's record entity exactly\n *                (case-sensitive trim-equality enforced by the slot host).\n *   - `slot`   — which slot the panel renders into.\n *   - `sortKey`— higher = earlier within the slot. Defaults to 0 if omitted.\n *                Use ranges (e.g., 100/50/10) so future panels can wedge in\n *                without recomputing every neighbor's sort.\n */\nexport interface FormPanelRegistrationMetadata extends Record<string, unknown> {\n    entity: string;\n    slot: FormPanelSlot;\n    sortKey?: number;\n}\n\n/**\n * Abstract base for every dynamically-injectable form panel.\n *\n * Subclasses are standalone Angular components decorated with\n * `@RegisterClass(BaseFormPanel, { metadata: { entity, slot, sortKey? } })`.\n * At runtime, `<mj-form-panel-slot>` discovers matching registrations via\n * `ClassFactory.GetAllRegistrationsByMetadata`, instantiates each via\n * `ViewContainerRef.createComponent`, and wires `Record` + `FormComponent` +\n * `FormContext` into the inputs.\n *\n * Lifecycle hooks: standard Angular `ngOnInit` / `ngOnDestroy` work as usual.\n * `Record` is guaranteed to be set before the first change-detection pass.\n *\n * Optional `validate()` returns a synchronous validation result; the parent\n * `BaseFormComponent.Save()` path will surface it via the existing validation\n * pipeline when called. Panels that don't validate anything beyond what the\n * record itself does can leave this method off.\n */\n@Directive()\nexport abstract class BaseFormPanel<TRecord extends BaseEntity = BaseEntity> {\n    /** The entity record being edited. Set by the slot host before view init. */\n    @Input() Record!: TRecord;\n    /** The host form component (use for EditMode, dirty notifications, etc). Set by the slot host. */\n    @Input() FormComponent!: BaseFormComponent;\n    /** Optional form context — same shape the collapsible-panel chrome expects. Set by the slot host. */\n    @Input() FormContext?: FormContext;\n\n    /**\n     * Convenience getter for read-only / edit-mode rendering. Falls back to\n     * `false` when the panel is shown outside a `BaseFormComponent` host (e.g.,\n     * a dashboard quick-edit dialog reusing the same panel — see the\n     * \"composable panel\" docs).\n     */\n    public get EditMode(): boolean {\n        return this.FormComponent?.EditMode ?? false;\n    }\n\n    /**\n     * Override to add per-panel validation that should block the parent form's\n     * Save(). Return `{ Success: true, Errors: [] }` when valid, or include\n     * `ValidationErrorInfo` entries to surface field-level errors. The default\n     * implementation reports valid (panels that don't need extra validation\n     * can leave this method off).\n     */\n    public validate(): ValidationResult {\n        // Inline construction — ValidationResult is a class in @memberjunction/core,\n        // not a plain interface, so callers can construct via `new`.\n        const result = new ValidationResult();\n        result.Success = true;\n        return result;\n    }\n}\n"]}

package/dist/lib/panel-slot/form-panel-slot.component.d.ts

@@ -0,0 +1,78 @@
+import { OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
+import { BaseEntity } from '@memberjunction/core';
+import { BaseFormComponent } from '../base-form-component';
+import { FormContext } from '../types/form-types';
+import { FormPanelSlot } from './base-form-panel';
+import { FormSlotCoordinator } from './form-slot-coordinator.service';
+import * as i0 from "@angular/core";
+/**
+ * `<mj-form-panel-slot>` — dynamic slot host that discovers and mounts every
+ * registered `BaseFormPanel` whose metadata matches the slot's `Entity` +
+ * `Slot` inputs. Generated entity-form HTML emits one of these at each
+ * well-known slot position so consumers can extend the form WITHOUT replacing
+ * it via the custom-form override pattern.
+ *
+ * **Discovery**: uses `ClassFactory.GetAllRegistrationsByMetadata(BaseFormPanel, ...)`
+ * to find every panel registered with metadata `{ entity, slot }` matching this
+ * slot. Registrations without a metadata bag (or without these required keys)
+ * are silently ignored so legacy registrations don't accidentally bind.
+ *
+ * **Ordering**: registrations are sorted by `metadata.sortKey` descending —
+ * higher number renders first within the slot. Use ranges (100/50/10) so future
+ * panels can wedge in without renumbering. Ties fall back to the
+ * `ClassRegistration.Priority` field (also descending), and finally to
+ * registration order.
+ *
+ * **Fallback chain** (see `FormSlotCoordinator`): each slot host registers
+ * with the per-form coordinator and additionally renders panels whose
+ * REGISTERED slot is missing in the current form, when this host happens to
+ * be the next-existing slot down the chain. The container template guarantees
+ * an `after-everything` slot host, so fallback always terminates somewhere.
+ * Downstream consumers running an older form template (no CodeGen rerun
+ * yet) get every panel rendered at the bottom; consumers on the new template
+ * get them in the preferred position.
+ *
+ * **Re-mount**: any input change OR a coordinator change (another slot
+ * registers/deregisters) triggers a re-render so fallback assignments stay
+ * correct as slots come and go.
+ */
+export declare class FormPanelSlotComponent implements OnInit, OnChanges, OnDestroy {
+    private readonly coordinator?;
+    /** The entity name (e.g., `"MJ: Content Sources"`) being edited. */
+    Entity: string;
+    /** Which slot position this host represents. */
+    Slot: FormPanelSlot;
+    /** The record being edited — threaded through to every mounted panel. */
+    Record: BaseEntity;
+    /** The host form component — used by panels for EditMode + dirty notifications. */
+    FormComponent: BaseFormComponent;
+    /** Optional form context — same shape collapsible-panel chrome expects. */
+    FormContext?: FormContext;
+    private anchor;
+    private mounted;
+    private readonly destroy$;
+    private registeredSlot;
+    /** Tracks synchronous re-entry depth into remount() so a future refactor
+     *  that reintroduces a remount loop surfaces loudly instead of freezing. */
+    private remountDepth;
+    constructor(coordinator?: FormSlotCoordinator | undefined);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private remount;
+    /** Find registrations whose metadata declares this exact entity + slot. */
+    private findRegistrations;
+    /**
+     * Find panels registered for a different slot that should mount HERE
+     * because their preferred slot isn't present and this slot is the next
+     * existing one in the fallback chain.
+     *
+     * Only meaningful when we have a coordinator (i.e., we're inside an
+     * `<mj-record-form-container>`).
+     */
+    private findOrphans;
+    private unmountAll;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormPanelSlotComponent, [{ optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormPanelSlotComponent, "mj-form-panel-slot", never, { "Entity": { "alias": "Entity"; "required": false; }; "Slot": { "alias": "Slot"; "required": false; }; "Record": { "alias": "Record"; "required": false; }; "FormComponent": { "alias": "FormComponent"; "required": false; }; "FormContext": { "alias": "FormContext"; "required": false; }; }, {}, never, never, false, never>;
+}
+//# sourceMappingURL=form-panel-slot.component.d.ts.map

package/dist/lib/panel-slot/form-panel-slot.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"form-panel-slot.component.d.ts","sourceRoot":"","sources":["../../../src/lib/panel-slot/form-panel-slot.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAIH,SAAS,EACT,SAAS,EACT,MAAM,EAEN,aAAa,EAIhB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,UAAU,EAAY,MAAM,sBAAsB,CAAC;AAE5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAgD,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAChG,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBAWa,sBAAuB,YAAW,MAAM,EAAE,SAAS,EAAE,SAAS;IAsB/C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC;IArBrD,oEAAoE;IAC3D,MAAM,EAAG,MAAM,CAAC;IACzB,gDAAgD;IACvC,IAAI,EAAG,aAAa,CAAC;IAC9B,yEAAyE;IAChE,MAAM,EAAG,UAAU,CAAC;IAC7B,mFAAmF;IAC1E,aAAa,EAAG,iBAAiB,CAAC;IAC3C,2EAA2E;IAClE,WAAW,CAAC,EAAE,WAAW,CAAC;IAGnC,OAAO,CAAC,MAAM,CAAoB;IAElC,OAAO,CAAC,OAAO,CAAqC;IACpD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAuB;IAChD,OAAO,CAAC,cAAc,CAA8B;IACpD;gFAC4E;IAC5E,OAAO,CAAC,YAAY,CAAK;gBAEgB,WAAW,CAAC,EAAE,mBAAmB,YAAA;IAE1E,QAAQ,IAAI,IAAI;IAahB,WAAW,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;IA4BzC,WAAW,IAAI,IAAI;IAUnB,OAAO,CAAC,OAAO;IAqDf,2EAA2E;IAC3E,OAAO,CAAC,iBAAiB;IAWzB;;;;;;;OAOG;IACH,OAAO,CAAC,WAAW;IAoBnB,OAAO,CAAC,UAAU;yCAxKT,sBAAsB;2CAAtB,sBAAsB;CA4KlC"}

package/dist/lib/panel-slot/form-panel-slot.component.js

@@ -0,0 +1,227 @@
+import { Component, Input, Optional, ViewChild, ViewContainerRef, } from '@angular/core';
+import { Subject, takeUntil } from 'rxjs';
+import { LogError } from '@memberjunction/core';
+import { MJGlobal } from '@memberjunction/global';
+import { BaseFormPanel } from './base-form-panel';
+import * as i0 from "@angular/core";
+import * as i1 from "./form-slot-coordinator.service";
+const _c0 = ["anchor"];
+/**
+ * `<mj-form-panel-slot>` — dynamic slot host that discovers and mounts every
+ * registered `BaseFormPanel` whose metadata matches the slot's `Entity` +
+ * `Slot` inputs. Generated entity-form HTML emits one of these at each
+ * well-known slot position so consumers can extend the form WITHOUT replacing
+ * it via the custom-form override pattern.
+ *
+ * **Discovery**: uses `ClassFactory.GetAllRegistrationsByMetadata(BaseFormPanel, ...)`
+ * to find every panel registered with metadata `{ entity, slot }` matching this
+ * slot. Registrations without a metadata bag (or without these required keys)
+ * are silently ignored so legacy registrations don't accidentally bind.
+ *
+ * **Ordering**: registrations are sorted by `metadata.sortKey` descending —
+ * higher number renders first within the slot. Use ranges (100/50/10) so future
+ * panels can wedge in without renumbering. Ties fall back to the
+ * `ClassRegistration.Priority` field (also descending), and finally to
+ * registration order.
+ *
+ * **Fallback chain** (see `FormSlotCoordinator`): each slot host registers
+ * with the per-form coordinator and additionally renders panels whose
+ * REGISTERED slot is missing in the current form, when this host happens to
+ * be the next-existing slot down the chain. The container template guarantees
+ * an `after-everything` slot host, so fallback always terminates somewhere.
+ * Downstream consumers running an older form template (no CodeGen rerun
+ * yet) get every panel rendered at the bottom; consumers on the new template
+ * get them in the preferred position.
+ *
+ * **Re-mount**: any input change OR a coordinator change (another slot
+ * registers/deregisters) triggers a re-render so fallback assignments stay
+ * correct as slots come and go.
+ */
+export class FormPanelSlotComponent {
+    coordinator;
+    /** The entity name (e.g., `"MJ: Content Sources"`) being edited. */
+    Entity;
+    /** Which slot position this host represents. */
+    Slot;
+    /** The record being edited — threaded through to every mounted panel. */
+    Record;
+    /** The host form component — used by panels for EditMode + dirty notifications. */
+    FormComponent;
+    /** Optional form context — same shape collapsible-panel chrome expects. */
+    FormContext;
+    anchor;
+    mounted = [];
+    destroy$ = new Subject();
+    registeredSlot = null;
+    /** Tracks synchronous re-entry depth into remount() so a future refactor
+     *  that reintroduces a remount loop surfaces loudly instead of freezing. */
+    remountDepth = 0;
+    constructor(coordinator) {
+        this.coordinator = coordinator;
+    }
+    ngOnInit() {
+        if (this.Slot && this.coordinator) {
+            this.coordinator.registerSlot(this.Slot);
+            this.registeredSlot = this.Slot;
+            // Re-mount whenever the coordinator's known-slot set changes —
+            // a panel that was previously orphaned to us might now have a
+            // better slot available (or vice versa).
+            this.coordinator.changes
+                .pipe(takeUntil(this.destroy$))
+                .subscribe(() => this.remount());
+        }
+    }
+    ngOnChanges(changes) {
+        if (!this.Entity || !this.Slot || !this.Record || !this.FormComponent) {
+            // Inputs still being wired — wait for the next pass.
+            return;
+        }
+        // Only remount when something that affects WHICH panels to mount has
+        // changed. FormContext only flows through to mounted panels — pushing
+        // it to the existing panels avoids an unmount/remount cycle.
+        //
+        // Critical for performance: the host form often reconstructs
+        // formContext on every CD pass. Treating that as a structural change
+        // would loop (remount → detectChanges → another CD → new FormContext
+        // → remount again).
+        const meaningfulKeys = ['Entity', 'Slot', 'Record', 'FormComponent'];
+        const meaningfulChange = meaningfulKeys.some(k => changes[k]?.currentValue !== changes[k]?.previousValue);
+        if (!meaningfulChange && changes['FormContext'] && this.mounted.length > 0) {
+            for (const ref of this.mounted) {
+                ref.instance.FormContext = this.FormContext;
+            }
+            return;
+        }
+        if (!meaningfulChange && this.mounted.length > 0) {
+            return;
+        }
+        this.remount();
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+        if (this.coordinator && this.registeredSlot) {
+            this.coordinator.deregisterSlot(this.registeredSlot);
+            this.registeredSlot = null;
+        }
+        this.unmountAll();
+    }
+    remount() {
+        this.remountDepth++;
+        if (this.remountDepth > 5) {
+            console.error(`[mj-form-panel-slot] LOOP DETECTED — remount depth ${this.remountDepth} on slot=${this.Slot}. Bailing.`);
+            this.remountDepth--;
+            return;
+        }
+        this.unmountAll();
+        // 1. Direct matches: panels registered for THIS slot.
+        const direct = this.findRegistrations(this.Slot);
+        // 2. Orphans: panels registered for some OTHER slot whose preferred
+        //    slot doesn't exist in this form, AND this slot host is the
+        //    coordinator-resolved fallback for them. Without a coordinator
+        //    (no parent container), no orphan handling — panels just bind
+        //    to their literal slot.
+        const orphans = this.findOrphans();
+        const all = [...direct, ...orphans];
+        if (all.length === 0) {
+            this.remountDepth--;
+            return;
+        }
+        // Sort: higher sortKey first, then higher Priority, then registration order.
+        all.sort((a, b) => {
+            const aSort = a.Metadata?.sortKey ?? 0;
+            const bSort = b.Metadata?.sortKey ?? 0;
+            if (aSort !== bSort)
+                return bSort - aSort;
+            return b.Priority - a.Priority;
+        });
+        for (const reg of all) {
+            try {
+                const ctor = reg.SubClass;
+                const ref = this.anchor.createComponent(ctor);
+                ref.instance.Record = this.Record;
+                ref.instance.FormComponent = this.FormComponent;
+                if (this.FormContext)
+                    ref.instance.FormContext = this.FormContext;
+                // No detectChanges() — Angular's normal CD pass picks the new
+                // component up. Calling detectChanges() synchronously inside
+                // an ongoing CD cycle (which is when ngOnChanges → remount
+                // fires) can re-enter and cause an infinite loop if anything
+                // upstream is reconstructing inputs on each CD pass.
+                this.mounted.push(ref);
+            }
+            catch (e) {
+                LogError(`[mj-form-panel-slot] Failed to mount panel for ${this.Entity}:${this.Slot}: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+        this.remountDepth--;
+    }
+    /** Find registrations whose metadata declares this exact entity + slot. */
+    findRegistrations(slot) {
+        return MJGlobal.Instance.ClassFactory.GetAllRegistrationsByMetadata(BaseFormPanel, (metadata) => {
+            if (!metadata)
+                return false;
+            const meta = metadata;
+            return meta.entity === this.Entity && meta.slot === slot;
+        });
+    }
+    /**
+     * Find panels registered for a different slot that should mount HERE
+     * because their preferred slot isn't present and this slot is the next
+     * existing one in the fallback chain.
+     *
+     * Only meaningful when we have a coordinator (i.e., we're inside an
+     * `<mj-record-form-container>`).
+     */
+    findOrphans() {
+        if (!this.coordinator)
+            return [];
+        const allForEntity = MJGlobal.Instance.ClassFactory.GetAllRegistrationsByMetadata(BaseFormPanel, (metadata) => {
+            if (!metadata)
+                return false;
+            const meta = metadata;
+            return meta.entity === this.Entity && meta.slot != null && meta.slot !== this.Slot;
+        });
+        return allForEntity.filter(reg => {
+            const meta = reg.Metadata;
+            if (!meta?.slot)
+                return false;
+            const resolved = this.coordinator.resolveSlot(meta.slot);
+            return resolved === this.Slot;
+        });
+    }
+    unmountAll() {
+        this.anchor.clear();
+        this.mounted = [];
+    }
+    static ɵfac = function FormPanelSlotComponent_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || FormPanelSlotComponent)(i0.ɵɵdirectiveInject(i1.FormSlotCoordinator, 8)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: FormPanelSlotComponent, selectors: [["mj-form-panel-slot"]], viewQuery: function FormPanelSlotComponent_Query(rf, ctx) { if (rf & 1) {
+            i0.ɵɵviewQuery(_c0, 7, ViewContainerRef);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.anchor = _t.first);
+        } }, inputs: { Entity: "Entity", Slot: "Slot", Record: "Record", FormComponent: "FormComponent", FormContext: "FormContext" }, standalone: false, features: [i0.ɵɵNgOnChangesFeature], decls: 2, vars: 0, consts: [["anchor", ""]], template: function FormPanelSlotComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementContainer(0, null, 0);
+        } }, styles: ["[_nghost-%COMP%] { display: contents; }"] });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FormPanelSlotComponent, [{
+        type: Component,
+        args: [{ standalone: false, selector: 'mj-form-panel-slot', template: `<ng-container #anchor></ng-container>`, styles: [":host { display: contents; }"] }]
+    }], () => [{ type: i1.FormSlotCoordinator, decorators: [{
+                type: Optional
+            }] }], { Entity: [{
+            type: Input
+        }], Slot: [{
+            type: Input
+        }], Record: [{
+            type: Input
+        }], FormComponent: [{
+            type: Input
+        }], FormContext: [{
+            type: Input
+        }], anchor: [{
+            type: ViewChild,
+            args: ['anchor', { read: ViewContainerRef, static: true }]
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(FormPanelSlotComponent, { className: "FormPanelSlotComponent", filePath: "src/lib/panel-slot/form-panel-slot.component.ts", lineNumber: 64 }); })();
+//# sourceMappingURL=form-panel-slot.component.js.map

package/dist/lib/panel-slot/form-panel-slot.component.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"form-panel-slot.component.js","sourceRoot":"","sources":["../../../src/lib/panel-slot/form-panel-slot.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    Component,\n    ComponentRef,\n    Input,\n    OnChanges,\n    OnDestroy,\n    OnInit,\n    Optional,\n    SimpleChanges,\n    Type,\n    ViewChild,\n    ViewContainerRef,\n} from '@angular/core';\nimport { Subject, takeUntil } from 'rxjs';\nimport { BaseEntity, LogError } from '@memberjunction/core';\nimport { ClassRegistration, MJGlobal } from '@memberjunction/global';\nimport { BaseFormComponent } from '../base-form-component';\nimport { FormContext } from '../types/form-types';\nimport { BaseFormPanel, FormPanelRegistrationMetadata, FormPanelSlot } from './base-form-panel';\nimport { FormSlotCoordinator } from './form-slot-coordinator.service';\n\n/**\n * `<mj-form-panel-slot>` — dynamic slot host that discovers and mounts every\n * registered `BaseFormPanel` whose metadata matches the slot's `Entity` +\n * `Slot` inputs. Generated entity-form HTML emits one of these at each\n * well-known slot position so consumers can extend the form WITHOUT replacing\n * it via the custom-form override pattern.\n *\n * **Discovery**: uses `ClassFactory.GetAllRegistrationsByMetadata(BaseFormPanel, ...)`\n * to find every panel registered with metadata `{ entity, slot }` matching this\n * slot. Registrations without a metadata bag (or without these required keys)\n * are silently ignored so legacy registrations don't accidentally bind.\n *\n * **Ordering**: registrations are sorted by `metadata.sortKey` descending —\n * higher number renders first within the slot. Use ranges (100/50/10) so future\n * panels can wedge in without renumbering. Ties fall back to the\n * `ClassRegistration.Priority` field (also descending), and finally to\n * registration order.\n *\n * **Fallback chain** (see `FormSlotCoordinator`): each slot host registers\n * with the per-form coordinator and additionally renders panels whose\n * REGISTERED slot is missing in the current form, when this host happens to\n * be the next-existing slot down the chain. The container template guarantees\n * an `after-everything` slot host, so fallback always terminates somewhere.\n * Downstream consumers running an older form template (no CodeGen rerun\n * yet) get every panel rendered at the bottom; consumers on the new template\n * get them in the preferred position.\n *\n * **Re-mount**: any input change OR a coordinator change (another slot\n * registers/deregisters) triggers a re-render so fallback assignments stay\n * correct as slots come and go.\n */\n@Component({\n    standalone: false,\n    selector: 'mj-form-panel-slot',\n    template: `<ng-container #anchor></ng-container>`,\n    // `display: contents` makes the host element disappear from the layout\n    // tree so the mounted panels (children) participate directly in the\n    // parent's flex/grid layout. Without this, the parent's gap/spacing\n    // rules treat all mounted panels as a SINGLE child (the slot host),\n    // collapsing the spacing between them.\n    styles: [`:host { display: contents; }`],\n})\nexport class FormPanelSlotComponent implements OnInit, OnChanges, OnDestroy {\n    /** The entity name (e.g., `\"MJ: Content Sources\"`) being edited. */\n    @Input() Entity!: string;\n    /** Which slot position this host represents. */\n    @Input() Slot!: FormPanelSlot;\n    /** The record being edited — threaded through to every mounted panel. */\n    @Input() Record!: BaseEntity;\n    /** The host form component — used by panels for EditMode + dirty notifications. */\n    @Input() FormComponent!: BaseFormComponent;\n    /** Optional form context — same shape collapsible-panel chrome expects. */\n    @Input() FormContext?: FormContext;\n\n    @ViewChild('anchor', { read: ViewContainerRef, static: true })\n    private anchor!: ViewContainerRef;\n\n    private mounted: ComponentRef<BaseFormPanel>[] = [];\n    private readonly destroy$ = new Subject<void>();\n    private registeredSlot: FormPanelSlot | null = null;\n    /** Tracks synchronous re-entry depth into remount() so a future refactor\n     *  that reintroduces a remount loop surfaces loudly instead of freezing. */\n    private remountDepth = 0;\n\n    constructor(@Optional() private readonly coordinator?: FormSlotCoordinator) {}\n\n    ngOnInit(): void {\n        if (this.Slot && this.coordinator) {\n            this.coordinator.registerSlot(this.Slot);\n            this.registeredSlot = this.Slot;\n            // Re-mount whenever the coordinator's known-slot set changes —\n            // a panel that was previously orphaned to us might now have a\n            // better slot available (or vice versa).\n            this.coordinator.changes\n                .pipe(takeUntil(this.destroy$))\n                .subscribe(() => this.remount());\n        }\n    }\n\n    ngOnChanges(changes: SimpleChanges): void {\n        if (!this.Entity || !this.Slot || !this.Record || !this.FormComponent) {\n            // Inputs still being wired — wait for the next pass.\n            return;\n        }\n\n        // Only remount when something that affects WHICH panels to mount has\n        // changed. FormContext only flows through to mounted panels — pushing\n        // it to the existing panels avoids an unmount/remount cycle.\n        //\n        // Critical for performance: the host form often reconstructs\n        // formContext on every CD pass. Treating that as a structural change\n        // would loop (remount → detectChanges → another CD → new FormContext\n        // → remount again).\n        const meaningfulKeys = ['Entity', 'Slot', 'Record', 'FormComponent'];\n        const meaningfulChange = meaningfulKeys.some(k => changes[k]?.currentValue !== changes[k]?.previousValue);\n        if (!meaningfulChange && changes['FormContext'] && this.mounted.length > 0) {\n            for (const ref of this.mounted) {\n                ref.instance.FormContext = this.FormContext;\n            }\n            return;\n        }\n        if (!meaningfulChange && this.mounted.length > 0) {\n            return;\n        }\n        this.remount();\n    }\n\n    ngOnDestroy(): void {\n        this.destroy$.next();\n        this.destroy$.complete();\n        if (this.coordinator && this.registeredSlot) {\n            this.coordinator.deregisterSlot(this.registeredSlot);\n            this.registeredSlot = null;\n        }\n        this.unmountAll();\n    }\n\n    private remount(): void {\n        this.remountDepth++;\n        if (this.remountDepth > 5) {\n            console.error(`[mj-form-panel-slot] LOOP DETECTED — remount depth ${this.remountDepth} on slot=${this.Slot}. Bailing.`);\n            this.remountDepth--;\n            return;\n        }\n        this.unmountAll();\n\n        // 1. Direct matches: panels registered for THIS slot.\n        const direct = this.findRegistrations(this.Slot);\n\n        // 2. Orphans: panels registered for some OTHER slot whose preferred\n        //    slot doesn't exist in this form, AND this slot host is the\n        //    coordinator-resolved fallback for them. Without a coordinator\n        //    (no parent container), no orphan handling — panels just bind\n        //    to their literal slot.\n        const orphans = this.findOrphans();\n\n        const all = [...direct, ...orphans];\n        if (all.length === 0) {\n            this.remountDepth--;\n            return;\n        }\n\n        // Sort: higher sortKey first, then higher Priority, then registration order.\n        all.sort((a, b) => {\n            const aSort = (a.Metadata as FormPanelRegistrationMetadata | undefined)?.sortKey ?? 0;\n            const bSort = (b.Metadata as FormPanelRegistrationMetadata | undefined)?.sortKey ?? 0;\n            if (aSort !== bSort) return bSort - aSort;\n            return b.Priority - a.Priority;\n        });\n\n        for (const reg of all) {\n            try {\n                const ctor = reg.SubClass as Type<BaseFormPanel>;\n                const ref = this.anchor.createComponent(ctor);\n                ref.instance.Record = this.Record;\n                ref.instance.FormComponent = this.FormComponent;\n                if (this.FormContext) ref.instance.FormContext = this.FormContext;\n                // No detectChanges() — Angular's normal CD pass picks the new\n                // component up. Calling detectChanges() synchronously inside\n                // an ongoing CD cycle (which is when ngOnChanges → remount\n                // fires) can re-enter and cause an infinite loop if anything\n                // upstream is reconstructing inputs on each CD pass.\n                this.mounted.push(ref);\n            } catch (e) {\n                LogError(`[mj-form-panel-slot] Failed to mount panel for ${this.Entity}:${this.Slot}: ${e instanceof Error ? e.message : String(e)}`);\n            }\n        }\n        this.remountDepth--;\n    }\n\n    /** Find registrations whose metadata declares this exact entity + slot. */\n    private findRegistrations(slot: FormPanelSlot): ClassRegistration[] {\n        return MJGlobal.Instance.ClassFactory.GetAllRegistrationsByMetadata(\n            BaseFormPanel,\n            (metadata) => {\n                if (!metadata) return false;\n                const meta = metadata as Partial<FormPanelRegistrationMetadata>;\n                return meta.entity === this.Entity && meta.slot === slot;\n            },\n        );\n    }\n\n    /**\n     * Find panels registered for a different slot that should mount HERE\n     * because their preferred slot isn't present and this slot is the next\n     * existing one in the fallback chain.\n     *\n     * Only meaningful when we have a coordinator (i.e., we're inside an\n     * `<mj-record-form-container>`).\n     */\n    private findOrphans(): ClassRegistration[] {\n        if (!this.coordinator) return [];\n\n        const allForEntity = MJGlobal.Instance.ClassFactory.GetAllRegistrationsByMetadata(\n            BaseFormPanel,\n            (metadata) => {\n                if (!metadata) return false;\n                const meta = metadata as Partial<FormPanelRegistrationMetadata>;\n                return meta.entity === this.Entity && meta.slot != null && meta.slot !== this.Slot;\n            },\n        );\n\n        return allForEntity.filter(reg => {\n            const meta = reg.Metadata as FormPanelRegistrationMetadata | undefined;\n            if (!meta?.slot) return false;\n            const resolved = this.coordinator!.resolveSlot(meta.slot);\n            return resolved === this.Slot;\n        });\n    }\n\n    private unmountAll(): void {\n        this.anchor.clear();\n        this.mounted = [];\n    }\n}\n"]}

package/dist/lib/panel-slot/form-slot-coordinator.service.d.ts

@@ -0,0 +1,57 @@
+import { FormPanelSlot } from './base-form-panel';
+import * as i0 from "@angular/core";
+/**
+ * Document-order chain used by the slot host to figure out where to render a
+ * panel whose preferred slot is missing in the current form. Walks forward:
+ * a panel registered for `after-fields` looks for the next existing slot down
+ * the chain (`after-related`, then `after-everything`) until it finds one.
+ *
+ * The chain is intentionally short — these are the only positions any panel
+ * should ever need. New positions can be added by inserting into this array
+ * at the right document-order position.
+ */
+export declare const FORM_SLOT_CHAIN: FormPanelSlot[];
+/**
+ * Per-form coordinator that tracks which slot positions are physically present
+ * in the current form's DOM. Provided at the `<mj-record-form-container>` level
+ * (one instance per form) so descendant slot hosts can register themselves and
+ * compute the fallback chain.
+ *
+ * The container template guarantees an `after-everything` slot host at the very
+ * bottom of the form body — so panels whose preferred slot is missing always
+ * have a final landing spot. Pre-CodeGen-regen forms still display every
+ * panel; post-regen forms display them at the better position.
+ */
+export declare class FormSlotCoordinator {
+    private readonly presentSlots;
+    private readonly changes$;
+    /** Tracks synchronous re-entry depth into safeEmit so an emit storm
+     *  caused by a future refactor surfaces loudly instead of freezing. */
+    private emitDepth;
+    /** Slot host calls this on init. Idempotent — safe if invoked twice. */
+    registerSlot(slot: FormPanelSlot): void;
+    /** Slot host calls this on destroy. */
+    deregisterSlot(slot: FormPanelSlot): void;
+    hasSlot(slot: FormPanelSlot): boolean;
+    /**
+     * Resolve a preferred slot to the slot that should ACTUALLY render the
+     * panel. Returns the preferred slot if it's present; otherwise walks
+     * forward in the chain to find the next existing slot.
+     *
+     * Returns null only in the (impossible) case where no slot at all is
+     * present — the container guarantees `after-everything` exists, so this
+     * should never happen in practice.
+     */
+    resolveSlot(preferred: FormPanelSlot): FormPanelSlot | null;
+    /** RxJS stream that fires whenever a slot registers or deregisters. */
+    get changes(): import("rxjs").Observable<void>;
+    /**
+     * Emit with re-entrancy detection. If we're already in the middle of an
+     * emit (i.e., a subscriber triggered another emit), log loudly so the loop
+     * is visible in the console instead of silently freezing the browser.
+     */
+    private safeEmit;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormSlotCoordinator, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormSlotCoordinator>;
+}
+//# sourceMappingURL=form-slot-coordinator.service.d.ts.map

package/dist/lib/panel-slot/form-slot-coordinator.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"form-slot-coordinator.service.d.ts","sourceRoot":"","sources":["../../../src/lib/panel-slot/form-slot-coordinator.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;;AAElD;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,EAAE,aAAa,EAM1C,CAAC;AAEF;;;;;;;;;;GAUG;AACH,qBACa,mBAAmB;IAC5B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA4B;IACzD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAuB;IAChD;2EACuE;IACvE,OAAO,CAAC,SAAS,CAAK;IAEtB,wEAAwE;IACjE,YAAY,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI;IAO9C,uCAAuC;IAChC,cAAc,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI;IAOzC,OAAO,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAI5C;;;;;;;;OAQG;IACI,WAAW,CAAC,SAAS,EAAE,aAAa,GAAG,aAAa,GAAG,IAAI;IAYlE,uEAAuE;IACvE,IAAW,OAAO,oCAEjB;IAED;;;;OAIG;IACH,OAAO,CAAC,QAAQ;yCA1DP,mBAAmB;6CAAnB,mBAAmB;CAsE/B"}