@quadrel-enterprise-ui/framework 19.8.0 → 20.0.1

package/lib/page/page.component.d.ts

@@ -1,452 +0,0 @@
-import { AfterViewInit, EventEmitter, OnChanges, OnDestroy, OnInit, QueryList, SimpleChanges } from '@angular/core';
-import { DialogRef } from '@angular/cdk/dialog';
-import { BehaviorSubject, Observable } from 'rxjs';
-import { QdDialogService } from '../dialog/dialog.module';
-import { QdPageStepperAdapterDirective } from '../page-stepper/adaptors/page-stepper-adapter.directive';
-import { QdPageStepperComponent } from '../page-stepper/page-stepper.component';
-import { QdPageTabsAdapterDirective } from '../page-tabs/adaptors/page-tabs-adapter.directive';
-import { QdPageTabsComponent } from '../page-tabs/page-tabs.component';
-import { QdSectionComponent } from '../section/section.component';
-import { QdPageControlPanelComponent } from './control-panel/page-control-panel.component';
-import { QdPageInfoBannerComponent } from './info-banner/page-info-banner.component';
-import { QdInspectOperationMode, QdPageConfig } from './model/page-config.interface';
-import { QdFormGroupManagerService } from './shared/services/form-group-manager.service';
-import { QdPageFooterService } from './shared/services/page-footer.service';
-import { QdPageStoreService } from './shared/services/page-store.service';
-import { QdPageSubmitActionService } from './shared/services/page-submit-action.service';
-import * as i0 from "@angular/core";
-/**
- * **QdPage** serves as the central structural element within the hierarchy under the **QdShell**.
- * Integration is done through the Angular Routing Module, and QdPage is designed to be responsive across various screen sizes right out of the box.
- *
- * #### **Page Types**
- *
- * QdPage uses page types to decide how the page looks and works. Each page type has its own settings and actions.
- *
- * - **overview**: Displays a summary or a list of objects, providing an overview of multiple business cases.
- * - **create**: Allows the creation of a new object, representing a business case.
- * - **inspect**: Enables viewing, editing, and executing additional actions related to the object, which also represents a business case.
- * - **custom**: Provides a way to implement unique functionality that doesn’t fit the other predefined page types.
- *
- * **Note that the 'custom' page type should be used only as a fallback for very specific cases. If you encounter such a situation, please contact the Quadrel team.**
- *
- * #### **Facets**
- *
- * These are extra pieces of information shown in the page header. They give context specific to the current object model being viewed or edited. There are several types of facets, including `status`, `value`, `criticality`, `references`, `progress`, `date`, `singleSelect`, and `multiSelect`. Each type has its own options. For more details, see the `QdPageHeaderFacet` interface.
- *
- * #### **Context**
- *
- * The `context` acts as a filter that can be selected on the overview page and provides the business context, which remains consistent throughout the entire application. On create and inspect pages, the context is displayed as read-only. For more details, check the dedicated chapter in Storybook.
- *
- *
- * #### **Page Info Banners**
- *
- * To insert a page info banner under the page header, just put a `qd-page-info-banner` component inside the `qd-page`. Multiple consecutive info banners of the same type will be merged into one banner container. Page info banners have the same appearance like notifications.
- *
- * #### **Control Panel**
- *
- * The control panel is located on the right side of the page and is used to display additional information and functions relevant to a specific business case, which is linked to a specific object model. For further information, please consult the dedicated chapter in Storybook.
- *
- * #### **Actions**
- *
- * These are interactive elements that perform specific functions. Functions for these actions can be set up through configurations. Custom actions can be added to any page type. Additionally, all actions can be configured and customized with your own text, which will override the default texts.
- *
- * Please check the relevant interfaces for each page type: `QdPageConfigOverview`, `QdPageConfigCreate`, `QdPageConfigInspect`, and `QdPageConfigCustom`.
- *
- * #### **Validation/Parameterization**
- *
- * Validation and parameterization are covered in a dedicated chapter in the Storybook. Please check the "Validation" section for more information.
- *
- * #### **Resolver**
- *
- * Using a resolver to fetch page object data is essential to the page concept. Add the resolver to the component's providers and use the `QD_PAGE_OBJECT_RESOLVER_TOKEN` token. This approach enables type safety and user feedback by effectively managing the necessary data for the page.
- *
- * ```ts
- * interface MyObjectModel {
- *   // Metadata displayed in the ObjectHeader
- *   state: MyState;
- *   countryOfDestination: MyCountryOfDestination;
- *   // Appears not in the ObjectHeader
- *   payload: MyPayload;
- * }
- *
- * type MyObjectMetadata = 'state' | 'countryOfDestination';
- *
- * @Injectable()
- * class MyObjectModelResolver implements QdPageObjectResolver<MyObjectModel> {
- *   constructor(private http: HttpClient) {}
- *
- *   resolve(): Observable<MyObjectModel> {
- *     return this.http
- *       .get<MyObjectModel>('my-api')
- *       .pipe(tap((data: MyObjectModel) => doSomethingWith(data)));
- *   }
- * }
- *
- * @Component({
- *   selector: 'my-page',
- *   templateUrl: './my-page.component.html',
- *   providers: [
- *     {
- *       provide: QD_PAGE_OBJECT_RESOLVER_TOKEN,
- *       useClass: MyObjectModelResolver
- *     }
- *   ]
- * })
- * class MyPageComponent {
- *   pageConfig: QdPageConfig<Pick<MyObjectModel, MyObjectMetadata>> = {
- *     title: { i18n: 'i18n.page.title' },
- *     pageType: 'inspect',
- *     headerFacets: [
- *       {
- *         name: 'status',
- *         label: {
- *           i18n: 'i18n.status.label'
- *         },
- *         options: {
- *           type: 'status'
- *         }
- *       },
- *       {
- *         name: 'countryOfDestination',
- *         label: {
- *           i18n: 'i18n.countryOfDestination.label'
- *         },
- *         options: {
- *           type: 'value'
- *         }
- *       }
- *     ],
- *     pageTypeConfig: {
- *       cancel: {
- *         handler: () => handleCancel()
- *       },
- *       save: {
- *         handler: (formValues) => handleSave(formValues)
- *       }
- *     }
- *   };
- * }
- * ```
- *
- * #### **Updating Facets**
- *
- * Typically, the values of the facets on a create or inspect page are set to read-only. However, there may be cases where, for example, a status change is needed, such as through a dialog. For this purpose, we have provided an update method. In the resolver service, define an empty method called `updateMetadata`. Inject this service using its type, and then call the `updateMetadata` method with the required parameter.
- *
- * **Please note: These values should not be modified directly within a QdPage.**
- *
- * ```ts
- * @Injectable()
- * class MyObjectModelResolver implements QdPageObjectResolver<MyObjectModel> {
- *   config: QdPageObjectResolverConfig = {
- *     // your configuration options here
- *   }
- *
- *   constructor(private http: HttpClient) {}
- *
- *   resolve(): Observable<MyObjectModel> {
- *     // your implementation here
- *   }
- *
- *   updateMetadata(metadata: Partial<MyObjectModel>) {
- *     // leave empty here & call in your component
- *   }
- * }
- *
- * @Component({
- *   // ...
- *   providers: [
- *     {
- *       provide: QD_PAGE_OBJECT_RESOLVER_TOKEN,
- *       useClass: MyObjectModelResolver
- *     }
- *   ]
- * })
- * class MyPageComponent {
- *   constructor(@Inject(QD_PAGE_OBJECT_RESOLVER_TOKEN) private objectResolver: MyObjectModelResolver) {}
- *
- *   updateStatus() {
- *     this.objectResolver.updateMetadata({ state: 'Updated' });
- *   }
- * }
- * ```
- *
- * #### **Overview Page**
- *
- * On an overview page, a list of business cases can be displayed. Typically, this is done in a **QdTable**, including filters and/or search options. There are actions that handle routing to the related detail pages, where the business cases, represented by a business object model, can be viewed, edited, or newly created.
- *
- * ```ts
- * const overviewPageConfig: QdPageConfig<MyObjectType> = {
- *   title: { i18n: 'i18n.my-page.title' },
- *   pageType: 'overview',
- *   pageTypeConfig: {
- *     customActions: [
- *       {
- *         i18n: 'i18n.custom.action',
- *         handler: () => doSomething()
- *       }
- *     ]
- *   }
- * };
- * ```
- *
- * ```html
- * <qd-page [config]="pageConfig">
- *   <qd-section [config]="sectionConfig">
- *     <qd-table [config]="tableConfig"></qd-table>
- *   </qd-section>
- * </qd-page>
- * ```
- *
- * To configure contexts for a page, you can easily set contexts in the configuration for the overview page. They are then selectable on the overview page:
- *
- * ```ts
- * const overviewPageConfig: QdPageConfig<MyObjectType> = {
- *   // ...
- *   contexts: [
- *     {
- *       id: 'typeOfTraffic',
- *       label: { i18n: 'Verkehrsart' },
- *       type: 'single',
- *       selected: {
- *         label: { i18n: 'Schiene' },
- *         value: 'rail'
- *       },
- *       options: [
- *         {
- *           value: 'rail',
- *           label: { i18n: 'Schiene' }
- *         },
- *         {
- *           value: 'air',
- *           label: { i18n: 'Luft' }
- *         }
- *       ]
- *     }
- *   ]
- *   // ...
- * };
- * ```
- *
- * #### **Create Page**
- *
- * On the create page, a new business case can be created. This page typically includes forms for entering data. The submit button is parameterized with the form data and is validated through the QdPageStepper.
- * The click on the submit button should submit the creation of the business case or object. You can define a specific handler in the submit button's configuration to create the object.
- * If only one step is needed, the single-step mode can be used. In single-step mode, the stepper is visually hidden and behaves like a **QdSection**.
- *
- * ```ts
- * const createPageConfig: QdPageConfig<MyObjectType> = {
- *   title: { i18n: 'i18n.page.title' },
- *   pageType: 'create',
- *   pageTypeConfig: {
- *     submit: {
- *       handler: (formValues) => handleSubmit(formValues)
- *     }
- *   }
- * };
- * ```
- *
- * ```html
- * <!-- For "Quick Add" use PageStepper in single-step mode -->
- * <qd-page [config]="pageConfig">
- *   <qd-page-stepper [config]="stepperConfig">
- *     <qd-page-step [config]="stepConfigOne">
- *       <qd-section [config]="sectionConfig">
- *         <qd-grid [config]="gridConfig" [formGroup]="myForms" qdConnectFormStateToPage="myForms">
- *           <!-- your qd-form-components here -->
- *         </qd-grid>
- *       </qd-section>
- *     </qd-page-step>
- *   </qd-page-stepper>
- * </qd-page>
- *
- * <!-- With PageStepper using multiple steps -->
- * <qd-page [config]="pageConfig">
- *   <qd-page-stepper [config]="stepperConfig">
- *     <qd-page-step [config]="stepConfigOne">
- *       <qd-section [config]="sectionConfig">
- *         <qd-grid [config]="gridConfig" [formGroup]="myFormsOne" qdConnectFormStateToPage="myFormsOne">
- *           <!-- your qd-form-components here -->
- *         </qd-grid>
- *       </qd-section>
- *     </qd-page-step>
- *     <qd-page-step [config]="stepConfigTwo">
- *       <qd-section [config]="sectionConfig">
- *         <qd-grid [config]="gridConfig" [formGroup]="myFormsTwo" qdConnectFormStateToPage="myFormsTwo">
- *           <!-- your qd-form-components here -->
- *         </qd-grid>
- *       </qd-section>
- *     </qd-page-step>
- *   </qd-page-stepper>
- * </qd-page>
- * ```
- *
- * To allow resolving asynchronous operations when going to next step, you can provide a resolver of type QdPageStepResolver:
- *
- * ```ts
- * class MyResolver implements QdPageStepResolver {
- *   ...
- *
- *   resolve(index: number): Observable<void> {
- *     return this.http.post("next-step.com");
- *   }
- * }
- *
- * @Component({
- *   selector: 'qd-ui-page-create',
- *   templateUrl: './create.component.html',
- *   providers: [
- *     {
- *       provide: QD_PAGE_STEP_RESOLVER_TOKEN,
- *       useClass: PageStepResolver
- *     }
- *   ]
- * })
- * export class CreateComponent {
- * ```
- *
- * #### **Inspect Page**
- *
- * On an inspect page, a specific business case is displayed and may be edited or submitted. Depending on your needs you can hide the submit button.
- * In contrast to a create page, an existing object is shown and potentially updated.
- *
- * The page operates in one of two modes - `view` or `edit` - as defined by the `operationMode` configuration key.
- *
- * The `viewonly` behavior defined by the operation mode is automatically propagated to all nested QdSection components that are part of a QLS,
- * as well as to functional patterns such as QdTable, QdTree, QdFileCollector, and QdQuickEdit.
- * All forms are rendered either in viewonly or editable mode accordingly.
- *
- * This behavior can be explicitly overridden in each component’s configuration - for example, to allow certain fields to remain editable.
- *
- * - **view**: A submit action can optionally be added for process-related operations such as status updates.
- *   The action receives the current form values and supports validation and parameterization.
- *
- * - **edit**: Typically includes a save button to persist changes made in editable fields.
- *
- * ```ts
- * const inspectPageConfig: QdPageConfig<MyObjectType> = {
- *   title: { i18n: 'i18n.page.title' },
- *   pageType: 'inspect',
- *   pageTypeConfig: {
- *     operationMode: 'edit',
- *     cancel: {
- *       handler: () => handleCancel()
- *     },
- *     save: {
- *       handler: (formValues) => handleSave(formValues)
- *     }
- *   }
- * };
- * ```
- *
- * ```html
- * <!-- with Section -->
- * <qd-page [config]="pageConfig">
- *   <qd-section [config]="sectionConfig">
- *     <qd-grid [config]="gridConfig" [formGroup]="myForms" qdConnectFormStateToPage="myForms">
- *       <!-- your qd-form-components here -->
- *     </qd-grid>
- *   </qd-section>
- * </qd-page>
- *
- * <!-- with PageTabs -->
- * <qd-page [config]="pageConfig">
- *   <qd-page-tabs [config]="stepperConfig">
- *     <qd-page-tab [config]="tabConfigOne">
- *       <qd-section [config]="sectionConfig">
- *         <qd-grid [config]="gridConfig" [formGroup]="myFormsOne" qdConnectFormStateToPage="myFormsOne">
- *           <!-- your qd-form-components here -->
- *         </qd-grid>
- *       </qd-section>
- *     </qd-page-tab>
- *     <qd-page-tab [config]="tabConfigTwo">
- *       <qd-section [config]="sectionConfig">
- *         <qd-grid [config]="gridConfig" [formGroup]="myFormsTwo" qdConnectFormStateToPage="myFormsTwo">
- *           <!-- your qd-form-components here -->
- *         </qd-grid>
- *       </qd-section>
- *     </qd-page-tab>
- *   </qd-page-tabs>
- * </qd-page>
- * ```
- *
- * #### **Custom Page**
- *
- * ```ts
- * const customPageConfig: QdPageConfig<MyObjectType> = {
- *   title: { i18n: 'i18n.page.title' },
- *   pageType: 'custom',
- *   pageTypeConfig: {
- *     customActions: [
- *       {
- *         i18n: 'i18n.custom.action',
- *         handler: () => doSomething()
- *       }
- *     ]
- *   }
- * };
- * ```
- *
- * ```html
- * <qd-page [config]="pageConfig">
- *   <!-- Place content here that doesn’t fit the other page types -->
- * </qd-page>
- * ```
- */
-export declare class QdPageComponent<T extends object> implements OnInit, OnChanges, AfterViewInit, OnDestroy {
-    private readonly pageStoreService;
-    private readonly footerService;
-    private readonly formGroupManagerService;
-    private readonly submitActionService;
-    private readonly dialog;
-    private bottomOffset$?;
-    private readonly dialogRef?;
-    /**
-     * This property defines the configuration for the QdPage component, including the page type,
-     * title, and specific configurations for each type of page.
-     */
-    config: QdPageConfig<T>;
-    /**
-     * A static test ID for integration tests can be set. <br />
-     * The value for the HTML attribute [data-test-id].
-     */
-    testId?: string;
-    /**
-     * This event is emitted when the operation mode of the inspect page is changed.
-     */
-    operationModeChanged: EventEmitter<QdInspectOperationMode>;
-    sections: QueryList<QdSectionComponent>;
-    controlPanel: QdPageControlPanelComponent;
-    stepperComponent?: QdPageStepperComponent;
-    tabsComponent?: QdPageTabsComponent;
-    stepperAdapterDirective?: QdPageStepperAdapterDirective;
-    tabsAdapterDirective?: QdPageTabsAdapterDirective;
-    infoBanners: QueryList<QdPageInfoBannerComponent>;
-    footerHasContent$: Observable<boolean>;
-    isFooterVisible: boolean | undefined;
-    projectionGuardMessage: string;
-    private _isInitialized;
-    private _destroyed$;
-    get isControlPanelVisible(): boolean;
-    get isControlPanelBroad(): boolean;
-    get hasNavigation(): boolean;
-    get footerVisible(): boolean | undefined;
-    get hasInfoBanners(): boolean;
-    constructor(pageStoreService: QdPageStoreService<T>, footerService: QdPageFooterService, formGroupManagerService: QdFormGroupManagerService, submitActionService: QdPageSubmitActionService, dialog: QdDialogService, bottomOffset$?: BehaviorSubject<number>, dialogRef?: DialogRef<unknown>);
-    ngOnInit(): void;
-    ngOnChanges(changes: SimpleChanges): void;
-    ngAfterViewInit(): void;
-    ngOnDestroy(): void;
-    private checkConfigValidity;
-    private setupCreatePageFooterActions;
-    private handleCancelActionWithFormChanges;
-    private initSaveDraftFooterAction;
-    private updateInspectPageOperationMode;
-    private generateFooterActionHandler;
-    private setupSubmitActionValidation;
-    private initSubmitValidation;
-    private setupPageDialogCloseContract;
-    static ɵfac: i0.ɵɵFactoryDeclaration<QdPageComponent<any>, [null, null, null, null, null, { optional: true; }, { optional: true; }]>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<QdPageComponent<any>, "qd-page", never, { "config": { "alias": "config"; "required": true; }; "testId": { "alias": "data-test-id"; "required": false; }; }, { "operationModeChanged": "operationModeChanged"; }, ["controlPanel", "stepperComponent", "tabsComponent", "stepperAdapterDirective", "tabsAdapterDirective", "sections", "infoBanners"], ["qd-page-info-banner", "qd-page-stepper", "[qdPageStepperAdapter]", "qd-page-tabs", "[qdPageTabsAdapter]", "qd-section", "[qdSectionAdapter]", "[qdPageFooter]", "qd-page-control-panel", "*"], false, never>;
-}
-//# sourceMappingURL=page.component.d.ts.map

