js-draw 0.18.0 → 0.18.1

package/src/tools/TextTool.ts

@@ -1,326 +0,0 @@
-import Color4 from '../Color4';
-import TextComponent from '../components/TextComponent';
-import Editor from '../Editor';
-import EditorImage from '../EditorImage';
-import Rect2 from '../math/Rect2';
-import Mat33 from '../math/Mat33';
-import { Vec2 } from '../math/Vec2';
-import { PointerDevice } from '../Pointer';
-import { EditorEventType, PointerEvt } from '../types';
-import BaseTool from './BaseTool';
-import { ToolLocalization } from './localization';
-import Erase from '../commands/Erase';
-import uniteCommands from '../commands/uniteCommands';
-import TextStyle from '../rendering/TextRenderingStyle';
-
-const overlayCssClass = 'textEditorOverlay';
-export default class TextTool extends BaseTool {
-	private textStyle: TextStyle;
-
-	private textEditOverlay: HTMLElement;
-	private textInputElem: HTMLTextAreaElement|null = null;
-	private textTargetPosition: Vec2|null = null;
-	private textMeasuringCtx: CanvasRenderingContext2D|null = null;
-	private textRotation: number;
-	private textScale: Vec2 = Vec2.of(1, 1);
-
-	private removeExistingCommand: Erase|null = null;
-
-	public constructor(private editor: Editor, description: string, private localizationTable: ToolLocalization) {
-		super(editor.notifier, description);
-		this.textStyle = {
-			size: 32,
-			fontFamily: 'sans-serif',
-			renderingStyle: {
-				fill: Color4.purple,
-			},
-		};
-
-		this.textEditOverlay = document.createElement('div');
-		this.textEditOverlay.classList.add(overlayCssClass);
-		this.editor.addStyleSheet(`
-			.${overlayCssClass} {
-				height: 0;
-				overflow: visible;
-			}
-
-			.${overlayCssClass} textarea {
-				background-color: rgba(0, 0, 0, 0);
-
-				white-space: pre;
-				overflow: hidden;
-
-				padding: 0;
-				margin: 0;
-				border: none;
-				padding: 0;
-
-				min-width: 100px;
-				min-height: 1.1em;
-			}
-		`);
-		this.editor.createHTMLOverlay(this.textEditOverlay);
-		this.editor.notifier.on(EditorEventType.ViewportChanged, () => this.updateTextInput());
-	}
-
-	private getTextAscent(text: string, style: TextStyle): number {
-		this.textMeasuringCtx ??= document.createElement('canvas').getContext('2d');
-		if (this.textMeasuringCtx) {
-			TextComponent.applyTextStyles(this.textMeasuringCtx, style);
-			return this.textMeasuringCtx.measureText(text).actualBoundingBoxAscent;
-		}
-
-		// Estimate
-		return style.size * 2 / 3;
-	}
-
-	// Take input from this' textInputElem and add it to the EditorImage.
-	// If [removeInput], the HTML input element is removed. Otherwise, its value
-	// is cleared.
-	private flushInput(removeInput: boolean = true) {
-		if (this.textInputElem && this.textTargetPosition) {
-			const content = this.textInputElem.value.trimEnd();
-
-			this.textInputElem.value = '';
-
-			if (removeInput) {
-				// In some browsers, .remove() triggers a .blur event (synchronously).
-				// Clear this.textInputElem before removal
-				const input = this.textInputElem;
-				this.textInputElem = null;
-				input.remove();
-			}
-
-			if (content === '') {
-				return;
-			}
-
-			const textTransform = Mat33.translation(
-				this.textTargetPosition
-			).rightMul(
-				this.getTextScaleMatrix()
-			).rightMul(
-				Mat33.scaling2D(this.editor.viewport.getSizeOfPixelOnCanvas())
-			).rightMul(
-				Mat33.zRotation(this.textRotation)
-			);
-
-			const textComponent = TextComponent.fromLines(content.split('\n'), textTransform, this.textStyle);
-
-			const action = EditorImage.addElement(textComponent);
-			if (this.removeExistingCommand) {
-				// Unapply so that `removeExistingCommand` can be added to the undo stack.
-				this.removeExistingCommand.unapply(this.editor);
-
-				this.editor.dispatch(uniteCommands([ this.removeExistingCommand, action ]));
-				this.removeExistingCommand = null;
-			} else {
-				this.editor.dispatch(action);
-			}
-		}
-	}
-
-	private getTextScaleMatrix() {
-		return Mat33.scaling2D(this.textScale.times(1/this.editor.viewport.getSizeOfPixelOnCanvas()));
-	}
-
-	private updateTextInput() {
-		if (!this.textInputElem || !this.textTargetPosition) {
-			this.textInputElem?.remove();
-			return;
-		}
-
-		const viewport = this.editor.viewport;
-		const textScreenPos = viewport.canvasToScreen(this.textTargetPosition);
-		this.textInputElem.placeholder = this.localizationTable.enterTextToInsert;
-		this.textInputElem.style.fontFamily = this.textStyle.fontFamily;
-		this.textInputElem.style.fontVariant = this.textStyle.fontVariant ?? '';
-		this.textInputElem.style.fontWeight = this.textStyle.fontWeight ?? '';
-		this.textInputElem.style.fontSize = `${this.textStyle.size}px`;
-		this.textInputElem.style.color = this.textStyle.renderingStyle.fill.toHexString();
-
-		this.textInputElem.style.position = 'relative';
-		this.textInputElem.style.left = `${textScreenPos.x}px`;
-		this.textInputElem.style.top = `${textScreenPos.y}px`;
-		this.textInputElem.style.margin = '0';
-
-		this.textInputElem.style.width = `${this.textInputElem.scrollWidth}px`;
-		this.textInputElem.style.height = `${this.textInputElem.scrollHeight}px`;
-
-		// Get the ascent based on the font, using a character that is tall in most fonts.
-		const tallCharacter = '⎢';
-		const ascent = this.getTextAscent(tallCharacter, this.textStyle);
-
-		const rotation = this.textRotation + viewport.getRotationAngle();
-		const scale: Mat33 = this.getTextScaleMatrix();
-		this.textInputElem.style.transform = `${scale.toCSSMatrix()} rotate(${rotation * 180 / Math.PI}deg) translate(0, ${-ascent}px)`;
-		this.textInputElem.style.transformOrigin = 'top left';
-	}
-
-	private startTextInput(textCanvasPos: Vec2, initialText: string) {
-		this.flushInput();
-
-		this.textInputElem = document.createElement('textarea');
-		this.textInputElem.value = initialText;
-		this.textInputElem.style.display = 'inline-block';
-		this.textTargetPosition = this.editor.viewport.roundPoint(textCanvasPos);
-		this.textRotation = -this.editor.viewport.getRotationAngle();
-		this.textScale = Vec2.of(1, 1).times(this.editor.viewport.getSizeOfPixelOnCanvas());
-		this.updateTextInput();
-
-		// Update the input size/position/etc. after the placeHolder has had time to appear.
-		setTimeout(() => this.updateTextInput(), 0);
-
-		this.textInputElem.oninput = () => {
-			if (this.textInputElem) {
-				this.textInputElem.style.width = `${this.textInputElem.scrollWidth}px`;
-				this.textInputElem.style.height = `${this.textInputElem.scrollHeight}px`;
-			}
-		};
-		this.textInputElem.onblur = () => {
-			// Delay removing the input -- flushInput may be called within a blur()
-			// event handler
-			const removeInput = false;
-			const input = this.textInputElem;
-
-			this.flushInput(removeInput);
-			this.textInputElem = null;
-			setTimeout(() => {
-				input?.remove();
-			}, 0);
-		};
-		this.textInputElem.onkeyup = (evt) => {
-			if (evt.key === 'Enter' && !evt.shiftKey) {
-				this.flushInput();
-				this.editor.focus();
-			} else if (evt.key === 'Escape') {
-				// Cancel input.
-				this.textInputElem?.remove();
-				this.textInputElem = null;
-				this.editor.focus();
-
-				this.removeExistingCommand?.unapply(this.editor);
-				this.removeExistingCommand = null;
-			}
-		};
-
-		this.textEditOverlay.replaceChildren(this.textInputElem);
-		setTimeout(() => this.textInputElem?.focus(), 0);
-	}
-
-	public setEnabled(enabled: boolean) {
-		super.setEnabled(enabled);
-
-		if (!enabled) {
-			this.flushInput();
-		}
-
-		this.textEditOverlay.style.display = enabled ? 'block' : 'none';
-	}
-
-	public onPointerDown({ current, allPointers }: PointerEvt): boolean {
-		if (current.device === PointerDevice.Eraser) {
-			return false;
-		}
-
-		if (allPointers.length === 1) {
-
-			// Are we clicking on a text node?
-			const canvasPos = current.canvasPos;
-			const halfTestRegionSize = Vec2.of(2.5, 2.5).times(this.editor.viewport.getSizeOfPixelOnCanvas());
-			const testRegion = Rect2.fromCorners(canvasPos.minus(halfTestRegionSize), canvasPos.plus(halfTestRegionSize));
-			const targetNodes = this.editor.image.getElementsIntersectingRegion(testRegion);
-			let targetTextNodes = targetNodes.filter(node => node instanceof TextComponent) as TextComponent[];
-
-			// Don't try to edit text nodes that contain the viewport (this allows us
-			// to zoom in on text nodes and add text on top of them.)
-			const visibleRect = this.editor.viewport.visibleRect;
-			targetTextNodes = targetTextNodes.filter(node => !node.getBBox().containsRect(visibleRect));
-
-			// End any TextNodes we're currently editing.
-			this.flushInput();
-
-			if (targetTextNodes.length > 0) {
-				const targetNode = targetTextNodes[targetTextNodes.length - 1];
-				this.setTextStyle(targetNode.getTextStyle());
-
-				// Create and temporarily apply removeExistingCommand.
-				this.removeExistingCommand = new Erase([ targetNode ]);
-				this.removeExistingCommand.apply(this.editor);
-
-				this.startTextInput(targetNode.getBaselinePos(), targetNode.getText());
-
-				const transform = targetNode.getTransform();
-				this.textRotation = transform.transformVec3(Vec2.unitX).angle();
-				const scaleFactor = transform.transformVec3(Vec2.unitX).magnitude();
-				this.textScale = Vec2.of(1, 1).times(scaleFactor);
-				this.updateTextInput();
-			} else {
-				this.removeExistingCommand = null;
-				this.startTextInput(current.canvasPos, '');
-			}
-			return true;
-		}
-
-		return false;
-	}
-
-	public onGestureCancel(): void {
-		this.flushInput();
-		this.editor.focus();
-	}
-
-	private dispatchUpdateEvent() {
-		this.updateTextInput();
-		this.editor.notifier.dispatch(EditorEventType.ToolUpdated, {
-			kind: EditorEventType.ToolUpdated,
-			tool: this,
-		});
-	}
-
-	public setFontFamily(fontFamily: string) {
-		if (fontFamily !== this.textStyle.fontFamily) {
-			this.textStyle = {
-				...this.textStyle,
-				fontFamily: fontFamily,
-			};
-
-			this.dispatchUpdateEvent();
-		}
-	}
-
-	public setColor(color: Color4) {
-		if (!color.eq(this.textStyle.renderingStyle.fill)) {
-			this.textStyle = {
-				...this.textStyle,
-				renderingStyle: {
-					...this.textStyle.renderingStyle,
-					fill: color,
-				},
-			};
-
-			this.dispatchUpdateEvent();
-		}
-	}
-
-	public setFontSize(size: number) {
-		if (size !== this.textStyle.size) {
-			this.textStyle = {
-				...this.textStyle,
-				size,
-			};
-
-			this.dispatchUpdateEvent();
-		}
-	}
-
-	public getTextStyle(): TextStyle {
-		return this.textStyle;
-	}
-
-	private setTextStyle(style: TextStyle) {
-		// Copy the style — we may change parts of it.
-		this.textStyle = { ...style, renderingStyle: { ...style.renderingStyle } };
-		this.dispatchUpdateEvent();
-	}
-}

