@eclipse-glsp/client 2.3.0-next.391 → 2.3.0-next.392

package/src/base/feedback/feedback-action-dispatcher.ts

@@ -13,23 +13,29 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, Command, CommandExecutionContext, Disposable, MaybeFunction, call, asArray as toArray } from '@eclipse-glsp/sprotty';
+import {
+    Action,
+    ActionHandlerRegistry,
+    Command,
+    CommandActionHandler,
+    CommandExecutionContext,
+    Disposable,
+    GModelElement,
+    IActionDispatcher,
+    ICommand,
+    ILogger,
+    MaybeActions,
+    TYPES,
+    toTypeGuard
+} from '@eclipse-glsp/sprotty';
+import { inject, injectable, preDestroy } from 'inversify';
+import { getFeedbackRank } from './feedback-command';
 import { FeedbackEmitter } from './feedback-emitter';
 
 export interface IFeedbackEmitter {}
 
 export const feedbackFeature = Symbol('feedbackFeature');
 
-export type MaybeActions = MaybeFunction<Action[] | Action | undefined>;
-
-export namespace MaybeActions {
-    // eslint-disable-next-line @typescript-eslint/no-shadow
-    export function asArray(actions?: MaybeActions): Action[] {
-        const cleanup = actions ? call(actions) : [];
-        return cleanup ? toArray(cleanup) : [];
-    }
-}
-
 /**
  * Dispatcher for actions that are meant to show visual feedback on
  * the diagram that is not part of the diagram sent from the server
@@ -86,3 +92,100 @@ export interface IFeedbackActionDispatcher {
      */
     createEmitter(): FeedbackEmitter;
 }
+
+@injectable()
+export class FeedbackActionDispatcher implements IFeedbackActionDispatcher, Disposable {
+    protected registeredFeedback: Map<IFeedbackEmitter, Action[]> = new Map();
+
+    @inject(TYPES.IActionDispatcher) protected actionDispatcher: IActionDispatcher;
+
+    @inject(TYPES.ILogger) protected logger: ILogger;
+
+    @inject(ActionHandlerRegistry) protected actionHandlerRegistry: ActionHandlerRegistry;
+
+    protected isDisposed = false;
+
+    registerFeedback(feedbackEmitter: IFeedbackEmitter, feedbackActions: Action[], cleanupActions?: MaybeActions): Disposable {
+        if (feedbackEmitter instanceof GModelElement) {
+            this.logger.log(
+                this,
+                // eslint-disable-next-line max-len
+                'GModelElements as feedback emitters are discouraged, as they usually change between model updates and are considered unstable.'
+            );
+        }
+        if (feedbackActions.length > 0) {
+            this.registeredFeedback.set(feedbackEmitter, feedbackActions);
+            this.dispatchFeedback(feedbackActions, feedbackEmitter);
+        }
+        return Disposable.create(() => this.deregisterFeedback(feedbackEmitter, cleanupActions));
+    }
+
+    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, cleanupActions?: MaybeActions): void {
+        this.registeredFeedback.delete(feedbackEmitter);
+        const actions = MaybeActions.asArray(cleanupActions);
+        if (actions.length > 0) {
+            this.dispatchFeedback(actions, feedbackEmitter);
+        }
+    }
+
+    getRegisteredFeedback(): Action[] {
+        const result: Action[] = [];
+        this.registeredFeedback.forEach(actions => result.push(...actions));
+        return result;
+    }
+
+    getRegisteredFeedbackEmitters(action: Action): IFeedbackEmitter[] {
+        const result: IFeedbackEmitter[] = [];
+        this.registeredFeedback.forEach((actions, emitter) => {
+            if (actions.includes(action)) {
+                result.push(emitter);
+            }
+        });
+        return result;
+    }
+
+    getFeedbackCommands(): Command[] {
+        return this.getRegisteredFeedback()
+            .flatMap(action => this.actionToCommands(action))
+            .sort((left, right) => getFeedbackRank(left) - getFeedbackRank(right));
+    }
+
+    async applyFeedbackCommands(context: CommandExecutionContext): Promise<void> {
+        const feedbackCommands = this.getFeedbackCommands() ?? [];
+        if (feedbackCommands?.length > 0) {
+            const results = feedbackCommands.map(command => command.execute(context));
+            await Promise.all(results);
+        }
+    }
+
+    protected actionToCommands(action: Action): ICommand[] {
+        return (
+            this.actionHandlerRegistry
+                .get(action.kind)
+                .filter(toTypeGuard(CommandActionHandler))
+                .map(handler => handler.handle(action)) ?? []
+        );
+    }
+
+    createEmitter(): FeedbackEmitter {
+        return new FeedbackEmitter(this);
+    }
+
+    protected async dispatchFeedback(actions: Action[], feedbackEmitter: IFeedbackEmitter): Promise<void> {
+        try {
+            if (this.isDisposed) {
+                return;
+            }
+            await this.actionDispatcher.dispatchAll(actions);
+            this.logger.info(this, `Dispatched feedback actions for ${feedbackEmitter}`);
+        } catch (reason) {
+            this.logger.error(this, 'Failed to dispatch feedback actions', reason);
+        }
+    }
+
+    @preDestroy()
+    dispose(): void {
+        this.registeredFeedback.clear();
+        this.isDisposed = true;
+    }
+}

