@scion/workbench 18.0.0-beta.9 → 19.0.0-beta.2

package/lib/common/css-class.util.d.ts

@@ -0,0 +1,5 @@
+import { Signal } from '@angular/core';
+/**
+ * Tracks changes to the provided CSS classes and applies them to the given element.
+ */
+export declare function synchronizeCssClasses(element: HTMLElement, classes: Signal<string[]>): void;

package/lib/common/instanceof.pipe.d.ts

@@ -4,7 +4,7 @@ import * as i0 from "@angular/core";
  * Tests if the object is of the specified type. If so, returns the object, otherwise returns `null`.
  */
 export declare class InstanceofPipe implements PipeTransform {
-    transform<T>(object: any | undefined, type: Type<T>): T | null;
+    transform<T>(object: unknown | undefined, type: Type<T>): T | null;
     static ɵfac: i0.ɵɵFactoryDeclaration<InstanceofPipe, never>;
     static ɵpipe: i0.ɵɵPipeDeclaration<InstanceofPipe, "wbInstanceof", true>;
 }

package/lib/common/math.util.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns the value clamped to the inclusive range of min and max.
+ */
+export declare function clamp(value: number, minmax: {
+    min: number;
+    max: number;
+}): number;

package/lib/common/objects.util.d.ts