package/src/tools/ToolController.ts

@@ -1,178 +0,0 @@
-import { InputEvtType, InputEvt, EditorEventType } from '../types';
-import Editor from '../Editor';
-import BaseTool from './BaseTool';
-import PanZoom, { PanZoomMode } from './PanZoom';
-import Pen from './Pen';
-import ToolEnabledGroup from './ToolEnabledGroup';
-import Eraser from './Eraser';
-import SelectionTool from './SelectionTool/SelectionTool';
-import Color4 from '../Color4';
-import { ToolLocalization } from './localization';
-import UndoRedoShortcut from './UndoRedoShortcut';
-import TextTool from './TextTool';
-import PipetteTool from './PipetteTool';
-import ToolSwitcherShortcut from './ToolSwitcherShortcut';
-import PasteHandler from './PasteHandler';
-import ToolbarShortcutHandler from './ToolbarShortcutHandler';
-import { makePressureSensitiveFreehandLineBuilder } from '../components/builders/PressureSensitiveFreehandLineBuilder';
-import FindTool from './FindTool';
-import SelectAllShortcutHandler from './SelectionTool/SelectAllShortcutHandler';
-
-export default class ToolController {
-	private tools: BaseTool[];
-	private activeTool: BaseTool|null = null;
-	private primaryToolGroup: ToolEnabledGroup;
-	
-	/** @internal */
-	public constructor(editor: Editor, localization: ToolLocalization) {
-		const primaryToolGroup = new ToolEnabledGroup();
-		this.primaryToolGroup = primaryToolGroup;
-		
-		const panZoomTool = new PanZoom(editor, PanZoomMode.TwoFingerTouchGestures | PanZoomMode.RightClickDrags, localization.touchPanTool);
-		const keyboardPanZoomTool = new PanZoom(editor, PanZoomMode.Keyboard, localization.keyboardPanZoom);
-		const primaryPenTool = new Pen(editor, localization.penTool(1), { color: Color4.purple, thickness: 8 });
-		const primaryTools = [
-			// Three pens
-			primaryPenTool,
-			new Pen(editor, localization.penTool(2), { color: Color4.clay, thickness: 4 }),
-			
-			// Highlighter-like pen with width=40
-			new Pen(editor, localization.penTool(3), { color: Color4.ofRGBA(1, 1, 0, 0.5), thickness: 40 }, makePressureSensitiveFreehandLineBuilder),
-			
-			new Eraser(editor, localization.eraserTool),
-			new SelectionTool(editor, localization.selectionTool),
-			new TextTool(editor, localization.textTool, localization),
-			new PanZoom(editor, PanZoomMode.SinglePointerGestures, localization.anyDevicePanning)
-		];
-		this.tools = [
-			new PipetteTool(editor, localization.pipetteTool),
-			panZoomTool,
-			...primaryTools,
-			keyboardPanZoomTool,
-			new UndoRedoShortcut(editor),
-			new ToolbarShortcutHandler(editor),
-			new ToolSwitcherShortcut(editor),
-			new FindTool(editor),
-			new PasteHandler(editor),
-			new SelectAllShortcutHandler(editor),
-		];
-		primaryTools.forEach(tool => tool.setToolGroup(primaryToolGroup));
-		panZoomTool.setEnabled(true);
-		primaryPenTool.setEnabled(true);
-		
-		editor.notifier.on(EditorEventType.ToolEnabled, event => {
-			if (event.kind === EditorEventType.ToolEnabled) {
-				editor.announceForAccessibility(localization.toolEnabledAnnouncement(event.tool.description));
-			}
-		});
-		editor.notifier.on(EditorEventType.ToolDisabled, event => {
-			if (event.kind === EditorEventType.ToolDisabled) {
-				editor.announceForAccessibility(localization.toolDisabledAnnouncement(event.tool.description));
-			}
-		});
-		
-		this.activeTool = null;
-	}
-	
-	// Replaces the current set of tools with `tools`. This should only be done before
-	// the creation of the app's toolbar (if using `HTMLToolbar`).
-	public setTools(tools: BaseTool[], primaryToolGroup?: ToolEnabledGroup) {
-		this.tools = tools;
-		this.primaryToolGroup = primaryToolGroup ?? new ToolEnabledGroup();
-	}
-	
-	// Add a tool that acts like one of the primary tools (only one primary tool can be enabled at a time).
-	// This should be called before creating the app's toolbar.
-	public addPrimaryTool(tool: BaseTool) {
-		tool.setToolGroup(this.primaryToolGroup);
-		if (tool.isEnabled()) {
-			this.primaryToolGroup.notifyEnabled(tool);
-		}
-		
-		this.addTool(tool);
-	}
-	
-	public getPrimaryTools(): BaseTool[] {
-		return this.tools.filter(tool => {
-			return tool.getToolGroup() === this.primaryToolGroup;
-		});
-	}
-	
-	// Add a tool to the end of this' tool list (the added tool receives events after tools already added to this).
-	// This should be called before creating the app's toolbar.
-	public addTool(tool: BaseTool) {
-		this.tools.push(tool);
-	}
-	
-	// Returns true if the event was handled
-	public dispatchInputEvent(event: InputEvt): boolean {
-		let handled = false;
-		if (event.kind === InputEvtType.PointerDownEvt) {
-			for (const tool of this.tools) {
-				if (tool.isEnabled() && tool.onPointerDown(event)) {
-					if (this.activeTool !== tool) {
-						this.activeTool?.onGestureCancel();
-					}
-					
-					this.activeTool = tool;
-					handled = true;
-					break;
-				}
-			}
-		} else if (event.kind === InputEvtType.PointerUpEvt) {
-			this.activeTool?.onPointerUp(event);
-			this.activeTool = null;
-			handled = true;
-		} else if (event.kind === InputEvtType.PointerMoveEvt) {
-			if (this.activeTool !== null) {
-				this.activeTool.onPointerMove(event);
-				handled = true;
-			}
-		} else if (event.kind === InputEvtType.GestureCancelEvt) {
-			if (this.activeTool !== null) {
-				this.activeTool.onGestureCancel();
-				this.activeTool = null;	
-			}
-		} else {
-			let allCasesHandledGuard: never;
-
-			for (const tool of this.tools) {
-				if (!tool.isEnabled()) {
-					continue;
-				}
-				
-				switch (event.kind) {
-				case InputEvtType.KeyPressEvent:
-					handled = tool.onKeyPress(event);
-					break;
-				case InputEvtType.KeyUpEvent:
-					handled = tool.onKeyUp(event);
-					break;
-				case InputEvtType.WheelEvt:
-					handled = tool.onWheel(event);
-					break;
-				case InputEvtType.CopyEvent:
-					handled = tool.onCopy(event);
-					break;
-				case InputEvtType.PasteEvent:
-					handled = tool.onPaste(event);
-					break;
-				default:
-					allCasesHandledGuard = event;
-					return allCasesHandledGuard;
-				}
-
-				if (handled) {
-					break;
-				}
-			}
-		}
-		
-		return handled;
-	}
-	
-	public getMatchingTools<Type extends BaseTool>(type: new (...args: any[])=>Type): Type[] {
-		return this.tools.filter(tool => tool instanceof type) as Type[];
-	}
-}
-

