@firestitch/form 18.0.29 → 18.0.31

package/app/components/form-dialog-actions/form-dialog-actions.component.d.ts

@@ -1,18 +1,33 @@
 import { OnDestroy, OnInit } from '@angular/core';
 import * as i0 from "@angular/core";
 export declare class FsFormDialogActionsComponent implements OnInit, OnDestroy {
-    private _form;
-    private _cdRef;
+    /** Leave unset inside an `fsFormContainer` to follow whether it has anything to save. */
     save: boolean;
     create: boolean;
     close: boolean;
+    /** Leave unset inside an `fsFormContainer` to fill in whenever Save does not apply. */
     done: boolean;
     closeData: any;
     name: string;
     dirty: boolean;
     private _destroy$;
+    private _dialogRef;
+    private _container;
+    private _form;
+    private _cdRef;
+    /**
+     * Inside a container these default to whether anything mounted can actually
+     * save, so a footer left as a bare `<fs-form-dialog-actions>` swaps Save for
+     * Done as tabs change without the dialog listing which tabs are savable. An
+     * explicit binding always wins, and outside a container Save stays on as it
+     * always did.
+     */
+    get showSave(): boolean;
+    get showDone(): boolean;
     ngOnInit(): void;
     ngOnDestroy(): void;
+    /** Keeps a DI-resolved owner only when it belongs to these actions' dialog. */
+    private _ownDialogOnly;
     static ɵfac: i0.ɵɵFactoryDeclaration<FsFormDialogActionsComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<FsFormDialogActionsComponent, "fs-form-dialog-actions", never, { "save": { "alias": "save"; "required": false; }; "create": { "alias": "create"; "required": false; }; "close": { "alias": "close"; "required": false; }; "done": { "alias": "done"; "required": false; }; "closeData": { "alias": "closeData"; "required": false; }; "name": { "alias": "name"; "required": false; }; }, {}, never, ["*"], true, never>;
 }

package/app/directives/button.directive.d.ts