@@ -13,7 +13,7 @@ export declare const Objects: {
     /**
      * Like {@link Dictionaries.withoutUndefinedEntries}, but preserving the object data type.
      */
-    readonly withoutUndefinedEntries: <T_1>(object: T_1 & Record<string, unknown>) => T_1;
+    readonly withoutUndefinedEntries: <T>(object: T & Record<string, unknown>) => T;
     /**
      * Stringifies given object to matrix notation: a=b;c=d;e=f
      */

package/lib/desktop/desktop.directive.d.ts

@@ -0,0 +1,37 @@
+import * as i0 from "@angular/core";
+/**
+ * Directive to add a desktop to the workbench.
+ *
+ * The desktop is displayed when no view is open and the layout does not contain a navigated part.
+ *
+ * A desktop can provide instructions for working with the application, display a welcome page, or provide links to open views.
+ *
+ * Usage:
+ * Add this directive to an `<ng-template>` child of the `<wb-workbench>` component. The template content will be used as desktop content.
+ *
+ * ```html
+ * <wb-workbench>
+ *   <ng-template wbDesktop>
+ *     Welcome
+ *   </ng-template>
+ * </wb-workbench>
+ * ```
+ *
+ * > Using `@if` allows displaying the desktop based on a condition, e.g. the active perspective.
+ *
+ * For layouts with a main area, it is recommended to navigate the main area part instead:
+ * ```ts
+ * import {MAIN_AREA, provideWorkbench} from '@scion/workbench';
+ *
+ * provideWorkbench({
+ *   layout: factory => factory
+ *     .addPart(MAIN_AREA)
+ *     .navigatePart(MAIN_AREA, ['path/to/desktop'])
+ * });
+ * ```
+ */
+export declare class WorkbenchDesktopDirective {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<WorkbenchDesktopDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<WorkbenchDesktopDirective, "ng-template[wbDesktop]", never, {}, {}, never, never, true, never>;
+}

package/lib/desktop/public_api.d.ts

@@ -0,0 +1 @@
+export { WorkbenchDesktopDirective } from './desktop.directive';

package/lib/dialog/workbench-dialog.component.d.ts

@@ -4,7 +4,6 @@ import { WbMoveEvent } from './movable.directive';
 import { WbResizeEvent } from './resizable.directive';
 import { SciDimension } from '@scion/components/dimension';
 import * as i0 from "@angular/core";
-import * as i1 from "@angular/common";
 /**
  * Renders the workbench dialog.
  *
@@ -57,5 +56,5 @@ export declare class WorkbenchDialogComponent implements OnInit {
     onResize(event: WbResizeEvent): void;
     protected onHeaderDimensionChange(dimension: SciDimension): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<WorkbenchDialogComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<WorkbenchDialogComponent, "wb-dialog", never, {}, {}, never, never, true, [{ directive: typeof i1.NgClass; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WorkbenchDialogComponent, "wb-dialog", never, {}, {}, never, never, true, never>;
 }

package/lib/dialog/workbench-dialog.options.d.ts

@@ -9,8 +9,7 @@ export interface WorkbenchDialogOptions {
      *
      * **Example:**
      * ```ts
-     * @Input()
-     * public someInput: string;
+     * public someInput = input.required<string>();
      * ```
      */
     inputs?: {

package/lib/layout/grid-element/grid-element.component.d.ts

@@ -2,6 +2,7 @@ import { OnChanges, SimpleChanges } from '@angular/core';
 import { MPart, MTreeNode } from '../workbench-layout.model';
 import { ɵWorkbenchRouter } from '../../routing/ɵworkbench-router.service';
 import { WorkbenchLayoutService } from '../workbench-layout.service';
+import { PartId } from '../../part/workbench-part.model';
 import * as i0 from "@angular/core";
 /**
  * Renders a {@link MTreeNode} or {@link MPart}.
@@ -10,10 +11,7 @@ import * as i0 from "@angular/core";
  * Each node has two children, which can be either another node or a part (leaf). A node defines
  * a split layout in which the two children are arranged vertically or horizontally.
  *
- * Nodes are rendered as {@link SciSashboxComponent} and parts as {@link PartComponent} or
- * {@link MainAreaLayoutComponent}.
- *
- * @see WorkbenchLayoutComponent
+ * Nodes are rendered as {@link SciSashboxComponent} and parts as {@link PartComponent} or {@link MainAreaPartComponent}.
  */
 export declare class GridElementComponent implements OnChanges {
     private _workbenchRouter;
@@ -23,7 +21,7 @@ export declare class GridElementComponent implements OnChanges {
     children: ChildElement[];
     parentNodeId: string | undefined;
     nodeId: string | undefined;
-    partId: string | undefined;
+    partId: PartId | undefined;
     element: MTreeNode | MPart;
     constructor(_workbenchRouter: ɵWorkbenchRouter, _workbenchLayoutService: WorkbenchLayoutService);
     ngOnChanges(changes: SimpleChanges): void;

package/lib/layout/migration/model/workbench-layout-migration-v6.model.d.ts

@@ -0,0 +1,35 @@
+export interface MPartV6 {
+    type: 'MPart';
+    id: string;
+    views: MViewV6[];
+    activeViewId?: ViewIdV6;
+    structural: boolean;
+}
+export interface MTreeNodeV6 {
+    type: 'MTreeNode';
+    id: string;
+    child1: MTreeNodeV6 | MPartV6;
+    child2: MTreeNodeV6 | MPartV6;
+    ratio: number;
+    direction: 'column' | 'row';
+}
+export interface MPartGridV6 {
+    root: MTreeNodeV6 | MPartV6;
+    activePartId: string;
+}
+export interface MViewV6 {
+    id: ViewIdV6;
+    alternativeId?: string;
+    cssClass?: string[];
+    markedForRemoval?: true;
+    navigation?: {
+        id: string;
+        hint?: string;
+        data?: NavigationDataV6;
+        cssClass?: string[];
+    };
+}
+export type ViewIdV6 = `view.${number}`;
+export type NavigationDataV6 = {
+    [key: string]: unknown;
+};

package/lib/layout/migration/model/workbench-layout-migration-v7.model.d.ts

@@ -0,0 +1,37 @@
+export interface MPartV7 {
+    type: 'MPart';
+    id: PartIdV7;
+    alternativeId?: string;
+    views: MViewV7[];
+    activeViewId?: ViewIdV7;
+    structural: boolean;
+}
+export interface MTreeNodeV7 {
+    type: 'MTreeNode';
+    id: string;
+    child1: MTreeNodeV7 | MPartV7;
+    child2: MTreeNodeV7 | MPartV7;
+    ratio: number;
+    direction: 'column' | 'row';
+}
+export interface MPartGridV7 {
+    root: MTreeNodeV7 | MPartV7;
+    activePartId: PartIdV7;
+}
+export interface MViewV7 {
+    id: ViewIdV7;
+    alternativeId?: string;
+    cssClass?: string[];
+    markedForRemoval?: true;
+    navigation?: {
+        id: string;
+        hint?: string;
+        data?: NavigationDataV7;
+        cssClass?: string[];
+    };
+}
+export type PartIdV7 = `part.${string}`;
+export type ViewIdV7 = `view.${number}`;
+export type NavigationDataV7 = {
+    [key: string]: unknown;
+};

package/lib/layout/migration/workbench-layout-migration-v6.service.d.ts

@@ -0,0 +1,12 @@
+import { WorkbenchMigration } from '../../migration/workbench-migration';
+import * as i0 from "@angular/core";
+/**
+ * Migrates the workbench layout from version 5 to version 6.
+ *
+ * TODO [Angular 20] Remove migrator.
+ */
+export declare class WorkbenchLayoutMigrationV6 implements WorkbenchMigration {
+    migrate(json: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WorkbenchLayoutMigrationV6, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WorkbenchLayoutMigrationV6>;
+}

package/lib/layout/migration/workbench-layout-migration-v7.service.d.ts

@@ -0,0 +1,10 @@
+import { WorkbenchMigration } from '../../migration/workbench-migration';
+import * as i0 from "@angular/core";
+/**
+ * Migrates the workbench layout from version 6 to version 7.
+ */
+export declare class WorkbenchLayoutMigrationV7 implements WorkbenchMigration {
+    migrate(json: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WorkbenchLayoutMigrationV7, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WorkbenchLayoutMigrationV7>;
+}

package/lib/layout/public_api.d.ts

@@ -1,2 +1,3 @@
 export { WorkbenchLayout, ReferencePart, MAIN_AREA } from './workbench-layout';
+export { MAIN_AREA_INITIAL_PART_ID } from './ɵworkbench-layout';
 export { WorkbenchLayoutFactory } from './workbench-layout.factory';

package/lib/layout/stringifier.d.ts

@@ -1,11 +1,18 @@
 /**
  * Stringifies given data, exluding specified fields from serialization.
  *
- * To exclude a field, specify the path to the field in the object tree,
- * using the slash as delimiter. The path supports the asterisk (`*`) to match a
- * single segment or the globstar (`**`) to match multiple segments.
+ * @param data - Data to serialize to json.
+ * @param options - Controls how to serialize data.
+ * @param options.exclusions - Controls which fields to exclude from serialization.\
+ *                             To exclude a field, specify the path to the field in the object tree,
+ *                             using the slash as delimiter. The path supports the asterisk (`*`) to match a
+ *                             single segment or the globstar (`**`) to match multiple segments.
+ * @param options.sort - Controls if to sort the fields by name. Defaults to `false`.
  */
-export declare function stringify(data: unknown, exclusions?: Array<string | Exclusion>): string;
+export declare function stringify(data: unknown, options?: {
+    exclusions?: Array<string | Exclusion>;
+    sort?: true;
+}): string;
 /**
  * Describes a field to exclude from serialization.
  */
@@ -19,7 +26,7 @@ export interface Exclusion {
      * Tests if to exclude the resolved field, enabling extended checks if the field cannot be uniquely identified via the path.
      *
      * @param objectPath - path to the field in the object tree.
-     * @param key - key under with the field is associated in the parent object.
+     * @param key - key under which the field is associated in the parent object.
      * @param value - value of the field.
      */
     predicate: (objectPath: unknown[], key: string, value: unknown) => boolean;

package/lib/layout/workbench-layout.component.d.ts

@@ -1,6 +1,5 @@
-import { ɵWorkbenchLayout } from './ɵworkbench-layout';
-import { MPartGrid } from './workbench-layout.model';
 import { WbViewDropEvent } from '../view-dnd/view-drop-zone.directive';
+import { MPartGrid } from './workbench-layout.model';
 import * as i0 from "@angular/core";
 /**
  * Renders the layout of the workbench.
@@ -23,17 +22,16 @@ import * as i0 from "@angular/core";
  *                                   |             |                 +--------+-----------------------+
  *                                 MPart         MPart
  *                                (left)        (right)
- *
- * @see MainAreaLayoutComponent
  */
 export declare class WorkbenchLayoutComponent {
-    layout: ɵWorkbenchLayout | undefined;
-    protected grid: MPartGrid | undefined;
-    private _workbenchId;
-    private _viewDragService;
-    private _workbenchLayoutService;
-    constructor();
+    private readonly _workbenchId;
+    private readonly _viewDragService;
+    private readonly _workbenchLayoutService;
+    private readonly _logger;
+    protected readonly desktop: import("@angular/core").WritableSignal<import("@angular/core").TemplateRef<void> | undefined>;
+    protected readonly grid: import("@angular/core").Signal<MPartGrid | undefined>;
     protected onViewDrop(event: WbViewDropEvent): void;
+    protected onLegacyStartPageActivate(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<WorkbenchLayoutComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<WorkbenchLayoutComponent, "wb-workbench-layout", never, {}, {}, never, never, true, never>;
 }

package/lib/layout/workbench-layout.d.ts

@@ -1,8 +1,8 @@
 import { Commands, NavigationData, NavigationState } from '../routing/routing.model';
 import { ActivatedRoute } from '@angular/router';
 /**
- * The workbench layout is a grid of parts. Parts are aligned relative to each other. A part is a stack of views. Content is
- * displayed in views.
+ * The workbench layout is a grid of parts. Parts are aligned relative to each other. Each part is a stack of views. Content is
+ * displayed in views or parts.
  *
  * The layout can be divided into a main and a peripheral area, with the main area as the primary place for opening views.
  * The peripheral area arranges parts around the main area to provide navigation or context-sensitive assistance to support
@@ -19,7 +19,7 @@ export interface WorkbenchLayout {
     /**
      * Adds a part with the given id to this layout. Position and size are expressed relative to a reference part.
      *
-     * @param id - Unique id of the part. Use {@link MAIN_AREA} to add the main area.
+     * @param id - The id of the part to add.  Use {@link MAIN_AREA} to add the main area.
      * @param relativeTo - Specifies the reference part to lay out the part.
      * @param options - Controls how to add the part to the layout.
      * @param options.activate - Controls whether to activate the part. Default is `false`.
@@ -28,6 +28,64 @@ export interface WorkbenchLayout {
     addPart(id: string | MAIN_AREA, relativeTo: ReferencePart, options?: {
         activate?: boolean;
     }): WorkbenchLayout;
+    /**
+     * Navigates the specified part based on the provided array of commands and extras.
+     *
+     * Navigating a part displays content when its view stack is empty. A navigated part can still have views but won't display
+     * navigated content unless its view stack is empty. Views cannot be dragged into parts displaying navigated content, except
+     * for the main area part.
+     *
+     * A command can be a string or an object literal. A string represents a path segment, an object literal associates matrix parameters with the preceding segment.
+     * Multiple segments can be combined into a single command, separated by a forward slash.
+     *
+     * By default, navigation is absolute. Set `relativeTo` in extras for relative navigation.
+     *
+     * Usage:
+     * ```
+     * layout.navigatePart(partId, ['path', 'to', 'part', {param 'value'}]);
+     * layout.navigatePart(partId, ['path/to/part', {param: 'value'}]);
+     * ```
+     *
+     * @param id - Identifies the part for navigation.
+     * @param commands - Instructs the router which route to navigate to.
+     * @param extras - Controls navigation:
+     * @param extras.hint - Allows differentiation between routes with identical paths.
+     *                      Multiple parts can navigate to the same path but still resolve to different routes, e.g., the empty path route to maintain a clean URL.
+     *
+     *                      Example:
+     *                      ```ts
+     *                      import {canMatchWorkbenchPart} from '@scion/workbench';
+     *
+     *                      const routes = [
+     *                         {
+     *                           path: '',
+     *                           component: Part1Component,
+     *                           canMatch: [canMatchWorkbenchPart('hint-1')], // matches navigations with hint 'hint-1'
+     *                         },
+     *                         {
+     *                           path: '',
+     *                           component: Part2Component,
+     *                           canMatch: [canMatchWorkbenchPart('hint-2')], // matches navigations with hint 'hint-1'
+     *                         },
+     *                       ];
+     *                      ```
+     * @param extras.relativeTo - Specifies the route for relative navigation, supporting navigational symbols such as '/', './', or '../' in the commands.
+     * @param extras.data - Associates data with the navigation.
+     *                      Unlike matrix parameters, navigation data is stored in the layout and not added to the URL, allowing data to be passed to empty path navigations.
+     *                      Data must be JSON serializable. Data can be read from {@link WorkbenchPart.navigation.data}.
+     * @param extras.state - Passes state to the navigation.
+     *                       State is not persistent, unlike {@link data}; however, state is added to the browser's session history to support back/forward browser navigation.
+     *                       State can be read from {@link WorkbenchPart.navigation.state} or from the browser's session history via `history.state`.
+     * @param extras.cssClass - Specifies CSS class(es) to add to the part, e.g., to locate the part in tests.
+     * @return a copy of this layout with the part navigated.
+     */
+    navigatePart(id: string, commands: Commands, extras?: {
+        hint?: string;
+        relativeTo?: ActivatedRoute;
+        data?: NavigationData;
+        state?: NavigationState;
+        cssClass?: string | string[];
+    }): WorkbenchLayout;
     /**
      * Adds a view to the specified part.
      *
@@ -56,24 +114,41 @@ export interface WorkbenchLayout {
      *
      * Usage:
      * ```
-     * layout.navigateView(viewId, ['path', 'to', 'view', {param1: 'value1', param2: 'value2'}]);
-     * layout.navigateView(viewId, ['path/to/view', {param1: 'value1', param2: 'value2'}]);
+     * layout.navigateView(viewId, ['path', 'to', 'view', {param 'value'}]);
+     * layout.navigateView(viewId, ['path/to/view', {param: 'value'}]);
      * ```
      *
      * @param id - Identifies the view for navigation.
      * @param commands - Instructs the router which route to navigate to.
-     * @param extras - Controls navigation.
-     * @param extras.hint - Sets a hint to control navigation, e.g., for use in a `CanMatch` guard to differentiate between routes with an identical path.
-     *                      For example, views of the initial layout or a perspective are usually navigated to the empty path route to avoid cluttering the URL,
-     *                      requiring a navigation hint to differentiate between the routes. See {@link canMatchWorkbenchView} for an example.
+     * @param extras - Controls navigation:
+     * @param extras.hint - Allows differentiation between routes with identical paths.
+     *                      Multiple views can navigate to the same path but still resolve to different routes, e.g., the empty path route to maintain a clean URL.
      *                      Like the path, a hint affects view resolution. If set, the router will only navigate views with an equivalent hint, or if not set, views without a hint.
+     *
+     *                      Example route config matching routes based on the hint passed to the navigation:
+     *                      ```ts
+     *                      import {canMatchWorkbenchView} from '@scion/workbench';
+     *
+     *                      const routes = [
+     *                        {
+     *                          path: '',
+     *                          component: View1Component,
+     *                          canMatch: [canMatchWorkbenchView('hint-1')], // matches navigations with hint 'hint-1'
+     *                        },
+     *                        {
+     *                          path: '',
+     *                          component: View2Component,
+     *                          canMatch: [canMatchWorkbenchView('hint-2')], // matches navigations with hint 'hint-2'
+     *                        },
+     *                      ];
+     *                      ```
      * @param extras.relativeTo - Specifies the route for relative navigation, supporting navigational symbols such as '/', './', or '../' in the commands.
-     * @param extras.data - Associates data with a view navigation.
-     *                      Unlike matrix parameters, navigation data is stored in the layout and not added to the path, allowing data to be passed to empty path navigations.
-     *                      Data must be JSON serializable. Data can be read from {@link WorkbenchView.navigationData}.
-     * @param extras.state - Passes state to a view navigation.
-     *                       State is not persistent, unlike {@link data}, it is only added to the browser's session history to support back/forward browser navigation.
-     *                       State can be read from {@link WorkbenchView.navigationState} or from the browser's session history via `history.state`.
+     * @param extras.data - Associates data with the navigation.
+     *                      Unlike matrix parameters, navigation data is stored in the layout and not added to the URL, allowing data to be passed to empty path navigations.
+     *                      Data must be JSON serializable. Data can be read from {@link WorkbenchView.navigation.data}.
+     * @param extras.state - Passes state to the navigation.
+     *                       State is not persistent, unlike {@link data}; however, state is added to the browser's session history to support back/forward browser navigation.
+     *                       State can be read from {@link WorkbenchView.navigation.state} or from the browser's session history via `history.state`.
      * @param extras.cssClass - Specifies CSS class(es) to add to the view, e.g., to locate the view in tests.
      * @return a copy of this layout with the view navigated.
      */
@@ -137,6 +212,13 @@ export interface WorkbenchLayout {
      * @return a copy of this layout with the part activated.
      */
     activatePart(id: string): WorkbenchLayout;
+    /**
+     * Applies a modification function to this layout, enabling conditional changes while maintaining method chaining.
+     *
+     * @param modifyFn - A function that takes the current layout and returns a modified layout.
+     * @return The modified layout returned by the modify function.
+     */
+    modify(modifyFn: (layout: WorkbenchLayout) => WorkbenchLayout): WorkbenchLayout;
 }
 /**
  * Describes how to lay out a part relative to another part.
@@ -166,4 +248,10 @@ export declare const MAIN_AREA: MAIN_AREA;
 /**
  * Represents the type of the constant {@link MAIN_AREA}.
  */
-export type MAIN_AREA = 'main-area';
+export type MAIN_AREA = 'part.main-area';
+/**
+ * Represents the alternative id of the main area part.
+ *
+ * @see MAIN_AREA
+ */
+export declare const MAIN_AREA_ALTERNATIVE_ID = "main-area";

package/lib/layout/workbench-layout.model.d.ts

@@ -1,5 +1,6 @@
 import { ViewId } from '../view/workbench-view.model';
 import { NavigationData } from '../routing/routing.model';
+import { PartId } from '../part/workbench-part.model';
 /**
  * Represents the arrangement of parts as grid.
  *
@@ -7,7 +8,7 @@ import { NavigationData } from '../routing/routing.model';
  */
 export interface MPartGrid {
     root: MTreeNode | MPart;
-    activePartId: string;
+    activePartId: PartId;
 }
 /**
  * {@link MPartGrid} with additional fields not serialized into the URL.
@@ -31,7 +32,7 @@ export declare class MTreeNode {
      * Discriminator to unmarshall {@link MTreeNode} to its class type.
      */
     readonly type = "MTreeNode";
-    readonly id: string;
+    id: string;
     child1: MTreeNode | MPart;
     child2: MTreeNode | MPart;
     ratio: number;
@@ -55,11 +56,18 @@ export declare class MPart {
      * Discriminator to unmarshall {@link MPart} to its class type.
      */
     readonly type = "MPart";
-    readonly id: string;
+    id: PartId;
+    alternativeId?: string;
     parent?: MTreeNode;
     views: MView[];
     activeViewId?: ViewId;
     structural: boolean;
+    navigation?: {
+        id: string;
+        hint?: string;
+        data?: NavigationData;
+        cssClass?: string[];
+    };
     constructor(part: Omit<MPart, 'type'>);
     /**
      * Tests if the given object is a {@link MPart}.
@@ -74,7 +82,6 @@ export declare class MPart {
 export interface MView {
     id: ViewId;
     alternativeId?: string;
-    uid: string;
     cssClass?: string[];
     markedForRemoval?: true;
     navigation?: {

package/lib/layout/workbench-layout.service.d.ts

@@ -1,14 +1,14 @@
 import { Observable } from 'rxjs';
-import { ViewDragService } from '../view-dnd/view-drag.service';
 import { ɵWorkbenchLayout } from './ɵworkbench-layout';
 import * as i0 from "@angular/core";
 /**
  * Provides access to the workbench layout.
  */
 export declare class WorkbenchLayoutService {
-    private _layout$;
-    private _dragStart$;
-    private _dragEnd$;
+    private readonly _viewDragService;
+    private readonly _layout$;
+    private readonly _moving;
+    private readonly _resizing;
     /**
      * Provides the current {@link WorkbenchLayout}, or `null` until Angular has performed the initial navigation.
      */
@@ -26,19 +26,17 @@ export declare class WorkbenchLayoutService {
      */
     readonly onLayoutChange$: Observable<ɵWorkbenchLayout>;
     /**
-     * Notifies when the user starts or ends modifying the layout using drag and drop, e.g., moving the splitter between parts,
-     * moving a message box, or moving a view.
+     * Indicates if a drag operation is active, such as moving a view or dialog, or resizing a part.
      */
-    readonly dragging$: Observable<'start' | 'end'>;
-    constructor(viewDragService: ViewDragService);
+    readonly dragging: import("@angular/core").Signal<boolean>;
     /**
-     * Invoke to inform the layout when about to start a drag operation, like when start moving the splitter between parts.
+     * Signals moving a workbench element, such as moving a dialog.
      */
-    notifyDragStarting(): void;
+    signalMoving(moving: boolean): void;
     /**
-     * Invoke to inform the layout when about to end a drag operation, like when end moving the splitter between parts.
+     * Signals resizing a workbench element, such as resizing a dialog or part.
      */
-    notifyDragEnding(): void;
+    signalResizing(resizing: boolean): void;
     /**
      * Sets the given {@link WorkbenchLayout}.
      */

package/lib/layout/workbench-layouts.util.d.ts

@@ -1,5 +1,6 @@
 import { MPart, MTreeNode } from './workbench-layout.model';
 import { ViewId } from '../view/workbench-view.model';
+import { PartId } from '../part/workbench-part.model';
 /**
  * Provides helper functions for operating on a workbench layout.
  */
@@ -19,4 +20,8 @@ export declare const WorkbenchLayouts: {
      * Computes the next available view id.
      */
     readonly computeNextViewId: (viewIds: Iterable<ViewId>) => ViewId;
+    /**
+     * Computes a random part id.
+     */
+    readonly computePartId: () => PartId;
 };

package/lib/layout/workench-layout-serializer.service.d.ts

@@ -1,5 +1,5 @@
 import { MPartGrid, ɵMPartGrid } from './workbench-layout.model';
-import { ViewOutlets } from '../routing/routing.model';
+import { Outlets } from '../routing/routing.model';
 import * as i0 from "@angular/core";
 /**
  * Serializes and deserializes a base64-encoded JSON into a {@link MPartGrid}.
@@ -10,7 +10,7 @@ export declare class WorkbenchLayoutSerializer {
      * Serializes the given grid into a URL-safe base64 string.
      *
      * @param grid - Specifies the grid to be serialized.
-     * @param flags - Controls which fields not to serialize. By default, all fields are serialized.
+     * @param flags - Controls how to serialize the grid.
      */
     serializeGrid(grid: MPartGrid, flags?: GridSerializationFlags): string;
     serializeGrid(grid: MPartGrid | undefined | null, flags?: GridSerializationFlags): null | string;
@@ -21,11 +21,11 @@ export declare class WorkbenchLayoutSerializer {
     /**
      * Serializes the given outlets.
      */
-    serializeViewOutlets(viewOutlets: ViewOutlets): string;
+    serializeOutlets(outlets: Outlets): string;
     /**
      * Deserializes the given outlets.
      */
-    deserializeViewOutlets(serialized: string): ViewOutlets;
+    deserializeOutlets(serialized: string): Outlets;
     static ɵfac: i0.ɵɵFactoryDeclaration<WorkbenchLayoutSerializer, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<WorkbenchLayoutSerializer>;
 }
@@ -36,13 +36,37 @@ export declare class WorkbenchLayoutSerializer {
  *
  * @see WorkbenchMigrator
  */
-export declare const WORKBENCH_LAYOUT_VERSION = 5;
+export declare const WORKBENCH_LAYOUT_VERSION = 7;
 /**
- * Controls which fields not to serialize. By default, all fields are serialized.
+ * Controls how to serialize the grid.
  */
 export interface GridSerializationFlags {
+    /**
+     * Excludes the node id from the serialization.
+     */
     excludeTreeNodeId?: true;
-    excludeViewUid?: true;
+    /**
+     * Excludes views marked for removal from the serialization.
+     */
     excludeViewMarkedForRemoval?: true;
+    /**
+     * Excludes the view navigation id from the serialization.
+     */
     excludeViewNavigationId?: true;
+    /**
+     * Excludes the part navigation id from the serialization.
+     */
+    excludePartNavigationId?: true;
+    /**
+     * Assigns each part a stable id based on its position in the grid.
+     *
+     * Stable part identifiers are required to compare the initial grid with the user-modified grid to detect layout changes.
+     */
+    assignStablePartIdentifier?: true;
+    /**
+     * Controls if to sort the fields of the grid by name. Defaults to `false`.
+     *
+     * Stable sort order is required to compare the initial grid with the user-modified grid to detect layout changes.
+     */
+    sort?: true;
 }