package/src/tools/ToolEnabledGroup.ts

@@ -1,14 +0,0 @@
-import BaseTool from './BaseTool';
-
-// Connects a group of tools -- at most one tool in the group can be enabled.
-export default class ToolEnabledGroup {
-	private activeTool: BaseTool|null;
-	public constructor() { }
-
-	public notifyEnabled(tool: BaseTool) {
-		if (tool !== this.activeTool) {
-			this.activeTool?.setEnabled(false);
-			this.activeTool = tool;
-		}
-	}
-}

package/src/tools/ToolSwitcherShortcut.ts

@@ -1,39 +0,0 @@
-import Editor from '../Editor';
-import { KeyPressEvent } from '../types';
-import BaseTool from './BaseTool';
-
-/**
- * Handles keyboard events used, by default, to select tools. By default,
- * 1 maps to the first primary tool, 2 to the second primary tool, ... .
- *
- * This is in the default set of {@link ToolController} tools.
- * 
- * @deprecated This may be replaced in the future.
- */
-export default class ToolSwitcherShortcut extends BaseTool {
-	public constructor(private editor: Editor) {
-		super(editor.notifier, editor.localization.changeTool);
-	}
-
-	// @internal
-	public onKeyPress({ key }: KeyPressEvent): boolean {
-		const toolController = this.editor.toolController;
-		const primaryTools = toolController.getPrimaryTools();
-
-		// Map keys 0-9 to primary tools.
-		const keyMatch = /^[0-9]$/.exec(key);
-
-		let targetTool: BaseTool|undefined;
-		if (keyMatch) {
-			const targetIdx = parseInt(keyMatch[0], 10) - 1;
-			targetTool = primaryTools[targetIdx];
-		}
-
-		if (targetTool) {
-			targetTool.setEnabled(true);
-			return true;
-		}
-
-		return false;
-	}
-}