package/lib/page/page.component.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"page.component.d.ts","sourceRoot":"","sources":["../../../../libs/qd-ui/src/lib/page/page.component.ts"],"names":[],"mappings":"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"}

package/lib/page/page.module.d.ts

@@ -1,53 +0,0 @@
-import { QdPageControlPanelComponent } from './control-panel/page-control-panel.component';
-import { QdPageFooterComponent } from './footer/page-footer.component';
-import { QdPageInfoBannerComponent } from './info-banner/page-info-banner.component';
-import { QdInspectOperationMode, QdPageConfig, QdPageConfigCreate, QdPageConfigCustom, QdPageConfigInspect, QdPageConfigOverview, QdPageTypeCreateConfig, QdPageTypeCustomConfig, QdPageTypeInspectConfig, QdPageTypeOverviewConfig } from './model/page-config.interface';
-import { QdPageControlPanelConfig } from './model/page-control-panel-config.interface';
-import { QdPageInfoBannerConfig } from './model/page-info-banner.interface';
-import { QD_PAGE_OBJECT_RESOLVER_TOKEN, QdPageObjectResolver, QdPageObjectResolverConfig } from './model/page-object-resolver';
-import { QdPageComponent } from './page.component';
-import { QdConnectFormStateToPageDirective } from './shared/directives/connect-form-state-to-page.directive';
-import { QdContextSelection, QdContextService } from './shared/services/context.service';
-import { QdPageStoreService } from './shared/services/page-store.service';
-import * as i0 from "@angular/core";
-import * as i1 from "./page.component";
-import * as i2 from "./footer/page-footer.component";
-import * as i3 from "./object-header/page-object-header.component";
-import * as i4 from "./control-panel/page-control-panel.component";
-import * as i5 from "./object-header/facets/single-select-facet/single-select-facet.component";
-import * as i6 from "./object-header/facets/multi-select-facet/multi-select-facet.component";
-import * as i7 from "./object-header/facets/date-facet/date-facet.component";
-import * as i8 from "./object-header/facets/value-facet/value-facet.component";
-import * as i9 from "./object-header/facets/status-facet/status-facet.component";
-import * as i10 from "./object-header/dynamic-facet/dynamic-facet.component";
-import * as i11 from "./object-header/dynamic-facet/dynamic-facet.directive";
-import * as i12 from "./object-header/facets/crititcality-facet/criticality-facet.component";
-import * as i13 from "./object-header/facets/progress-facet/progress-facet.component";
-import * as i14 from "./object-header/facets/references-facet/references-facet.component";
-import * as i15 from "./shared/directives/connect-form-state-to-page.directive";
-import * as i16 from "./footer/page-footer-custom-content.directive";
-import * as i17 from "./object-header/context-select-dialog/context-select-dialog.component";
-import * as i18 from "./cancel-confirmation-dialog/page-cancel-confirmation-dialog.component";
-import * as i19 from "./info-banner/page-info-banner.component";
-import * as i20 from "@angular/common";
-import * as i21 from "@ngx-translate/core";
-import * as i22 from "../button/button.module";
-import * as i23 from "../chips/chips.module";
-import * as i24 from "../core/core.module";
-import * as i25 from "../dialog/dialog.module";
-import * as i26 from "../icon/icon.module";
-import * as i27 from "../progress-bar/progress-bar.module";
-import * as i28 from "../section/section.module";
-import * as i29 from "../spinner/spinner.module";
-import * as i30 from "../status-indicator/status-indicator.module";
-import * as i31 from "../table/table.module";
-import * as i32 from "../text-section/text-section.module";
-import * as i33 from "../search/search.module";
-import * as i34 from "../core/popover/popover.module";
-export { QD_PAGE_OBJECT_RESOLVER_TOKEN, QdConnectFormStateToPageDirective, QdContextSelection, QdContextService, QdInspectOperationMode, QdPageComponent, QdPageConfig, QdPageConfigCreate, QdPageConfigCustom, QdPageConfigInspect, QdPageConfigOverview, QdPageControlPanelComponent, QdPageControlPanelConfig, QdPageFooterComponent, QdPageInfoBannerComponent, QdPageInfoBannerConfig, QdPageObjectResolver, QdPageObjectResolverConfig, QdPageStoreService, QdPageTypeCreateConfig, QdPageTypeCustomConfig, QdPageTypeInspectConfig, QdPageTypeOverviewConfig };
-export declare class QdPageModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<QdPageModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<QdPageModule, [typeof i1.QdPageComponent, typeof i2.QdPageFooterComponent, typeof i3.QdPageObjectHeaderComponent, typeof i4.QdPageControlPanelComponent, typeof i5.QdSingleSelectFacetComponent, typeof i6.QdMultiSelectFacetComponent, typeof i7.QdDateFacetComponent, typeof i8.QdValueFacetComponent, typeof i9.QdStatusFacetComponent, typeof i10.QdDynamicFacetComponent, typeof i11.QdDynamicFacetDirective, typeof i12.QdCriticalityFacetComponent, typeof i13.QdProgressFacetComponent, typeof i14.QdReferencesFacetComponent, typeof i15.QdConnectFormStateToPageDirective, typeof i16.QdPageFooterCustomContentDirective, typeof i17.QdContextSelectDialogComponent, typeof i18.QdPageCancelConfirmationDialogComponent, typeof i19.QdPageInfoBannerComponent], [typeof i20.CommonModule, typeof i21.TranslateModule, typeof i22.QdButtonModule, typeof i22.QdButtonModule, typeof i23.QdChipModule, typeof i24.QdCoreModule, typeof i25.QdDialogModule, typeof i26.QdIconModule, typeof i27.QdProgressBarModule, typeof i28.QdSectionModule, typeof i29.QdSpinnerModule, typeof i30.QdStatusIndicatorModule, typeof i31.QdTableModule, typeof i32.QdTextSectionModule, typeof i33.QdSearchModule, typeof i34.QdPopoverModule], [typeof i1.QdPageComponent, typeof i2.QdPageFooterComponent, typeof i15.QdConnectFormStateToPageDirective, typeof i4.QdPageControlPanelComponent, typeof i16.QdPageFooterCustomContentDirective, typeof i19.QdPageInfoBannerComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<QdPageModule>;
-}
-//# sourceMappingURL=page.module.d.ts.map

