js-draw 1.16.0 → 1.17.0

package/dist/mjs/Editor.mjs

@@ -13,7 +13,6 @@ import  getLocalizationTable  from './localizations/getLocalizationTable.mjs';
 import  IconProvider  from './toolbar/IconProvider.mjs';
 import  CanvasRenderer  from './rendering/renderers/CanvasRenderer.mjs';
 import  untilNextAnimationFrame  from './util/untilNextAnimationFrame.mjs';
-import  fileToBase64Url  from './util/fileToBase64Url.mjs';
 import  uniteCommands  from './commands/uniteCommands.mjs';
 import  SelectionTool  from './tools/SelectionTool/SelectionTool.mjs';
 import  Erase  from './commands/Erase.mjs';
@@ -29,6 +28,7 @@ import  { editorImageToSVGSync, editorImageToSVGAsync }  from './image/export/ed
 import  { MutableReactiveValue }  from './util/ReactiveValue.mjs';
 import  listenForKeyboardEventsFrom  from './util/listenForKeyboardEventsFrom.mjs';
 import  mitLicenseAttribution  from './util/mitLicenseAttribution.mjs';
+import  ClipboardHandler  from './util/ClipboardHandler.mjs';
 /**
  * The main entrypoint for the full editor.
  *
@@ -109,6 +109,7 @@ export class Editor {
             iconProvider: settings.iconProvider ?? new IconProvider(),
             notices: [],
             appInfo: settings.appInfo ? { ...settings.appInfo } : null,
+            pens: { additionalPenTypes: settings.pens?.additionalPenTypes ?? [], },
         };
         // Validate settings
         if (this.settings.minZoom > this.settings.maxZoom) {
@@ -189,6 +190,16 @@ export class Editor {
             }
         });
     }
+    /**
+     * @returns a shallow copy of the current settings of the editor.
+     *
+     * Do not modify.
+     */
+    getCurrentSettings() {
+        return {
+            ...this.settings,
+        };
+    }
     /**
      * @returns a reference to the editor's container.
      *
@@ -238,6 +249,24 @@ export class Editor {
         this.handlePointerEventsFrom(this.renderingRegion);
         this.handleKeyEventsFrom(this.renderingRegion);
         this.handlePointerEventsFrom(this.accessibilityAnnounceArea);
+        // Prevent selected text from control areas from being dragged.
+        // See https://github.com/personalizedrefrigerator/joplin-plugin-freehand-drawing/issues/8
+        const preventSelectionOf = [
+            this.renderingRegion,
+            this.accessibilityAnnounceArea,
+            this.accessibilityControlArea,
+            this.loadingWarning,
+        ];
+        for (const element of preventSelectionOf) {
+            element.addEventListener('drag', event => {
+                event.preventDefault();
+                return false;
+            });
+            element.addEventListener('dragstart', event => {
+                event.preventDefault();
+                return false;
+            });
+        }
         this.container.addEventListener('wheel', evt => {
             this.handleHTMLWheelEvent(evt);
         });
@@ -257,19 +286,12 @@ export class Editor {
         this.accessibilityControlArea.addEventListener('input', () => {
             this.accessibilityControlArea.value = '';
         });
-        document.addEventListener('copy', evt => {
+        const copyHandler = new ClipboardHandler(this);
+        document.addEventListener('copy', async (evt) => {
             if (!this.isEventSink(document.querySelector(':focus'))) {
                 return;
             }
-            const clipboardData = evt.clipboardData;
-            if (this.toolController.dispatchInputEvent({
-                kind: InputEvtType.CopyEvent,
-                setData: (mime, data) => {
-                    clipboardData?.setData(mime, data);
-                },
-            })) {
-                evt.preventDefault();
-            }
+            copyHandler.copy(evt);
         });
         document.addEventListener('paste', evt => {
             this.handlePaste(evt);
@@ -337,11 +359,21 @@ export class Editor {
      * (e.g. with synthetic events). @internal
      */
     setPointerCapture(target, pointerId) {
-        target.setPointerCapture(pointerId);
+        try {
+            target.setPointerCapture(pointerId);
+        }
+        catch (error) {
+            console.warn('Failed to setPointerCapture', error);
+        }
     }
     /** Can be overridden in a testing environment to handle synthetic events. @internal */
     releasePointerCapture(target, pointerId) {
-        target.releasePointerCapture(pointerId);
+        try {
+            target.releasePointerCapture(pointerId);
+        }
+        catch (error) {
+            console.warn('Failed to releasePointerCapture', error);
+        }
     }
     /**
      * Dispatches a `PointerEvent` to the editor. The target element for `evt` must have the same top left
@@ -367,7 +399,7 @@ export class Editor {
             if (pointer.down) {
                 const prevData = this.pointers[pointer.id];
                 if (prevData) {
-                    const distanceMoved = pointer.screenPos.minus(prevData.screenPos).magnitude();
+                    const distanceMoved = pointer.screenPos.distanceTo(prevData.screenPos);
                     // If the pointer moved less than two pixels, don't send a new event.
                     if (distanceMoved < 2) {
                         return false;
@@ -415,71 +447,18 @@ export class Editor {
         }
         return false;
     }
+    /** @internal */
+    async handleDrop(evt) {
+        evt.preventDefault();
+        this.handlePaste(evt);
+    }
+    /** @internal */
     async handlePaste(evt) {
         const target = document.querySelector(':focus') ?? evt.target;
         if (!this.isEventSink(target)) {
             return;
         }
-        const clipboardData = evt.dataTransfer ?? evt.clipboardData;
-        if (!clipboardData) {
-            return;
-        }
-        // Handle SVG files (prefer to PNG/JPEG)
-        for (const file of clipboardData.files) {
-            if (file.type.toLowerCase() === 'image/svg+xml') {
-                const text = await file.text();
-                if (this.toolController.dispatchInputEvent({
-                    kind: InputEvtType.PasteEvent,
-                    mime: file.type,
-                    data: text,
-                })) {
-                    evt.preventDefault();
-                    return;
-                }
-            }
-        }
-        // Handle image files.
-        for (const file of clipboardData.files) {
-            const fileType = file.type.toLowerCase();
-            if (fileType === 'image/png' || fileType === 'image/jpg') {
-                this.showLoadingWarning(0);
-                const onprogress = (evt) => {
-                    this.showLoadingWarning(evt.loaded / evt.total);
-                };
-                try {
-                    const data = await fileToBase64Url(file, { onprogress });
-                    if (data && this.toolController.dispatchInputEvent({
-                        kind: InputEvtType.PasteEvent,
-                        mime: fileType,
-                        data: data,
-                    })) {
-                        evt.preventDefault();
-                        this.hideLoadingWarning();
-                        return;
-                    }
-                }
-                catch (e) {
-                    console.error('Error reading image:', e);
-                }
-                this.hideLoadingWarning();
-            }
-        }
-        // Supported MIMEs for text data, in order of preference
-        const supportedMIMEs = [
-            'image/svg+xml',
-            'text/plain',
-        ];
-        for (const mime of supportedMIMEs) {
-            const data = clipboardData.getData(mime);
-            if (data && this.toolController.dispatchInputEvent({
-                kind: InputEvtType.PasteEvent,
-                mime,
-                data,
-            })) {
-                evt.preventDefault();
-                return;
-            }
-        }
+        return await new ClipboardHandler(this).paste(evt);
     }
     /**
      * Forward pointer events from `elem` to this editor. Such that right-click/right-click drag
@@ -590,7 +569,7 @@ export class Editor {
                 const eventBuffer = gestureData[pointerId].eventBuffer;
                 // Skip if the pointer hasn't moved enough to not be a "click".
                 const strokeStartThreshold = 10;
-                const isWithinClickThreshold = gestureStartPos && currentPos.minus(gestureStartPos).magnitude() < strokeStartThreshold;
+                const isWithinClickThreshold = gestureStartPos && currentPos.distanceTo(gestureStartPos) < strokeStartThreshold;
                 if (isWithinClickThreshold && !gestureData[pointerId].hasMovedSignificantly) {
                     eventBuffer.push([eventName, event]);
                     sendToEditor = false;
@@ -677,8 +656,7 @@ export class Editor {
             evt.preventDefault();
         };
         elem.ondrop = evt => {
-            evt.preventDefault();
-            this.handlePaste(evt);
+            this.handleDrop(evt);
         };
         this.eventListenerTargets.push(elem);
     }
@@ -705,7 +683,8 @@ export class Editor {
     /** `apply` a command. `command` will be announced for accessibility. */
     dispatch(command, addToHistory = true) {
         const dispatchResult = this.dispatchNoAnnounce(command, addToHistory);
-        this.announceForAccessibility(command.description(this, this.localization));
+        const commandDescription = command.description(this, this.localization);
+        this.announceForAccessibility(commandDescription);
         return dispatchResult;
     }
     /**
@@ -919,8 +898,11 @@ export class Editor {
      * This is a convenience method that creates **and applies** a single command.
      *
      * If `selectComponents` is true (the default), the components are selected.
+     *
+     * `actionDescription`, if given, should be a screenreader-friendly description of the
+     * reason components were added (e.g. "pasted").
      */