package/src/tools/ToolbarShortcutHandler.ts

@@ -1,34 +0,0 @@
-// Allows the toolbar to register keyboard events.
-// @packageDocumentation
-
-import Editor from '../Editor';
-import { KeyPressEvent } from '../types';
-import BaseTool from './BaseTool';
-
-// Returns true if the event was handled, false otherwise.
-type KeyPressListener = (event: KeyPressEvent)=>boolean;
-
-export default class ToolbarShortcutHandler extends BaseTool {
-	private listeners: Set<KeyPressListener> = new Set([]);
-	public constructor(editor: Editor) {
-		super(editor.notifier, editor.localization.changeTool);
-	}
-
-	public registerListener(listener: KeyPressListener) {
-		this.listeners.add(listener);
-	}
-
-	public removeListener(listener: KeyPressListener) {
-		this.listeners.delete(listener);
-	}
-	
-	public onKeyPress(event: KeyPressEvent): boolean {
-		for (const listener of this.listeners) {
-			if (listener(event)) {
-				return true;
-			}
-		}
-
-		return false;
-	}
-}

package/src/tools/UndoRedoShortcut.test.ts

@@ -1,56 +0,0 @@
-/* @jest-environment jsdom */
-
-import Color4 from '../Color4';
-import Stroke from '../components/Stroke';
-import EditorImage from '../EditorImage';
-import Path from '../math/Path';
-import createEditor from '../testing/createEditor';
-import { InputEvtType } from '../types';
-
-describe('UndoRedoShortcut', () => {
-	const testStroke = new Stroke([Path.fromString('M0,0L10,10').toRenderable({ fill: Color4.red })]);
-	const addTestStrokeCommand = EditorImage.addElement(testStroke);
-
-	it('ctrl+z should undo', () => {
-		const editor = createEditor();
-		editor.dispatch(addTestStrokeCommand);
-		expect(editor.history.undoStackSize).toBe(1);
-
-		editor.toolController.dispatchInputEvent({
-			kind: InputEvtType.KeyPressEvent,
-			ctrlKey: true,
-			altKey: false,
-			key: 'z',
-		});
-		
-		expect(editor.history.undoStackSize).toBe(0);
-		expect(editor.history.redoStackSize).toBe(1);
-	});
-
-	it('ctrl+shift+Z should re-do', () => {
-		const editor = createEditor();
-		editor.dispatch(addTestStrokeCommand);
-		editor.dispatch(addTestStrokeCommand);
-		expect(editor.history.undoStackSize).toBe(2);
-
-		editor.toolController.dispatchInputEvent({
-			kind: InputEvtType.KeyPressEvent,
-			ctrlKey: true,
-			altKey: false,
-			key: 'z',
-		});
-
-		expect(editor.history.undoStackSize).toBe(1);
-		expect(editor.history.redoStackSize).toBe(1);
-
-		editor.toolController.dispatchInputEvent({
-			kind: InputEvtType.KeyPressEvent,
-			ctrlKey: true,
-			altKey: false,
-			key: 'Z',
-		});
-
-		expect(editor.history.undoStackSize).toBe(2);
-		expect(editor.history.redoStackSize).toBe(0);
-	});
-});