package/lib/page/page.module.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"page.module.d.ts","sourceRoot":"","sources":["../../../../libs/qd-ui/src/lib/page/page.module.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,2BAA2B,EAAE,MAAM,8CAA8C,CAAC;AAE3F,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AACvE,OAAO,EAAE,yBAAyB,EAAE,MAAM,0CAA0C,CAAC;AACrF,OAAO,EACL,sBAAsB,EACtB,YAAY,EACZ,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,sBAAsB,EACtB,sBAAsB,EACtB,uBAAuB,EACvB,wBAAwB,EACzB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,wBAAwB,EAAE,MAAM,6CAA6C,CAAC;AACvF,OAAO,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AAC5E,OAAO,EACL,6BAA6B,EAC7B,oBAAoB,EACpB,0BAA0B,EAC3B,MAAM,8BAA8B,CAAC;AActC,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,iCAAiC,EAAE,MAAM,0DAA0D,CAAC;AAC7G,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AACzF,OAAO,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE1E,OAAO,EACL,6BAA6B,EAC7B,iCAAiC,EACjC,kBAAkB,EAClB,gBAAgB,EAChB,sBAAsB,EACtB,eAAe,EACf,YAAY,EACZ,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,2BAA2B,EAC3B,wBAAwB,EACxB,qBAAqB,EACrB,yBAAyB,EACzB,sBAAsB,EACtB,oBAAoB,EACpB,0BAA0B,EAC1B,kBAAkB,EAClB,sBAAsB,EACtB,sBAAsB,EACtB,uBAAuB,EACvB,wBAAwB,EACzB,CAAC;AAEF,qBAyDa,YAAY;yCAAZ,YAAY;0CAAZ,YAAY;0CAAZ,YAAY;CAAG"}