@@ -11,7 +11,8 @@ export declare class FsButtonDirective implements OnInit, OnDestroy {
     private _formDisabled;
     private _previousDisabled;
     private _destroy$;
-    private _formGroup;
+    private _dialogRef;
+    private _container;
     private _form;
     private _matButton;
     private _elementRef;
@@ -27,6 +28,13 @@ export declare class FsButtonDirective implements OnInit, OnDestroy {
     get element(): any;
     reset(): void;
     ngOnDestroy(): void;
+    /**
+     * Keeps a DI-resolved owner only when it belongs to this button's dialog. A
+     * dialog opened with `viewContainerRef` resolves through to whatever opened
+     * it, so without this the inner dialog's Save would register with - and
+     * submit - the outer dialog's form set.
+     */
+    private _ownDialogOnly;
     private _applyDisabled;
     private _resetClass;
     private _getSvg;

package/app/directives/confirm-tabs/confirm-tabs.directive.d.ts

@@ -0,0 +1,32 @@
+import { OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Brings a tab group into the enclosing form set's unsaved-changes confirm.
+ *
+ * An owner picks up tab groups with `@ContentChildren(MatTabGroup)`, which reaches
+ * through its own projected content - including lazily mounted tab bodies - but
+ * stops at a child component's view. So a tab group declared inside a child
+ * component's own template is invisible to the dialog that contains it, and
+ * switching between those tabs never prompts even though switching the outer ones
+ * does. That is not a shape worth avoiding: a dialog whose Profile tab is its own
+ * component, with its own tabs inside, is the normal way to keep a large dialog
+ * readable.
+ *
+ * DI does cross the boundary a content query cannot, so put this on the nested
+ * group and it registers itself with the owner above it:
+ *
+ *   <mat-tab-group fsFormConfirmTabs [(selected)]="tab">
+ *
+ * Confirming stays gated on the owner's `confirm` and `confirmTabs` inputs, so
+ * this only opts the group in - it never forces a prompt on.
+ */
+export declare class FsFormConfirmTabsDirective implements OnInit {
+    private _tabGroup;
+    private _dialogRef;
+    private _container;
+    private _form;
+    ngOnInit(): void;
+    private _ownDialogOnly;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FsFormConfirmTabsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FsFormConfirmTabsDirective, "mat-tab-group[fsFormConfirmTabs]", never, {}, {}, never, never, true, never>;
+}

package/app/directives/confirm-tabs/index.d.ts

@@ -0,0 +1 @@
+export * from './confirm-tabs.directive';

package/app/directives/form/form.directive.d.ts

@@ -3,34 +3,37 @@ import { NgForm } from '@angular/forms';
 import { Observable } from 'rxjs';
 import { FsFormBaseDirective } from '../form-base';
 import { ConfirmResult } from './../../enums/confirm-result';
-import { ConfirmConfig, SubmittedEvent } from './../../interfaces';
+import { FormStatus } from './../../enums/form-status';
+import { SubmittedEvent } from './../../interfaces';
 import { SubmitEvent } from './../../interfaces/submit-event';
 import * as i0 from "@angular/core";
 export declare class FsFormDirective extends FsFormBaseDirective implements OnInit, OnDestroy, AfterContentInit, OnChanges {
     ngForm: NgForm;
-    private _form;
-    private _element;
-    private _message;
-    private _formGroup;
-    private _dialogRef;
-    private _drawerRef;
-    private _route;
     wrapperSelector: string;
     messageSelector: string;
     hintSelector: string;
     labelSelector: string;
     autocomplete: boolean;
-    shortcuts: boolean;
-    confirm: ConfirmConfig | boolean;
-    confirmDialog: boolean;
-    confirmDrawer: boolean;
-    confirmBrowser: boolean;
     dirtySubmitButton: boolean;
     set submit(submit$: (event: SubmitEvent) => Observable<any>);
     get submit(): (event: SubmitEvent) => Observable<any>;
     successDelay: number;
     errorDelay: number;
-    deactivationGuard: boolean;
+    /**
+     * Whether this form joins the set around it - the `fsForm` it is nested inside,
+     * or the `fsFormContainer` enclosing it.
+     *
+     * Forms in a set behave as one submittable unit: the outermost form is what the
+     * submit buttons drive, and validation, dirty state, the unsaved-changes
+     * confirm and the pristine reset all span the set. That is what lets a form
+     * wrap only one tab's fields while the dialog footer stays outside it.
+     *
+     * Set `[link]="false"` for a panel that owns its own saving - an instant-save
+     * side panel, say. It keeps every fsForm feature for itself, but its dirty
+     * state never enables the outer Save button, its validation never blocks the
+     * outer submit, and the outer submit never touches it.
+     */
+    link: boolean;
     submitEvent: EventEmitter<SubmitEvent>;
     invalid: EventEmitter<SubmitEvent>;
     valid: EventEmitter<SubmitEvent>;
@@ -39,19 +42,73 @@ export declare class FsFormDirective extends FsFormBaseDirective implements OnIn
     cleared: EventEmitter<SubmitEvent>;
     fsFormClass: boolean;
     private _registerControl;
-    private _dialogBackdropEscape;
     private _snapshot;
-    private _activatedRouteConfig;
     private _status$;
     private _submit$;
+    private _linkedForms;
+    private _containerParent;
+    private _dirtyChange$;
+    private _message;
+    private _container;
+    private _ancestorForm;
+    /**
+     * Emits whenever the set's dirty state may have moved. Anything outside the
+     * form that renders off it - the dialog actions, say - can't watch
+     * `ngForm.valueChanges` on its own, because the edits happen in a nested form's
+     * NgForm, not this one's.
+     */
+    get dirtyChange$(): Observable<void>;
+    get submitted$(): Observable<SubmittedEvent>;
+    get status$(): Observable<FormStatus>;
+    get element(): HTMLElement;
+    /** True when a Save button driving this form would have something to run. */
+    get hasSubmit(): boolean;
+    /**
+     * The form this one is linked into, or null when it is a root - either because
+     * nothing encloses it or because `[link]="false"` cut it loose. A container
+     * supplies the parent when the forms are siblings rather than nested.
+     */
+    get parentForm(): FsFormDirective;
+    /** The outermost form of this set. Submit buttons drive this one. */
+    get rootForm(): FsFormDirective;
+    /** This form plus every form linked into it, at any depth. */
+    get linkedForms(): FsFormDirective[];
+    /** True when this form or anything linked into it has unsaved changes. */
+    get dirtyLinked(): boolean;
+    /**
+     * True when this form or anything linked into it has a submit handler - i.e.
+     * there is something for a Save button to do. A dialog footer can bind to this
+     * to swap Save for Done as the mounted tab changes, instead of hard-coding
+     * which tab names happen to be savable.
+     */
+    get submits(): boolean;
     get submitting(): boolean;
     get validating(): boolean;
     get completing(): boolean;
+    /**
+     * True when nothing above this form speaks for the set it belongs to. Reads the
+     * raw injections rather than `parentForm`, so an unlinked panel inside a dialog
+     * still defers to whatever encloses it instead of registering a second backdrop
+     * confirm on the same dialog.
+     */
+    private get _owns();
     private get _submitEvent();
     private get _formValidState$();
     private get _formInvalidState$();
     private get _submitter();
     ngOnInit(): void;
+    /**
+     * Take a nested form into this one's set. Called by the child on init, or by a
+     * container linking its siblings - consumers never call it directly.
+     */
+    linkForm(form: FsFormDirective): void;
+    unlinkForm(form: FsFormDirective): void;
+    /**
+     * Adopt a parent that DI could not supply. Only a container calls this, to link
+     * forms that are siblings in the template into one set.
+     */
+    linkTo(form: FsFormDirective): void;
+    unlinkFrom(): void;
     ngOnChanges(changes: SimpleChanges): void;
     clearSubmit(submit?: (event: SubmitEvent) => Observable<any>): void;
     registerSubmit(submit$: () => Observable<any>): void;
@@ -72,22 +129,27 @@ export declare class FsFormDirective extends FsFormBaseDirective implements OnIn
     enable(): void;
     disable(): void;
     validate(): void;
-    submit$(submitEvent: SubmitEvent): Observable<SubmittedEvent>;
+    submit$(submitEvent?: SubmitEvent): Observable<SubmittedEvent>;
     private _listenSubmit;
     private _listenFormStatus;
-    private _listenWindowClose;
-    private _activeDialog;
-    private _listenHotKeys;
-    private _formClose;
     private _getActiveSubmitButton;
-    private _elementInForm;
     private _completeSubmit;
-    private _getFormGroup;
+    /**
+     * Whoever holds the submit buttons for this form. A container when one encloses
+     * it, otherwise the root of its linked set - the button that saves a tab's form
+     * typically sits outside it, down in the dialog footer.
+     *
+     * Only a form that actually joined the container may drive its buttons. DI
+     * hands `_container` to every form inside, including one cut loose with
+     * `[link]="false"`, and an instant-save panel is usually `[confirm]="false"`
+     * too - so without this it would take the `!confirm` branch below and
+     * re-enable the footer's Save button that the linked set had just disabled.
+     */
+    private _getOwner;
+    /** Keeps a DI-resolved owner only when it belongs to this form's dialog. */
+    private _ownDialogOnly;
     private _resetButtons;
     private _registerConfirm;
-    private _registerDrawerClose;
-    private _registerConfirmDrawerClose;
-    private _registerConfirmDialogBackdropEscape;
     private _registerAutocomplete;
     private _registerDirtySubmitButton;
     private _updateDirtySubmitButtons;
@@ -97,8 +159,6 @@ export declare class FsFormDirective extends FsFormBaseDirective implements OnIn
     private _disableButtons;
     private _waitUntilStatusPending;
     private _handleError;
-    private _registerCanDeactivateGuard;
-    private _cleanupCanDeactivate;
     static ɵfac: i0.ɵɵFactoryDeclaration<FsFormDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FsFormDirective, "[fsForm]", ["fsForm"], { "wrapperSelector": { "alias": "wrapperSelector"; "required": false; }; "messageSelector": { "alias": "messageSelector"; "required": false; }; "hintSelector": { "alias": "hintSelector"; "required": false; }; "labelSelector": { "alias": "labelSelector"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; "shortcuts": { "alias": "shortcuts"; "required": false; }; "confirm": { "alias": "confirm"; "required": false; }; "confirmDialog": { "alias": "confirmDialog"; "required": false; }; "confirmDrawer": { "alias": "confirmDrawer"; "required": false; }; "confirmBrowser": { "alias": "confirmBrowser"; "required": false; }; "dirtySubmitButton": { "alias": "dirtySubmitButton"; "required": false; }; "submit": { "alias": "submit"; "required": false; }; "successDelay": { "alias": "successDelay"; "required": false; }; "errorDelay": { "alias": "errorDelay"; "required": false; }; "deactivationGuard": { "alias": "deactivationGuard"; "required": false; }; }, { "submitEvent": "fsForm"; "invalid": "invalid"; "valid": "valid"; "submitted": "submitted"; "reseted": "reseted"; "cleared": "cleared"; }, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FsFormDirective, "[fsForm]", ["fsForm"], { "wrapperSelector": { "alias": "wrapperSelector"; "required": false; }; "messageSelector": { "alias": "messageSelector"; "required": false; }; "hintSelector": { "alias": "hintSelector"; "required": false; }; "labelSelector": { "alias": "labelSelector"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; "dirtySubmitButton": { "alias": "dirtySubmitButton"; "required": false; }; "submit": { "alias": "submit"; "required": false; }; "successDelay": { "alias": "successDelay"; "required": false; }; "errorDelay": { "alias": "errorDelay"; "required": false; }; "link": { "alias": "link"; "required": false; }; }, { "submitEvent": "fsForm"; "invalid": "invalid"; "valid": "valid"; "submitted": "submitted"; "reseted": "reseted"; "cleared": "cleared"; }, never, never, true, never>;
 }

package/app/directives/form-base/form-base.directive.d.ts

@@ -1,34 +1,114 @@
-import { AfterContentInit, ChangeDetectorRef, NgZone, OnDestroy, QueryList } from '@angular/core';
+import { AfterContentInit, ChangeDetectorRef, ElementRef, NgZone, OnDestroy, OnInit, QueryList } from '@angular/core';
+import { ActivatedRoute, Route } from '@angular/router';
+import { MatDialogRef } from '@angular/material/dialog';
 import { MatTabGroup } from '@angular/material/tabs';
+import { DrawerRef } from '@firestitch/drawer';
 import { Observable } from 'rxjs';
 import { ConfirmResult } from '../../enums';
-import { ConfirmConfig } from '../../interfaces';
+import { FormStatus } from '../../enums/form-status';
+import { ConfirmConfig, SubmitEvent, SubmittedEvent } from '../../interfaces';
+import { FsForm } from '../../services/fsform.service';
 import { FsButtonDirective } from '../button.directive';
+import type { FsFormDirective } from '../form/form.directive';
 import * as i0 from "@angular/core";
-export declare abstract class FsFormBaseDirective implements AfterContentInit, OnDestroy {
+/**
+ * Shared by the two things that can own a set of forms: an `fsForm` sitting at
+ * the root of its linked set, and an `fsFormContainer` holding forms that are
+ * siblings rather than nested.
+ *
+ * It holds the submit-button registry both of them expose to buttons, and the
+ * lifecycle that belongs to the set as a whole rather than to any one form -
+ * the dialog backdrop and Escape, Ctrl+S, the browser close prompt, the drawer
+ * and tab-switch confirms. Exactly one owner registers that lifecycle; see
+ * `_registerOwnerLifecycle`.
+ */
+export declare abstract class FsFormBaseDirective implements OnInit, AfterContentInit, OnDestroy {
     confirmTabs: boolean;
-    tabGroup: MatTabGroup;
+    confirm: ConfirmConfig | boolean;
+    confirmDialog: boolean;
+    confirmDrawer: boolean;
+    confirmBrowser: boolean;
+    shortcuts: boolean;
+    deactivationGuard: boolean;
     protected _ngZone: NgZone;
     protected _cdRef: ChangeDetectorRef;
+    protected _element: ElementRef<any>;
+    protected _form: FsForm;
+    protected _route: ActivatedRoute;
+    protected _dialogRef: MatDialogRef<any, any>;
+    protected _drawerRef: DrawerRef<any, any>;
+    protected _dialogBackdropEscape: boolean;
+    protected _activatedRouteConfig: Route | null;
     private _tabGroups;
     private _buttons;
     private _activeSubmitButton;
+    private _confirmTabGroups;
     private _destroy$;
     abstract submitting: boolean;
-    abstract confirm: ConfirmConfig | boolean;
+    /** True when anything in the owned set has unsaved changes. */
+    abstract dirtyLinked: boolean;
+    /** Every form in the owned set, at any depth. */
+    abstract linkedForms: FsFormDirective[];
+    /** Emits whenever the owned set's dirty state may have moved. */
+    abstract dirtyChange$: Observable<void>;
+    /** Emits once a submit over the owned set has completed successfully. */
+    abstract submitted$: Observable<SubmittedEvent>;
+    /** Tracks the owned set's submit lifecycle, so the drawer can wait one out. */
+    abstract status$: Observable<FormStatus>;
+    /**
+     * The dialog this owner lives in, or null outside one. Used to keep a form set
+     * from spanning a dialog boundary - see `withinSameDialog`.
+     */
+    get dialogRef(): MatDialogRef<any>;
+    ngOnInit(): void;
     ngAfterContentInit(): void;
     get destroy$(): Observable<void>;
     ngOnDestroy(): void;
     get buttons(): QueryList<FsButtonDirective>;
     get activeSubmitButton(): FsButtonDirective;
     set activeSubmitButton(button: FsButtonDirective);
+    /**
+     * Bring a tab group into this owner's unsaved-changes confirm.
+     *
+     * `_tabGroups` only reaches groups in this owner's projected content, so a group
+     * declared inside a child component's own template has to announce itself.
+     * `fsFormConfirmTabs` calls this - consumers never call it directly.
+     */
+    registerTabGroup(tabGroup: MatTabGroup): void;
     addButton(button: FsButtonDirective): void;
     removeButton(button: FsButtonDirective): void;
+    /**
+     * Everything here acts on the form set as a whole, so exactly one thing may
+     * register it. A form linked into a parent defers to that parent; every form
+     * inside a container defers to the container. Registering twice would put two
+     * confirms on the same backdrop click and two handlers on the same Ctrl+S.
+     */
+    protected _registerOwnerLifecycle(): void;
+    /** The half of the same ownership that needs projected content resolved. */
+    protected _registerOwnerContentLifecycle(): void;
+    /**
+     * Whether the element is inside what this owner covers. Overridden by the
+     * container, whose own element is a poor proxy: it may be an `<ng-container>`,
+     * which is a comment node and contains nothing.
+     */
+    protected _containsElement(el: Element): boolean;
+    protected _nodeContains(root: Node, el: Element): boolean;
+    protected _formClose(): void;
+    private _listenWindowClose;
+    private _activeDialog;
+    private _listenHotKeys;
+    private _registerConfirmDialogBackdropEscape;
+    private _registerDrawerClose;
+    private _registerConfirmDrawerClose;
     private _registerConfirmTabs;
     private _registerConfirmTabGroups;
     private _registerConfirmTabGroup;
+    private _registerCanDeactivateGuard;
+    private _cleanupCanDeactivate;
     abstract triggerSubmit(): void;
     abstract triggerConfirm(): Observable<ConfirmResult>;
+    abstract reset(): void;
+    abstract submit$(event?: SubmitEvent): Observable<SubmittedEvent>;
     static ɵfac: i0.ɵɵFactoryDeclaration<FsFormBaseDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FsFormBaseDirective, never, never, { "confirmTabs": { "alias": "confirmTabs"; "required": false; }; "tabGroup": { "alias": "tabGroup"; "required": false; }; }, {}, ["_tabGroups"], never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FsFormBaseDirective, never, never, { "confirmTabs": { "alias": "confirmTabs"; "required": false; }; "confirm": { "alias": "confirm"; "required": false; }; "confirmDialog": { "alias": "confirmDialog"; "required": false; }; "confirmDrawer": { "alias": "confirmDrawer"; "required": false; }; "confirmBrowser": { "alias": "confirmBrowser"; "required": false; }; "shortcuts": { "alias": "shortcuts"; "required": false; }; "deactivationGuard": { "alias": "deactivationGuard"; "required": false; }; }, {}, ["_tabGroups"], never, false, never>;
 }

package/app/directives/form-container/form-container.directive.d.ts

@@ -0,0 +1,80 @@
+import { Observable } from 'rxjs';
+import { ConfirmResult } from '../../enums';
+import { FormStatus } from '../../enums/form-status';
+import { FsFormOwner, SubmitEvent, SubmittedEvent } from '../../interfaces';
+import { FsFormBaseDirective } from '../form-base';
+import type { FsFormDirective } from '../form/form.directive';
+import * as i0 from "@angular/core";
+/**
+ * Bounds a set of forms without being one.
+ *
+ * An `fsForm` can only reach the forms nested inside it through DI, which forces
+ * a wrapper carrying `ngForm` around anything that needs to see them - and that
+ * wrapper then owns a real, empty `NgForm` whose control namespace every field
+ * below it falls into. A container has no `ngForm` and no controls. It only
+ * watches: forms register themselves as they mount, buttons resolve to it, and
+ * `fs-form-dialog-actions` reads Save-vs-Done off it. Put it on whatever element
+ * already frames the layout - or on an `<ng-container>` for no element at all.
+ *
+ * Forms in a container are siblings rather than nested, so on registration each
+ * one is linked into the first. That reproduces exactly the structure DI nesting
+ * builds, which is why validation, dirty state, the unsaved-changes confirm and
+ * the submit chain all span a container without any of that machinery knowing
+ * containers exist.
+ *
+ * A form marked `[link]="false"` never registers, so an instant-save panel stays
+ * out of the set the same way it does when nested.
+ */
+export declare class FsFormContainerDirective extends FsFormBaseDirective implements FsFormOwner {
+    private _forms;
+    private _formsChange$;
+    /** The forms registered into this container, in registration order. */
+    get forms(): FsFormDirective[];
+    /**
+     * The form the rest of the set is linked into, or null while the container
+     * holds none - an open tab that has nothing to save, say.
+     */
+    get rootForm(): FsFormDirective;
+    /** Emits whenever a form registers or deregisters. */
+    get formsChange$(): Observable<void>;
+    get linkedForms(): FsFormDirective[];
+    /**
+     * True when anything in the container has a submit handler - i.e. there is
+     * something for a Save button to do. `fs-form-dialog-actions` reads this to
+     * swap Save for Done as the mounted tab changes, so a dialog never has to keep
+     * a list of which tabs happen to be savable.
+     */
+    get submits(): boolean;
+    get dirtyLinked(): boolean;
+    get submitting(): boolean;
+    /**
+     * Emits whenever the set's dirty state may have moved, including when the set
+     * itself changes. Anything rendering off it - the dialog actions - subscribes
+     * once and outlives any particular form, so this has to follow the root across
+     * tab switches rather than bind to whichever form happened to be first.
+     */
+    get dirtyChange$(): Observable<void>;
+    get submitted$(): Observable<SubmittedEvent>;
+    get status$(): Observable<FormStatus>;
+    /**
+     * Take a form into the container. Called by the form on init - consumers never
+     * call it directly.
+     */
+    registerForm(form: FsFormDirective): void;
+    /**
+     * Material attaches an incoming tab body before it detaches the outgoing one,
+     * so losing the root is a routine reshuffle rather than teardown. Re-elect and
+     * re-link the survivors instead of leaving them pointing at a dead root, and
+     * only let go of forms actually registered - clearing unconditionally would
+     * drop the form that just arrived.
+     */
+    deregisterForm(form?: FsFormDirective): void;
+    triggerSubmit(): void;
+    triggerConfirm(): Observable<ConfirmResult>;
+    submit$(event?: SubmitEvent): Observable<SubmittedEvent>;
+    reset(): void;
+    validate(): void;
+    protected _containsElement(el: Element): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FsFormContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FsFormContainerDirective, "fs-form-container,[fsFormContainer]", ["fsFormContainer"], {}, {}, never, never, true, never>;
+}

package/app/directives/form-container/index.d.ts

@@ -0,0 +1 @@
+export * from './form-container.directive';

package/app/directives/index.d.ts

@@ -1,5 +1,6 @@
+export * from './confirm-tabs';
 export * from './form';
-export * from './form-group';
+export * from './form-container';
 export * from './validators';
 export * from './button.directive';
 export * from './form-dialog-close.directive';

package/app/fs-form.module.d.ts

@@ -34,10 +34,11 @@ import * as i31 from "./directives/button.directive";
 import * as i32 from "./directives/submit-button.directive";
 import * as i33 from "./directives/form-template.directive";
 import * as i34 from "./directives/form-template-outlet.directive";
-import * as i35 from "./directives/form-group/form-group.directive";
+import * as i35 from "./directives/form-container/form-container.directive";
+import * as i36 from "./directives/confirm-tabs/confirm-tabs.directive";
 export declare class FsFormModule {
     static forRoot(): ModuleWithProviders<FsFormModule>;
     static ɵfac: i0.ɵɵFactoryDeclaration<FsFormModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<FsFormModule, never, [typeof i1.CommonModule, typeof i2.FormsModule, typeof i3.MatButtonModule, typeof i4.MatDialogModule, typeof i4.MatDialogModule, typeof i5.FsDialogModule, typeof i6.FsFormDirective, typeof i7.FsControlDirective, typeof i8.FsFormRequiredDirective, typeof i9.FsFormMinDirective, typeof i10.FsFormMaxDirective, typeof i11.FsFormMinLengthDirective, typeof i12.FsFormMaxLengthDirective, typeof i13.FsFormEmailDirective, typeof i14.FsFormEmailsDirective, typeof i15.FsFormPhoneDirective, typeof i16.FsFormCompareDirective, typeof i17.FsFormIntegerDirective, typeof i18.FsFormNumericDirective, typeof i19.FsFormPatternDirective, typeof i20.FsFormFunctionDirective, typeof i21.FsFormDateRangeDirective, typeof i22.FsFormGreaterDirective, typeof i23.FsFormGreaterEqualDirective, typeof i24.FsFormLesserDirective, typeof i25.FsFormLesserEqualDirective, typeof i26.FsFormUrlDirective, typeof i27.FsFormDialogCloseDirective, typeof i28.FsFormValidateDirective, typeof i29.FsFormDialogActionsComponent, typeof i30.FsFormNoFsValidatorsDirective, typeof i31.FsButtonDirective, typeof i32.FsSubmitButtonDirective, typeof i33.FsFormTemplateDirective, typeof i33.FsFormTemplateDirective, typeof i34.FsFormTemplateOutletDirective, typeof i35.FsFormGroupDirective], [typeof i6.FsFormDirective, typeof i7.FsControlDirective, typeof i8.FsFormRequiredDirective, typeof i9.FsFormMinDirective, typeof i10.FsFormMaxDirective, typeof i11.FsFormMinLengthDirective, typeof i12.FsFormMaxLengthDirective, typeof i13.FsFormEmailDirective, typeof i14.FsFormEmailsDirective, typeof i15.FsFormPhoneDirective, typeof i16.FsFormCompareDirective, typeof i17.FsFormIntegerDirective, typeof i18.FsFormNumericDirective, typeof i19.FsFormPatternDirective, typeof i20.FsFormFunctionDirective, typeof i21.FsFormDateRangeDirective, typeof i22.FsFormGreaterDirective, typeof i23.FsFormGreaterEqualDirective, typeof i24.FsFormLesserDirective, typeof i25.FsFormLesserEqualDirective, typeof i26.FsFormUrlDirective, typeof i27.FsFormDialogCloseDirective, typeof i28.FsFormValidateDirective, typeof i29.FsFormDialogActionsComponent, typeof i30.FsFormNoFsValidatorsDirective, typeof i31.FsButtonDirective, typeof i32.FsSubmitButtonDirective, typeof i33.FsFormTemplateDirective, typeof i33.FsFormTemplateDirective, typeof i34.FsFormTemplateOutletDirective, typeof i35.FsFormGroupDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FsFormModule, never, [typeof i1.CommonModule, typeof i2.FormsModule, typeof i3.MatButtonModule, typeof i4.MatDialogModule, typeof i4.MatDialogModule, typeof i5.FsDialogModule, typeof i6.FsFormDirective, typeof i7.FsControlDirective, typeof i8.FsFormRequiredDirective, typeof i9.FsFormMinDirective, typeof i10.FsFormMaxDirective, typeof i11.FsFormMinLengthDirective, typeof i12.FsFormMaxLengthDirective, typeof i13.FsFormEmailDirective, typeof i14.FsFormEmailsDirective, typeof i15.FsFormPhoneDirective, typeof i16.FsFormCompareDirective, typeof i17.FsFormIntegerDirective, typeof i18.FsFormNumericDirective, typeof i19.FsFormPatternDirective, typeof i20.FsFormFunctionDirective, typeof i21.FsFormDateRangeDirective, typeof i22.FsFormGreaterDirective, typeof i23.FsFormGreaterEqualDirective, typeof i24.FsFormLesserDirective, typeof i25.FsFormLesserEqualDirective, typeof i26.FsFormUrlDirective, typeof i27.FsFormDialogCloseDirective, typeof i28.FsFormValidateDirective, typeof i29.FsFormDialogActionsComponent, typeof i30.FsFormNoFsValidatorsDirective, typeof i31.FsButtonDirective, typeof i32.FsSubmitButtonDirective, typeof i33.FsFormTemplateDirective, typeof i33.FsFormTemplateDirective, typeof i34.FsFormTemplateOutletDirective, typeof i35.FsFormContainerDirective, typeof i36.FsFormConfirmTabsDirective], [typeof i6.FsFormDirective, typeof i7.FsControlDirective, typeof i8.FsFormRequiredDirective, typeof i9.FsFormMinDirective, typeof i10.FsFormMaxDirective, typeof i11.FsFormMinLengthDirective, typeof i12.FsFormMaxLengthDirective, typeof i13.FsFormEmailDirective, typeof i14.FsFormEmailsDirective, typeof i15.FsFormPhoneDirective, typeof i16.FsFormCompareDirective, typeof i17.FsFormIntegerDirective, typeof i18.FsFormNumericDirective, typeof i19.FsFormPatternDirective, typeof i20.FsFormFunctionDirective, typeof i21.FsFormDateRangeDirective, typeof i22.FsFormGreaterDirective, typeof i23.FsFormGreaterEqualDirective, typeof i24.FsFormLesserDirective, typeof i25.FsFormLesserEqualDirective, typeof i26.FsFormUrlDirective, typeof i27.FsFormDialogCloseDirective, typeof i28.FsFormValidateDirective, typeof i29.FsFormDialogActionsComponent, typeof i30.FsFormNoFsValidatorsDirective, typeof i31.FsButtonDirective, typeof i32.FsSubmitButtonDirective, typeof i33.FsFormTemplateDirective, typeof i33.FsFormTemplateDirective, typeof i34.FsFormTemplateOutletDirective, typeof i35.FsFormContainerDirective, typeof i36.FsFormConfirmTabsDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<FsFormModule>;
 }

package/app/helpers/index.d.ts

@@ -1 +1,2 @@
 export * from './confirm-result-continue';
+export * from './within-same-dialog';

package/app/helpers/within-same-dialog.d.ts

@@ -0,0 +1,18 @@
+import { MatDialogRef } from '@angular/material/dialog';
+import type { FsFormBaseDirective } from '../directives/form-base';
+/**
+ * Whether an owner found through DI belongs to the same dialog as whoever found
+ * it - and may therefore be joined, or driven by a button.
+ *
+ * A form set must never span a dialog boundary. Owners are resolved by walking
+ * the element injector, and CDK parents a dialog opened with `viewContainerRef`
+ * to the opener's injector, so a dialog opened from inside another dialog's form
+ * would otherwise register into that form's set: the outer footer would flip to
+ * Save the moment the inner dialog opened and would then submit the inner form,
+ * while the inner dialog - no longer the owner of its own set - would stop
+ * confirming its unsaved changes on backdrop click.
+ *
+ * Identity of the `MatDialogRef` is the test: everything inside one dialog
+ * injects the same instance, and everything outside any dialog gets null.
+ */
+export declare function withinSameDialog(owner: FsFormBaseDirective, dialogRef: MatDialogRef<any>): boolean;

package/app/interfaces/form-owner.d.ts

@@ -0,0 +1,17 @@
+import { Observable } from 'rxjs';
+import type { FsFormDirective } from '../directives/form/form.directive';
+import { ConfirmConfig } from './confirm-config';
+import { SubmitEvent } from './submit-event';
+import { SubmittedEvent } from './submitted-event';
+/**
+ * What the unsaved-changes confirm and the route guard need from whatever owns a
+ * set of forms. Both an `fsForm` at the root of its linked set and an
+ * `fsFormContainer` holding several satisfy it, so neither caller has to know
+ * which of the two it was handed.
+ */
+export interface FsFormOwner {
+    confirm: ConfirmConfig | boolean;
+    linkedForms: FsFormDirective[];
+    reset(): void;
+    submit$(event?: SubmitEvent): Observable<SubmittedEvent>;
+}

package/app/interfaces/index.d.ts

@@ -2,3 +2,4 @@ export * from './submit-event';
 export * from './submitted-event';
 export * from './confirm-config';
 export * from './confirm-tab-group';
+export * from './form-owner';

package/app/services/fsform.service.d.ts

@@ -1,16 +1,16 @@
 import { Type } from '@angular/core';
 import { Observable } from 'rxjs';
-import type { FsFormDirective } from '../directives/form/form.directive';
 import { ConfirmResult } from '../enums';
+import { FsFormOwner } from '../interfaces';
 import * as i0 from "@angular/core";
 export declare class FsForm {
     private _formDirectiveStore;
     private _dialog;
-    registerFormDirective(routeComponent: Type<any>, directive: FsFormDirective): void;
-    getFormDirectives(routeComponent: any): FsFormDirective[];
+    registerFormDirective(routeComponent: Type<any>, directive: FsFormOwner): void;
+    getFormDirectives(routeComponent: any): FsFormOwner[];
     removeFormDirective(routeComponent: any): void;
-    hasChanges(form: FsFormDirective): boolean;
-    confirmUnsaved(form: FsFormDirective): Observable<ConfirmResult>;
+    hasChanges(form: FsFormOwner): boolean;
+    confirmUnsaved(form: FsFormOwner): Observable<ConfirmResult>;
     static ɵfac: i0.ɵɵFactoryDeclaration<FsForm, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<FsForm>;
 }