package/src/tools/UndoRedoShortcut.ts

@@ -1,25 +0,0 @@
-import Editor from '../Editor';
-import { KeyPressEvent } from '../types';
-import BaseTool from './BaseTool';
-
-// Handles ctrl+Z, ctrl+Shift+Z keyboard shortcuts.
-export default class UndoRedoShortcut extends BaseTool {
-	public constructor(private editor: Editor) {
-		super(editor.notifier, editor.localization.undoRedoTool);
-	}
-    
-	// @internal
-	public onKeyPress({ key, ctrlKey }: KeyPressEvent): boolean {
-		if (ctrlKey) {
-			if (key === 'z') {
-				this.editor.history.undo();
-				return true;
-			} else if (key === 'Z') {
-				this.editor.history.redo();
-				return true;
-			}
-		}
-
-		return false;
-	}
-}

package/src/tools/lib.ts

@@ -1,21 +0,0 @@
-
-/**
- * @packageDocumentation
- */
-
-export { default as BaseTool } from './BaseTool';
-export { default as ToolController } from './ToolController';
-export { default as ToolEnabledGroup } from './ToolEnabledGroup';
-
-export { default as UndoRedoShortcut } from './UndoRedoShortcut';
-export { default as ToolSwitcherShortcut } from './ToolSwitcherShortcut';
-export { default as PanZoomTool, PanZoomMode } from './PanZoom';
-
-export { default as PenTool, PenStyle } from './Pen';
-export { default as TextTool } from './TextTool';
-export { default as SelectionTool } from './SelectionTool/SelectionTool';
-export { default as SelectAllShortcutHandler } from './SelectionTool/SelectAllShortcutHandler';
-export { default as EraserTool } from './Eraser';
-export { default as PasteHandler } from './PasteHandler';
-
-export { default as ToolbarShortcutHandler } from './ToolbarShortcutHandler';