-    async addAndCenterComponents(components, selectComponents = true) {
+    async addAndCenterComponents(components, selectComponents = true, actionDescription) {
         let bbox = null;
         for (const component of components) {
             if (bbox) {
@@ -951,7 +933,7 @@ export class Editor {
             commands.push(component.transformBy(transfm));
         }
         const applyChunkSize = 100;
-        await this.dispatch(uniteCommands(commands, applyChunkSize), true);
+        await this.dispatch(uniteCommands(commands, { applyChunkSize, description: actionDescription }), true);
         if (selectComponents) {
             for (const selectionTool of this.toolController.getMatchingTools(SelectionTool)) {
                 selectionTool.setEnabled(true);
@@ -971,17 +953,7 @@ export class Editor {
      * [[include:doc-pages/inline-examples/adding-an-image-and-data-urls.md]]
      */
     toDataURL(format = 'image/png', outputSize) {
-        const canvas = document.createElement('canvas');
-        const importExportViewport = this.image.getImportExportViewport();
-        const exportRectSize = importExportViewport.getScreenRectSize();
-        const resolution = outputSize ?? exportRectSize;
-        canvas.width = resolution.x;
-        canvas.height = resolution.y;
-        const ctx = canvas.getContext('2d');
-        // Scale to ensure that the entire output is visible.
-        const scaleFactor = Math.min(resolution.x / exportRectSize.x, resolution.y / exportRectSize.y);
-        ctx.scale(scaleFactor, scaleFactor);
-        const renderer = new CanvasRenderer(ctx, importExportViewport);
+        const { element: canvas, renderer } = CanvasRenderer.fromViewport(this.image.getImportExportViewport(), { canvasSize: outputSize });
         this.image.renderAll(renderer);
         const dataURL = canvas.toDataURL(format);
         return dataURL;
@@ -1074,8 +1046,59 @@ export class Editor {
         }
         return background;
     }
+    /**
+     * This is a convenience method for adding or updating the {@link BackgroundComponent}
+     * and {@link EditorImage.setAutoresizeEnabled} for the current image.
+     *
+     * If there are multiple {@link BackgroundComponent}s in the image, this only modifies
+     * the topmost such element.
+     *
+     * **Example**:
+     * ```ts,runnable
+     * import { Editor, Color4, BackgroundComponentBackgroundType } from 'js-draw';
+     * const editor = new Editor(document.body);
+     * editor.dispatch(editor.setBackgroundStyle({
+     *     color: Color4.orange,
+     *     type: BackgroundComponentBackgroundType.Grid,
+     *     autoresize: true,
+     * }));
+     * ```
+     *
+     * To change the background size, see {@link EditorImage.setImportExportRect}.
+     */
+    setBackgroundStyle(style) {
+        const originalBackground = this.getTopmostBackgroundComponent();
+        const commands = [];
+        if (originalBackground) {
+            commands.push(new Erase([originalBackground]));
+        }
+        const originalType = originalBackground?.getBackgroundType?.() ?? BackgroundType.None;
+        const originalColor = originalBackground?.getStyle?.().color ?? Color4.transparent;
+        const originalFillsScreen = this.image.getAutoresizeEnabled();
+        const defaultType = (style.color && originalType === BackgroundType.None ? BackgroundType.SolidColor : originalType);
+        const backgroundType = style.type ?? defaultType;
+        const backgroundColor = style.color ?? originalColor;
+        const fillsScreen = style.autoresize ?? originalFillsScreen;
+        if (backgroundType !== BackgroundType.None) {
+            const newBackground = new BackgroundComponent(backgroundType, backgroundColor);
+            commands.push(EditorImage.addElement(newBackground));
+        }
+        if (fillsScreen !== originalFillsScreen) {
+            commands.push(this.image.setAutoresizeEnabled(fillsScreen));
+            // Avoid 0x0 backgrounds
+            if (!fillsScreen && this.image.getImportExportRect().maxDimension === 0) {
+                commands.push(this.image.setImportExportRect(this.image.getImportExportRect().resizedTo(Vec2.of(500, 500))));
+            }
+        }
+        return uniteCommands(commands);
+    }
     /**
      * Set the background color of the image.
+     *
+     * This is a convenience method for adding or updating the {@link BackgroundComponent}
+     * for the current image.
+     *
+     * @see {@link setBackgroundStyle}
      */
     setBackgroundColor(color) {
         let background = this.getTopmostBackgroundComponent();

package/dist/mjs/Pointer.d.ts

@@ -35,5 +35,6 @@ export default class Pointer {
      */
     withCanvasPosition(canvasPos: Point2, viewport: Viewport): Pointer;
     static ofEvent(evt: PointerEvent, isDown: boolean, viewport: Viewport, relativeTo?: HTMLElement): Pointer;
-    static ofCanvasPoint(canvasPos: Point2, isDown: boolean, viewport: Viewport, id?: number, device?: PointerDevice, isPrimary?: boolean, pressure?: number | null): Pointer;
+    static ofCanvasPoint(canvasPos: Point2, isDown: boolean, viewport: Viewport, id?: number, device?: PointerDevice, isPrimary?: boolean, pressure?: number | null, timeStamp?: number | null): Pointer;
+    static ofScreenPoint(screenPos: Point2, isDown: boolean, viewport: Viewport, id?: number, device?: PointerDevice, isPrimary?: boolean, pressure?: number | null, timeStamp?: number | null): Pointer;
 }

package/dist/mjs/Pointer.mjs

@@ -110,9 +110,16 @@ export default class Pointer {
     }
     // Create a new Pointer from a point on the canvas.
     // Intended for unit tests.
-    static ofCanvasPoint(canvasPos, isDown, viewport, id = 0, device = PointerDevice.Pen, isPrimary = true, pressure = null) {
+    static ofCanvasPoint(canvasPos, isDown, viewport, id = 0, device = PointerDevice.Pen, isPrimary = true, pressure = null, timeStamp = null) {
         const screenPos = viewport.canvasToScreen(canvasPos);
-        const timeStamp = performance.now();
+        timeStamp ??= performance.now();
+        return new Pointer(screenPos, canvasPos, pressure, isPrimary, isDown, device, id, timeStamp);
+    }
+    // Create a new Pointer from a point on the screen.
+    // Intended for unit tests.
+    static ofScreenPoint(screenPos, isDown, viewport, id = 0, device = PointerDevice.Pen, isPrimary = true, pressure = null, timeStamp = null) {
+        const canvasPos = viewport.screenToCanvas(screenPos);
+        timeStamp ??= performance.now();
         return new Pointer(screenPos, canvasPos, pressure, isPrimary, isDown, device, id, timeStamp);
     }
 }

package/dist/mjs/commands/localization.d.ts

@@ -20,6 +20,7 @@ export interface CommandLocalization {
     duplicateAction: (elemDescription: string, count: number) => string;
     inverseOf: (actionDescription: string) => string;
     unionOf: (actionDescription: string, actionCount: number) => string;
+    andNMoreCommands: (count: number) => string;
     selectedElements: (count: number) => string;
 }
 export declare const defaultCommandLocalization: CommandLocalization;

package/dist/mjs/commands/localization.mjs

@@ -19,5 +19,6 @@ export const defaultCommandLocalization = {
     movedRight: 'Moved right',
     zoomedOut: 'Zoomed out',
     zoomedIn: 'Zoomed in',
+    andNMoreCommands: (count) => `And ${count} more commands.`,
     selectedElements: (count) => `Selected ${count} element${count === 1 ? '' : 's'}`,
 };

package/dist/mjs/commands/uniteCommands.d.ts

@@ -1,5 +1,9 @@
 import Command from './Command';
 import SerializableCommand from './SerializableCommand';
+export interface UniteCommandsOptions {
+    applyChunkSize?: number;
+    description?: string;
+}
 /**
  * Creates a single command from `commands`. This is useful when undoing should undo *all* commands
  * in `commands` at once, rather than one at a time.
@@ -36,5 +40,5 @@ import SerializableCommand from './SerializableCommand';
  * // applying them shouldn't be done all at once (which would block the UI).
  * ```
  */
-declare const uniteCommands: <T extends Command>(commands: T[], applyChunkSize?: number) => T extends SerializableCommand ? SerializableCommand : Command;
+declare const uniteCommands: <T extends Command>(commands: T[], options?: UniteCommandsOptions | number) => T extends SerializableCommand ? SerializableCommand : Command;
 export default uniteCommands;

package/dist/mjs/commands/uniteCommands.mjs

@@ -2,10 +2,11 @@ import  waitForAll  from '../util/waitForAll.mjs';
 import  Command  from './Command.mjs';
 import  SerializableCommand  from './SerializableCommand.mjs';
 class NonSerializableUnion extends Command {
-    constructor(commands, applyChunkSize) {
+    constructor(commands, applyChunkSize, descriptionOverride) {
         super();
         this.commands = commands;
         this.applyChunkSize = applyChunkSize;
+        this.descriptionOverride = descriptionOverride;
     }
     apply(editor) {
         if (this.applyChunkSize === undefined) {
@@ -31,9 +32,13 @@ class NonSerializableUnion extends Command {
         this.commands.forEach(command => command.onDrop(editor));
     }
     description(editor, localizationTable) {
+        if (this.descriptionOverride) {
+            return this.descriptionOverride;
+        }
         const descriptions = [];
         let lastDescription = null;
         let duplicateDescriptionCount = 0;
+        let handledCommandCount = 0;
         for (const part of this.commands) {
             const description = part.description(editor, localizationTable);
             if (description !== lastDescription && lastDescription !== null) {
@@ -42,7 +47,13 @@ class NonSerializableUnion extends Command {
                 duplicateDescriptionCount = 0;
             }
             duplicateDescriptionCount++;
+            handledCommandCount++;
             lastDescription ??= description;
+            // Long descriptions aren't very useful to the user.
+            const maxDescriptionLength = 12;
+            if (descriptions.length > maxDescriptionLength) {
+                break;
+            }
         }
         if (duplicateDescriptionCount > 1) {
             descriptions.push(localizationTable.unionOf(lastDescription, duplicateDescriptionCount));
@@ -50,15 +61,19 @@ class NonSerializableUnion extends Command {
         else if (duplicateDescriptionCount === 1) {
             descriptions.push(lastDescription);
         }
+        if (handledCommandCount < this.commands.length) {
+            descriptions.push(localizationTable.andNMoreCommands(this.commands.length - handledCommandCount));
+        }
         return descriptions.join(', ');
     }
 }
 class SerializableUnion extends SerializableCommand {
-    constructor(commands, applyChunkSize) {
+    constructor(commands, applyChunkSize, descriptionOverride) {
         super('union');
         this.commands = commands;
         this.applyChunkSize = applyChunkSize;
-        this.nonserializableCommand = new NonSerializableUnion(commands, applyChunkSize);
+        this.descriptionOverride = descriptionOverride;
+        this.nonserializableCommand = new NonSerializableUnion(commands, applyChunkSize, descriptionOverride);
     }
     serializeToJSON() {
         if (this.serializedData) {
@@ -67,6 +82,7 @@ class SerializableUnion extends SerializableCommand {
         return {
             applyChunkSize: this.applyChunkSize,
             data: this.commands.map(command => command.serialize()),
+            description: this.descriptionOverride,
         };
     }
     apply(editor) {
@@ -120,7 +136,7 @@ class SerializableUnion extends SerializableCommand {
  * // applying them shouldn't be done all at once (which would block the UI).
  * ```
  */
-const uniteCommands = (commands, applyChunkSize) => {
+const uniteCommands = (commands, options) => {
     let allSerializable = true;
     for (const command of commands) {
         if (!(command instanceof SerializableCommand)) {
@@ -128,12 +144,21 @@ const uniteCommands = (commands, applyChunkSize) => {
             break;
         }
     }
+    let applyChunkSize;
+    let description;
+    if (typeof options === 'number') {
+        applyChunkSize = options;
+    }
+    else {
+        applyChunkSize = options?.applyChunkSize;
+        description = options?.description;
+    }
     if (!allSerializable) {
-        return new NonSerializableUnion(commands, applyChunkSize);
+        return new NonSerializableUnion(commands, applyChunkSize, description);
     }
     else {
         const castedCommands = commands;
-        return new SerializableUnion(castedCommands, applyChunkSize);
+        return new SerializableUnion(castedCommands, applyChunkSize, description);
     }
 };
 SerializableCommand.register('union', (data, editor) => {
@@ -144,10 +169,11 @@ SerializableCommand.register('union', (data, editor) => {
     if (typeof applyChunkSize !== 'number' && applyChunkSize !== undefined) {
         throw new Error('serialized applyChunkSize is neither undefined nor a number.');
     }
+    const description = typeof data.description === 'string' ? data.description : undefined;
     const commands = [];
     for (const part of data.data) {
         commands.push(SerializableCommand.deserialize(part, editor));
     }
-    return uniteCommands(commands, applyChunkSize);
+    return uniteCommands(commands, { applyChunkSize, description });
 });
 export default uniteCommands;

package/dist/mjs/components/TextComponent.d.ts

@@ -19,6 +19,41 @@ export declare enum TextTransformMode {
 type TextElement = TextComponent | string;
 /**
  * Displays text.
+ *
+ * A `TextComponent` is a collection of `TextElement`s (`string`s or {@link TextComponent}s).
+ *
+ * **Example**:
+ *
+ * ```ts,runnable
+ * import { Editor, TextComponent, Mat33, Vec2, Color4, TextRenderingStyle } from 'js-draw';
+ * const editor = new Editor(document.body);
+ * editor.dispatch(editor.setBackgroundStyle({ color: Color4.black, autoresize: true ));
+ * ---visible---
+ * /// Adding a simple TextComponent
+ * ///------------------------------
+ *
+ * const positioning1 = Mat33.translation(Vec2.of(10, 10));
+ * const style: TextRenderingStyle = {
+ *     fontFamily: 'sans', size: 12, renderingStyle: { fill: Color4.green },
+ * };
+ *
+ * editor.dispatch(
+ *     editor.image.addElement(new TextComponent(['Hello, world'], positioning1, style)),
+ * );
+ *
+ *
+ * /// Adding nested TextComponents
+ * ///-----------------------------
+ *
+ * // Add another TextComponent that contains text and a TextComponent. Observe that '[Test]'
+ * // is placed directly after 'Test'.
+ * const positioning2 = Mat33.translation(Vec2.of(10, 50));
+ * editor.dispatch(
+ *     editor.image.addElement(
+ *         new TextComponent([ new TextComponent(['Test'], positioning1, style), '[Test]' ], positioning2, style)
+ *     ),
+ * );
+ * ```
  */
 export default class TextComponent extends AbstractComponent implements RestyleableComponent {
     protected readonly textObjects: Array<TextElement>;
@@ -32,7 +67,7 @@ export default class TextComponent extends AbstractComponent implements Restylea
      *
      * @see {@link fromLines}
      */
-    constructor(textObjects: Array<TextElement>, transform: Mat33, style: TextRenderingStyle, transformMode?: TextTransformMode);
+    constructor(textObjects: Array<TextElement>, transform: Mat33, style?: TextRenderingStyle, transformMode?: TextTransformMode);
     static applyTextStyles(ctx: CanvasRenderingContext2D, style: TextRenderingStyle): void;
     private static textMeasuringCtx;
     private static estimateTextDimens;

package/dist/mjs/components/TextComponent.mjs

@@ -1,4 +1,4 @@
-import { Vec2, Rect2, Mat33 } from '@js-draw/math';
+import { Vec2, Rect2, Mat33, Color4 } from '@js-draw/math';
 import  { cloneTextStyle, textStyleFromJSON, textStyleToJSON }  from '../rendering/TextRenderingStyle.mjs';
 import  AbstractComponent  from './AbstractComponent.mjs';
 import  { createRestyleComponentCommand }  from './RestylableComponent.mjs';
@@ -14,8 +14,46 @@ export var TextTransformMode;
     /**Relatively positioned in the Y direction, absolutely positioned in the X direction. */
     TextTransformMode[TextTransformMode["RELATIVE_Y_ABSOLUTE_X"] = 3] = "RELATIVE_Y_ABSOLUTE_X";
 })(TextTransformMode || (TextTransformMode = {}));
+const defaultTextStyle = {
+    fontFamily: 'sans', size: 12, renderingStyle: { fill: Color4.purple },
+};
 /**
  * Displays text.
+ *
+ * A `TextComponent` is a collection of `TextElement`s (`string`s or {@link TextComponent}s).
+ *
+ * **Example**:
+ *
+ * ```ts,runnable
+ * import { Editor, TextComponent, Mat33, Vec2, Color4, TextRenderingStyle } from 'js-draw';
+ * const editor = new Editor(document.body);
+ * editor.dispatch(editor.setBackgroundStyle({ color: Color4.black, autoresize: true ));
+ * ---visible---
+ * /// Adding a simple TextComponent
+ * ///------------------------------
+ *
+ * const positioning1 = Mat33.translation(Vec2.of(10, 10));
+ * const style: TextRenderingStyle = {
+ *     fontFamily: 'sans', size: 12, renderingStyle: { fill: Color4.green },
+ * };
+ *
+ * editor.dispatch(
+ *     editor.image.addElement(new TextComponent(['Hello, world'], positioning1, style)),
+ * );
+ *
+ *
+ * /// Adding nested TextComponents
+ * ///-----------------------------
+ *
+ * // Add another TextComponent that contains text and a TextComponent. Observe that '[Test]'
+ * // is placed directly after 'Test'.
+ * const positioning2 = Mat33.translation(Vec2.of(10, 50));
+ * editor.dispatch(
+ *     editor.image.addElement(
+ *         new TextComponent([ new TextComponent(['Test'], positioning1, style), '[Test]' ], positioning2, style)
+ *     ),
+ * );
+ * ```
  */
 class TextComponent extends AbstractComponent {
     /**
@@ -25,7 +63,7 @@ class TextComponent extends AbstractComponent {
      */
     constructor(textObjects, 
     // Transformation relative to this component's parent element.
-    transform, style, 
+    transform, style = defaultTextStyle, 
     // @internal
     transformMode = TextTransformMode.ABSOLUTE_XY) {
         super(componentTypeId);

package/dist/mjs/components/builders/ArrowBuilder.mjs

@@ -21,7 +21,7 @@ export default class ArrowBuilder {
         const lineStartPoint = this.startPoint.pos;
         const endPoint = this.endPoint.pos;
         const toEnd = endPoint.minus(lineStartPoint).normalized();
-        const arrowLength = endPoint.minus(lineStartPoint).length();
+        const arrowLength = endPoint.distanceTo(lineStartPoint);
         // Ensure that the arrow tip is smaller than the arrow.
         const arrowTipSize = Math.min(this.getLineWidth(), arrowLength / 2);
         const startSize = this.startPoint.width / 2;

package/dist/mjs/components/builders/PolylineBuilder.d.ts

@@ -0,0 +1,35 @@
+import AbstractRenderer from '../../rendering/renderers/AbstractRenderer';
+import RenderablePathSpec from '../../rendering/RenderablePathSpec';
+import { Rect2 } from '@js-draw/math';
+import Stroke from '../Stroke';
+import Viewport from '../../Viewport';
+import { StrokeDataPoint } from '../../types';
+import { ComponentBuilder, ComponentBuilderFactory } from './types';
+import RenderingStyle from '../../rendering/RenderingStyle';
+/**
+ * Creates strokes from line segments rather than Bézier curves.
+ *
+ * @beta Output behavior may change significantly between versions. For now, intended for debugging.
+ */
+export declare const makePolylineBuilder: ComponentBuilderFactory;
+export default class PolylineBuilder implements ComponentBuilder {
+    private minFitAllowed;
+    private viewport;
+    private parts;
+    private bbox;
+    private averageWidth;
+    private widthAverageNumSamples;
+    private lastPoint;
+    private startPoint;
+    constructor(startPoint: StrokeDataPoint, minFitAllowed: number, viewport: Viewport);
+    getBBox(): Rect2;
+    protected getRenderingStyle(): RenderingStyle;
+    protected previewCurrentPath(): RenderablePathSpec;
+    protected previewFullPath(): RenderablePathSpec[];
+    preview(renderer: AbstractRenderer): void;
+    build(): Stroke;
+    private getMinFit;
+    private roundPoint;
+    private roundDistance;
+    addPoint(newPoint: StrokeDataPoint): void;
+}