package/src/base/feedback/feedback-emitter.ts

@@ -14,8 +14,8 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { Action, Disposable, arrayOf } from '@eclipse-glsp/sprotty';
-import { IFeedbackActionDispatcher, IFeedbackEmitter, MaybeActions } from './feedback-action-dispatcher';
+import { Action, Disposable, MaybeActions, arrayOf } from '@eclipse-glsp/sprotty';
+import type { IFeedbackActionDispatcher, IFeedbackEmitter } from './feedback-action-dispatcher';
 
 // counter for internal id, mainly useful for debugging
 let idCounter = 0;

package/src/features/context-menu/delete-element-context-menu.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2023 EclipseSource and others.
+ * Copyright (c) 2019-2024 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -13,27 +13,31 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { DeleteElementOperation, GModelRoot, IContextMenuItemProvider, MenuItem, Point, TYPES } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
-import { DeleteElementOperation, IContextMenuItemProvider, MenuItem, Point, GModelRoot, TYPES } from '@eclipse-glsp/sprotty';
 import { EditorContextService, EditorContextServiceProvider } from '../../base/editor-context-service';
 
 @injectable()
 export class DeleteElementContextMenuItemProvider implements IContextMenuItemProvider {
+    /** @deprecated No longer used. The {@link EditorContextService} is now directly injected.*/
+    // eslint-disable-next-line deprecation/deprecation
     @inject(TYPES.IEditorContextServiceProvider) editorContextServiceProvider: EditorContextServiceProvider;
 
+    @inject(EditorContextService)
+    protected editorContext: EditorContextService;
+
     async getItems(_root: Readonly<GModelRoot>, _lastMousePosition?: Point): Promise<MenuItem[]> {
-        const editorContextService = await this.editorContextServiceProvider();
-        return [this.createDeleteMenuItem(editorContextService)];
+        return [this.createDeleteMenuItem()];
     }
 
-    protected createDeleteMenuItem(editorContextService: EditorContextService): MenuItem {
+    protected createDeleteMenuItem(): MenuItem {
         return {
             id: 'delete',
             label: 'Delete',
             sortString: 'd',
             group: 'edit',
-            actions: [DeleteElementOperation.create(editorContextService.selectedElements.map(e => e.id))],
-            isEnabled: () => !editorContextService.isReadonly && editorContextService.selectedElements.length > 0
+            actions: [DeleteElementOperation.create(this.editorContext.selectedElements.map(e => e.id))],
+            isEnabled: () => !this.editorContext.isReadonly && this.editorContext.selectedElements.length > 0
         };
     }
 }

package/src/features/helper-lines/helper-line-manager.ts

@@ -13,8 +13,38 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { GModelElement, Vector } from '@eclipse-glsp/sprotty';
-import { Direction } from './model';
+import {
+    Action,
+    GModelElement,
+    GModelRoot,
+    IActionHandler,
+    MoveAction,
+    Point,
+    SetBoundsAction,
+    TYPES,
+    Vector,
+    Writable
+} from '@eclipse-glsp/sprotty';
+import { inject, injectable, optional, postConstruct } from 'inversify';
+import { IFeedbackActionDispatcher } from '../../base/feedback/feedback-action-dispatcher';
+import { FeedbackEmitter } from '../../base/feedback/feedback-emitter';
+import { ISelectionListener, SelectionService } from '../../base/selection-service';
+import { SetBoundsFeedbackAction } from '../bounds/set-bounds-feedback-command';
+import { GResizeHandle, ResizeHandleLocation } from '../change-bounds/model';
+import { Grid } from '../grid/grid';
+import { MoveFinishedEventAction, MoveInitializedEventAction } from '../tools/change-bounds/change-bounds-tool-feedback';
+import {
+    AlignmentElementFilter,
+    DEFAULT_ALIGNABLE_ELEMENT_FILTER,
+    DEFAULT_DEBUG,
+    DEFAULT_ELEMENT_LINES,
+    DEFAULT_EPSILON,
+    DEFAULT_VIEWPORT_LINES,
+    DrawHelperLinesFeedbackAction,
+    RemoveHelperLinesFeedbackAction,
+    ViewportLineType
+} from './helper-line-feedback';
+import { Direction, HelperLine, HelperLineType, isHelperLine } from './model';
 
 export interface IHelperLineManager {
     /**
@@ -35,3 +65,205 @@ export interface IHelperLineManager {
      */
     getMinimumMoveVector(element: GModelElement, isSnap: boolean, directions: Direction[]): Vector | undefined;
 }
+
+export interface IHelperLineOptions {
+    /**
+     * A list of helper line types that should be rendered when elements are aligned.
+     * Defaults to all possible alignments.
+     */
+    elementLines?: HelperLineType[];
+    /**
+     * A list of helper line types that should be rendered when an element is aligned with the viewport.
+     * Defaults to middle and center alignment.
+     */
+    viewportLines?: ViewportLineType[];
+    /**
+     * The minimum difference between two coordinates
+     * Defaults to 1 or zero (perfect match) if the optional grid module is loaded.
+     */
+    alignmentEpsilon?: number;
+    /**
+     * A filter that is applied to determine on which elements the alignment calculation is performed.
+     * By default all top-level bounds-aware, non-routable elements that are visible on the canvas are considered.
+     */
+    alignmentElementFilter?: AlignmentElementFilter;
+    /**
+     * The minimum move delta that is necessary for an element to break through a helper line.
+     * Defaults to { x: 1, y: 1 } whereas the x represents the horizontal distance and y represents the vertical distance.
+     * If the optional grid module is loaded, defaults to twice the grid size, i.e., two grid moves to break through a helper line.
+     */
+    minimumMoveDelta?: Point;
+
+    /**
+     * Produces debug output.
+     * Defaults to false.
+     */
+    debug?: boolean;
+}
+
+export const DEFAULT_MOVE_DELTA = { x: 1, y: 1 };
+
+export const DEFAULT_HELPER_LINE_OPTIONS: Required<IHelperLineOptions> = {
+    elementLines: DEFAULT_ELEMENT_LINES,
+    viewportLines: DEFAULT_VIEWPORT_LINES,
+    alignmentEpsilon: DEFAULT_EPSILON,
+    alignmentElementFilter: DEFAULT_ALIGNABLE_ELEMENT_FILTER,
+    minimumMoveDelta: DEFAULT_MOVE_DELTA,
+    debug: DEFAULT_DEBUG
+};
+
+@injectable()
+export class HelperLineManager implements IActionHandler, ISelectionListener, IHelperLineManager {
+    @inject(TYPES.IFeedbackActionDispatcher) protected feedbackDispatcher: IFeedbackActionDispatcher;
+    @inject(SelectionService) protected selectionService: SelectionService;
+    @optional() @inject(TYPES.IHelperLineOptions) protected userOptions?: IHelperLineOptions;
+    @optional() @inject(TYPES.Grid) protected grid?: Grid;
+
+    protected options: Required<IHelperLineOptions>;
+    protected feedback: FeedbackEmitter;
+
+    @postConstruct()
+    protected init(): void {
+        this.feedback = this.feedbackDispatcher.createEmitter();
+        const dynamicOptions: IHelperLineOptions = {};
+        if (this.grid) {
+            dynamicOptions.alignmentEpsilon = 0;
+            dynamicOptions.minimumMoveDelta = Point.multiplyScalar(this.grid, 2);
+        }
+        this.options = { ...DEFAULT_HELPER_LINE_OPTIONS, ...dynamicOptions, ...this.userOptions };
+        this.selectionService.addListener(this);
+    }
+
+    handle(action: Action): void {
+        if (MoveInitializedEventAction.is(action)) {
+            this.handleMoveInitializedAction(action);
+        } else if (MoveAction.is(action)) {
+            this.handleMoveAction(action);
+        } else if (MoveFinishedEventAction.is(action)) {
+            this.handleMoveFinishedAction(action);
+        } else if (SetBoundsAction.is(action) || SetBoundsFeedbackAction.is(action)) {
+            this.handleSetBoundsAction(action);
+        }
+    }
+
+    protected handleMoveInitializedAction(_action: MoveInitializedEventAction): void {
+        this.submitHelperLineFeedback();
+    }
+
+    protected handleMoveFinishedAction(_action: MoveFinishedEventAction): void {
+        this.feedback.dispose();
+    }
+
+    protected handleMoveAction(action: MoveAction): void {
+        if (!action.finished) {
+            this.submitHelperLineFeedback(action.moves.map(move => move.elementId));
+        } else {
+            this.feedback.dispose();
+        }
+    }
+
+    protected submitHelperLineFeedback(elementIds: string[] = this.selectionService.getSelectedElementIDs()): void {
+        const feedback = this.createHelperLineFeedback(elementIds);
+        this.feedback.add(feedback, [RemoveHelperLinesFeedbackAction.create()]).submit();
+    }
+
+    protected createHelperLineFeedback(elementIds: string[]): DrawHelperLinesFeedbackAction {
+        return DrawHelperLinesFeedbackAction.create({ elementIds, ...this.options });
+    }
+
+    protected handleSetBoundsAction(action: SetBoundsAction | SetBoundsFeedbackAction): void {
+        this.submitHelperLineFeedback(action.bounds.map(bound => bound.elementId));
+    }
+
+    selectionChanged(root: Readonly<GModelRoot>, selectedElements: string[], deselectedElements?: string[] | undefined): void {
+        this.feedback.dispose();
+    }
+
+    getMinimumMoveDelta(element: GModelElement, isSnap: boolean, direction: Direction): number {
+        if (!isSnap) {
+            return 0;
+        }
+        const minimumMoveDelta = this.options.minimumMoveDelta;
+        return direction === Direction.Left || direction === Direction.Right ? minimumMoveDelta.x : minimumMoveDelta.y;
+    }
+
+    getMinimumMoveVector(element: GModelElement, isSnap: boolean, move: Direction[]): Vector | undefined {
+        if (!isSnap) {
+            return undefined;
+        }
+
+        const state = this.getHelperLineState(element);
+        if (state.helperLines.length === 0) {
+            return undefined;
+        }
+
+        const minimum: Writable<Vector> = { ...Vector.ZERO };
+        const resize =
+            element instanceof GResizeHandle
+                ? ResizeHandleLocation.direction(element.location)
+                : [Direction.Left, Direction.Right, Direction.Up, Direction.Down];
+
+        if ((state.types.left || state.types.center) && move.includes(Direction.Left) && resize.includes(Direction.Left)) {
+            minimum.x = this.getMinimumMoveDelta(element, isSnap, Direction.Left);
+        } else if ((state.types.right || state.types.center) && move.includes(Direction.Right) && resize.includes(Direction.Right)) {
+            minimum.x = this.getMinimumMoveDelta(element, isSnap, Direction.Right);
+        }
+        if ((state.types.top || state.types.middle) && move.includes(Direction.Up) && resize.includes(Direction.Up)) {
+            minimum.y = this.getMinimumMoveDelta(element, isSnap, Direction.Up);
+        } else if ((state.types.bottom || state.types.middle) && move.includes(Direction.Down) && resize.includes(Direction.Down)) {
+            minimum.y = this.getMinimumMoveDelta(element, isSnap, Direction.Down);
+        }
+        return Vector.isZero(minimum) ? undefined : minimum;
+    }
+
+    protected getHelperLineState(element: GModelElement): HelperLineState {
+        const helperLines = element.root.children.filter(isHelperLine) || [];
+        const types = {
+            left: false,
+            right: false,
+            top: false,
+            bottom: false,
+            center: false,
+            middle: false
+        };
+        for (const line of helperLines) {
+            switch (line.lineType) {
+                case HelperLineType.Left:
+                case HelperLineType.LeftRight:
+                    types.left = true;
+                    break;
+                case HelperLineType.Right:
+                case HelperLineType.RightLeft:
+                    types.right = true;
+                    break;
+                case HelperLineType.Top:
+                case HelperLineType.TopBottom:
+                    types.top = true;
+                    break;
+                case HelperLineType.Bottom:
+                case HelperLineType.BottomTop:
+                    types.bottom = true;
+                    break;
+                case HelperLineType.Center:
+                    types.center = true;
+                    break;
+                case HelperLineType.Middle:
+                    types.middle = true;
+                    break;
+            }
+        }
+        return { helperLines, types };
+    }
+}
+
+export interface HelperLineState {
+    helperLines: HelperLine[];
+    types: {
+        left: boolean;
+        right: boolean;
+        top: boolean;
+        bottom: boolean;
+        center: boolean;
+        middle: boolean;
+    };
+}

package/src/features/helper-lines/helper-line-module.ts

@@ -27,7 +27,7 @@ import {
 import { SetBoundsFeedbackAction } from '../bounds/set-bounds-feedback-command';
 import { MoveFinishedEventAction, MoveInitializedEventAction } from '../tools/change-bounds/change-bounds-tool-feedback';
 import { DrawHelperLinesFeedbackCommand, RemoveHelperLinesFeedbackCommand } from './helper-line-feedback';
-import { HelperLineManager } from './helper-line-manager-default';
+import { HelperLineManager } from './helper-line-manager';
 import { HELPER_LINE, HelperLine, SELECTION_BOUNDS, SelectionBounds } from './model';
 import { HelperLineView, SelectionBoundsView } from './view';
 

package/src/features/hints/type-hint-provider.spec.ts

@@ -36,7 +36,7 @@ import { expect } from 'chai';
 import { Container } from 'inversify';
 import * as sinon from 'sinon';
 import { GLSPActionDispatcher } from '../../base/action-dispatcher';
-import { FeedbackActionDispatcher } from '../../base/feedback/feedback-action-dispatcher-default';
+import { FeedbackActionDispatcher } from '../../base/feedback/feedback-action-dispatcher';
 import { FeedbackEmitter } from '../../base/feedback/feedback-emitter';
 import { GEdge } from '../../model';
 import { isResizable } from '../change-bounds/model';

package/src/features/navigation/navigation-action-handler.ts

@@ -38,7 +38,7 @@ import {
     hasStringProp
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
-import { EditorContextServiceProvider } from '../../base/editor-context-service';
+import { EditorContextService, EditorContextServiceProvider } from '../../base/editor-context-service';
 import { NavigationTargetResolver } from './navigation-target-resolver';
 
 /**
@@ -140,9 +140,15 @@ export class NavigationActionHandler implements IActionHandler {
 
     @inject(TYPES.ILogger) protected logger: ILogger;
     @inject(TYPES.IActionDispatcher) protected dispatcher: IActionDispatcher;
+    /** @deprecated No longer in used. The {@link ActionHandlerRegistry} is now directly injected */
+    // eslint-disable-next-line deprecation/deprecation
     @inject(TYPES.ActionHandlerRegistryProvider) protected actionHandlerRegistryProvider: () => Promise<ActionHandlerRegistry>;
+    /** @deprecated No longer in used. The {@link EditorContextService} is now directly injected */
+    // eslint-disable-next-line deprecation/deprecation
     @inject(TYPES.IEditorContextServiceProvider) protected editorContextService: EditorContextServiceProvider;
+    @inject(ActionHandlerRegistry) protected actionHandlerRegistry: ActionHandlerRegistry;
     @inject(NavigationTargetResolver) protected resolver: NavigationTargetResolver;
+    @inject(EditorContextService) protected editorContext: EditorContextService;
 
     handle(action: Action): ICommand | Action | void {
         if (NavigateAction.is(action)) {
@@ -158,8 +164,7 @@ export class NavigationActionHandler implements IActionHandler {
 
     protected async handleNavigateAction(action: NavigateAction): Promise<void> {
         try {
-            const editorContextService = await this.editorContextService();
-            const editorContext = editorContextService.get(action.args);
+            const editorContext = this.editorContext.get(action.args);
             const response = await this.dispatcher.request(
                 RequestNavigationTargetsAction.create({ targetTypeId: action.targetTypeId, editorContext })
             );
@@ -250,8 +255,7 @@ export class NavigationActionHandler implements IActionHandler {
     }
 
     protected async handleNavigateToExternalTarget(action: NavigateToExternalTargetAction): Promise<void> {
-        const registry = await this.actionHandlerRegistryProvider();
-        const handlers = registry.get(NavigateToExternalTargetAction.KIND);
+        const handlers = this.actionHandlerRegistry.get(NavigateToExternalTargetAction.KIND);
         if (handlers.length === 1) {
             // we are the only handler so we know nobody took care of it
             this.warnAboutFailedNavigation('Could not resolve or navigate to target', action.target);

package/src/features/tools/base-tools.ts

@@ -13,10 +13,10 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, Disposable, DisposableCollection, IActionDispatcher, IActionHandler, TYPES } from '@eclipse-glsp/sprotty';
+import { Action, Disposable, DisposableCollection, IActionDispatcher, IActionHandler, MaybeActions, TYPES } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
 import { EditorContextService } from '../../base/editor-context-service';
-import { IFeedbackActionDispatcher, IFeedbackEmitter, MaybeActions } from '../../base/feedback/feedback-action-dispatcher';
+import { IFeedbackActionDispatcher, IFeedbackEmitter } from '../../base/feedback/feedback-action-dispatcher';
 import { FeedbackEmitter } from '../../base/feedback/feedback-emitter';
 import { EnableToolsAction, Tool } from '../../base/tool-manager/tool';
 import { GLSPKeyTool } from '../../base/view/key-tool';

package/src/index.ts

@@ -27,7 +27,6 @@ export * from './base/drag-aware-mouse-listener';
 export * from './base/editor-context-service';
 export * from './base/feedback/css-feedback';
 export * from './base/feedback/feedback-action-dispatcher';
-export * from './base/feedback/feedback-action-dispatcher-default';
 export * from './base/feedback/feedback-command';
 export * from './base/feedback/feedback-emitter';
 export * from './base/feedback/set-model-command';
@@ -145,7 +144,6 @@ export * from './features/grid/grid-snapper';
 export * from './features/grid/grid-style';
 export * from './features/helper-lines/helper-line-feedback';
 export * from './features/helper-lines/helper-line-manager';
-export * from './features/helper-lines/helper-line-manager-default';
 export * from './features/helper-lines/helper-line-module';
 export * from './features/helper-lines/model';
 export * from './features/helper-lines/view';

package/lib/base/feedback/feedback-action-dispatcher-default.d.ts

@@ -1,36 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2019-2024 EclipseSource and others.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v. 2.0 which is available at
- * http://www.eclipse.org/legal/epl-2.0.
- *
- * This Source Code may also be made available under the following Secondary
- * Licenses when the conditions for such availability set forth in the Eclipse
- * Public License v. 2.0 are satisfied: GNU General Public License, version 2
- * with the GNU Classpath Exception which is available at
- * https://www.gnu.org/software/classpath/license.html.
- *
- * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
- ********************************************************************************/
-import { Action, ActionHandlerRegistry, Command, CommandExecutionContext, Disposable, IActionDispatcher, ICommand, ILogger } from '@eclipse-glsp/sprotty';
-import { IFeedbackActionDispatcher, IFeedbackEmitter, MaybeActions } from './feedback-action-dispatcher';
-import { FeedbackEmitter } from './feedback-emitter';
-export declare class FeedbackActionDispatcher implements IFeedbackActionDispatcher, Disposable {
-    protected registeredFeedback: Map<IFeedbackEmitter, Action[]>;
-    protected actionDispatcher: IActionDispatcher;
-    protected logger: ILogger;
-    protected actionHandlerRegistry: ActionHandlerRegistry;
-    protected isDisposed: boolean;
-    registerFeedback(feedbackEmitter: IFeedbackEmitter, feedbackActions: Action[], cleanupActions?: MaybeActions): Disposable;
-    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, cleanupActions?: MaybeActions): void;
-    getRegisteredFeedback(): Action[];
-    getRegisteredFeedbackEmitters(action: Action): IFeedbackEmitter[];
-    getFeedbackCommands(): Command[];
-    applyFeedbackCommands(context: CommandExecutionContext): Promise<void>;
-    protected actionToCommands(action: Action): ICommand[];
-    createEmitter(): FeedbackEmitter;
-    protected dispatchFeedback(actions: Action[], feedbackEmitter: IFeedbackEmitter): Promise<void>;
-    dispose(): void;
-}
-//# sourceMappingURL=feedback-action-dispatcher-default.d.ts.map

package/lib/base/feedback/feedback-action-dispatcher-default.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"feedback-action-dispatcher-default.d.ts","sourceRoot":"","sources":["../../../src/base/feedback/feedback-action-dispatcher-default.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;kFAckF;AAClF,OAAO,EACH,MAAM,EACN,qBAAqB,EACrB,OAAO,EAEP,uBAAuB,EACvB,UAAU,EAEV,iBAAiB,EACjB,QAAQ,EACR,OAAO,EAGV,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,yBAAyB,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAEzG,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD,qBACa,wBAAyB,YAAW,yBAAyB,EAAE,UAAU;IAClF,SAAS,CAAC,kBAAkB,EAAE,GAAG,CAAC,gBAAgB,EAAE,MAAM,EAAE,CAAC,CAAa;IAEzC,SAAS,CAAC,gBAAgB,EAAE,iBAAiB,CAAC;IAExD,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC;IAElB,SAAS,CAAC,qBAAqB,EAAE,qBAAqB,CAAC;IAEtF,SAAS,CAAC,UAAU,UAAS;IAE7B,gBAAgB,CAAC,eAAe,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,YAAY,GAAG,UAAU;IAezH,kBAAkB,CAAC,eAAe,EAAE,gBAAgB,EAAE,cAAc,CAAC,EAAE,YAAY,GAAG,IAAI;IAQ1F,qBAAqB,IAAI,MAAM,EAAE;IAMjC,6BAA6B,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,EAAE;IAUjE,mBAAmB,IAAI,OAAO,EAAE;IAM1B,qBAAqB,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ5E,SAAS,CAAC,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,EAAE;IAStD,aAAa,IAAI,eAAe;cAIhB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,eAAe,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAarG,OAAO,IAAI,IAAI;CAIlB"}