package/lib/page/shared/directives/connect-form-state-to-page.directive.d.ts

@@ -1,61 +0,0 @@
-import { OnDestroy, OnInit } from '@angular/core';
-import { FormGroupDirective } from '@angular/forms';
-import { QdFormGroupManagerService } from '../services/form-group-manager.service';
-import * as i0 from "@angular/core";
-/**
- * The **QdConnectFormStateToPageDirective** registers a `FormGroup` with the surrounding **QdPage**, enabling page-level aggregation of validity, change tracking, and value access for actions and unsaved-changes protection.
- *
- * ### **What it enables in QdPage**
- * - Aggregated validity across all registered form groups: submit/save can be disabled or show an “invalid form” hint until all registered groups are valid.
- * - Aggregated change detection across all registered form groups: cancel/close can trigger an “unsaved changes” confirmation when any registered group differs from the snapshot.
- * - Bundled values for handlers: page actions (e.g. submit/save) receive a keyed object { [key]: formGroupValue } when at least one form group is registered.
- *
- * ### **Snapshots / restore (unsaved changes)**
- * - Snapshots store only raw values and are taken by the page/header workflow (e.g. on init, edit, save). The confirmation dialog may restore all registered form groups from the snapshot.
- * - FormArrays are restored with dynamic resizing (length is aligned to snapshot before values are reset).
- *
- * ### **Page-Dialog (FullWidth) – Unsaved-Changes Close Contract**
- * - When a QdPage is embedded in a full-width page dialog, the directive’s registered form groups are also used to guard dialog closing.
- * - The page dialog can only close (e.g. via ESC or backdrop) if no unsaved changes are detected ($hasValuesChanged() is false).
- * - If there are unsaved changes, closing is blocked and the same unsaved-changes confirmation flow applies as for cancel / view-edit switching.
- *
- * It works with both `FormGroupDirective` and `QdQuickEditComponent` as the host. The directive requires a host that provides a FormGroupDirective (i.e. an element with [formGroup]). Otherwise it will log an error and not register anything.
- * The directive requires a unique key to identify each form group instance within the `QdFormGroupManagerService`. The key must be unique within the same QdPage instance; duplicate keys are rejected.
- *
- * ### **Usage with regular FormGroup**
- * ```html
- * <qd-page [config]="pageConfig">
- *   <qd-section [config]="sectionConfig">
- *     <qd-grid [formGroup]="myFormGroup" qdConnectFormStateToPage="myFormGroup">
- *       My Section
- *     </qd-grid>
- *   </qd-section>
- * </qd-page>
- * ```
- *
- * ### **Usage with QdQuickEditComponent**
- * ```html
- * <qd-page [config]="pageConfig">
- *   <qd-quick-edit
- *     qdConnectFormStateToPage="myQuickEditKey"
- *     [config]="quickEditConfig"
- *     [data]="quickEditData">
- *   </qd-quick-edit>
- * </qd-page>
- * ```
- */
-export declare class QdConnectFormStateToPageDirective implements OnInit, OnDestroy {
-    private formGroupManagerService;
-    private formGroupDirective;
-    /**
-     * This key is used to manage and track the form state within the page. It has to be unique for each FormGroup Connector. Use the property name of the FormGroup in your component.
-     */
-    qdConnectFormStateToPage: string;
-    constructor(formGroupManagerService: QdFormGroupManagerService, formGroupDirective: FormGroupDirective);
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    isValid(): boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<QdConnectFormStateToPageDirective, [{ optional: true; }, { optional: true; host: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<QdConnectFormStateToPageDirective, "[qdConnectFormStateToPage]", never, { "qdConnectFormStateToPage": { "alias": "qdConnectFormStateToPage"; "required": false; }; }, {}, never, never, false, never>;
-}
-//# sourceMappingURL=connect-form-state-to-page.directive.d.ts.map

package/lib/page/shared/directives/connect-form-state-to-page.directive.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"connect-form-state-to-page.directive.d.ts","sourceRoot":"","sources":["../../../../../../libs/qd-ui/src/lib/page/shared/directives/connect-form-state-to-page.directive.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,SAAS,EAAE,MAAM,EAAY,MAAM,eAAe,CAAC;AACpF,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,yBAAyB,EAAE,MAAM,wCAAwC,CAAC;;AAEnF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,qBAIa,iCAAkC,YAAW,MAAM,EAAE,SAAS;IAO3D,OAAO,CAAC,uBAAuB;IACvB,OAAO,CAAC,kBAAkB;IAPhD;;OAEG;IACM,wBAAwB,EAAG,MAAM,CAAC;gBAGrB,uBAAuB,EAAE,yBAAyB,EAC1C,kBAAkB,EAAE,kBAAkB;IAGpE,QAAQ,IAAI,IAAI;IAUhB,WAAW,IAAI,IAAI;IAInB,OAAO,IAAI,OAAO;yCAzBP,iCAAiC;2CAAjC,iCAAiC;CAsD7C"}

package/lib/page/shared/services/context.service.d.ts

@@ -1,51 +0,0 @@
-import { QdPageContextConfig, QdPageSelectedContext } from '../../model/page-config.interface';
-import * as i0 from "@angular/core";
-export interface QdContextSelection {
-    contextId: string;
-    value: QdPageSelectedContext | QdPageSelectedContext[];
-}
-/**
- * The **QdContextService** allows you to set / select contexts. Contexts are shown by default in read-only on inspect and create page.
- *
- * This service can be also used to restore contexts. Also contexts can be configured on overview pages.
- *
- * **Connect context to a table**
- * To make data in a table filtered by the context, you can easily connect it with the qdConnectToContext-Directive:
- *
- * ```html
- * <qd-page [config]="pageConfig">
- *   <qd-section [config]="sectionConfig">
- *     <qd-table [config]="tableConfig" qdConnectToContext></qd-table>
- *   </qd-section>
- * </qd-page>
- * ```
- */
-export declare class QdContextService {
-    private _configuredContexts;
-    private _values;
-    private _configuredContexts$;
-    values$: import("rxjs").Observable<QdContextSelection[]>;
-    contexts$: import("rxjs").Observable<{
-        context: QdPageContextConfig;
-        selection: QdContextSelection;
-    }[]>;
-    /**
-     * This method allows to configure contexts outside an overview page. If you don't have an overview page that configures the contexts, you can use this service to configure it.
-     * @param contexts the specific contexts.
-     */
-    initContexts(contexts: QdPageContextConfig[]): void;
-    /**
-     * This method selects a value for a context.
-     * @param contextId ID of the context that the selection should happen for
-     * @param selection The selection
-     */
-    setValue(contextId: string, selection: QdPageSelectedContext | QdPageSelectedContext[]): void;
-    /**
-     * This method clears the selection for a context.
-     * @param contextId ID of the context you want to clear.
-     */
-    clear(contextId: string): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<QdContextService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<QdContextService>;
-}
-//# sourceMappingURL=context.service.d.ts.map

package/lib/page/shared/services/context.service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.service.d.ts","sourceRoot":"","sources":["../../../../../../libs/qd-ui/src/lib/page/shared/services/context.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAC;;AAE/F,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,qBAAqB,GAAG,qBAAqB,EAAE,CAAC;CACxD;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAGa,gBAAgB;IAC3B,OAAO,CAAC,mBAAmB,CAAkD;IAC7E,OAAO,CAAC,OAAO,CAAiD;IAChE,OAAO,CAAC,oBAAoB,CAA2C;IAEvE,OAAO,kDAA+B;IAEtC,SAAS;;;SAOP;IAEF;;;OAGG;IACH,YAAY,CAAC,QAAQ,EAAE,mBAAmB,EAAE,GAAG,IAAI;IAOnD;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,qBAAqB,GAAG,qBAAqB,EAAE,GAAG,IAAI;IAc7F;;;OAGG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;yCAlDnB,gBAAgB;6CAAhB,gBAAgB;CAwD5B"}