js-draw 0.18.1 → 0.19.0

package/dist/mjs/src/components/Stroke.mjs

@@ -0,0 +1,219 @@
+import  Path  from '../math/Path.mjs';
+import  Rect2  from '../math/Rect2.mjs';
+import  { styleFromJSON, styleToJSON }  from '../rendering/RenderingStyle.mjs';
+import  AbstractComponent  from './AbstractComponent.mjs';
+import  { createRestyleComponentCommand }  from './RestylableComponent.mjs';
+/**
+ * Represents an {@link AbstractComponent} made up of one or more {@link Path}s.
+ *
+ * @example
+ * For some {@link Editor} editor and `Stroke` stroke,
+ *
+ * **Restyling**:
+ * ```ts
+ * editor.dispatch(stroke.updateStyle({ color: Color4.red }));
+ * ```
+ *
+ * **Transforming**:
+ * ```ts
+ * editor.dispatch(stroke.transformBy(Mat33.translation(Vec2.of(10, 0))));
+ * ```
+ */
+export default class Stroke extends AbstractComponent {
+    /**
+     * Creates a `Stroke` from the given `parts`. All parts should have the
+     * same color.
+     *
+     * @example
+     * ```ts
+     * // A path that starts at (1,1), moves to the right by (2, 0),
+     * // then moves down and right by (3, 3)
+     * const path = Path.fromString('m1,1 2,0 3,3');
+     *
+     * const stroke = new Stroke([
+     *     // Fill with red
+     *     path.toRenderable({ fill: Color4.red })
+     * ]);
+     * ```
+     */
+    constructor(parts) {
+        var _a;
+        super('stroke');
+        // @internal
+        // eslint-disable-next-line @typescript-eslint/prefer-as-const
+        this.isRestylableComponent = true;
+        this.approximateRenderingTime = 0;
+        this.parts = [];
+        for (const section of parts) {
+            const path = Path.fromRenderable(section);
+            const pathBBox = this.bboxForPart(path.bbox, section.style);
+            if (!this.contentBBox) {
+                this.contentBBox = pathBBox;
+            }
+            else {
+                this.contentBBox = this.contentBBox.union(pathBBox);
+            }
+            this.parts.push({
+                path,
+                // To implement RenderablePathSpec
+                startPoint: path.startPoint,
+                style: section.style,
+                commands: path.parts,
+            });
+            this.approximateRenderingTime += path.parts.length;
+        }
+        (_a = this.contentBBox) !== null && _a !== void 0 ? _a : (this.contentBBox = Rect2.empty);
+    }
+    getStyle() {
+        if (this.parts.length === 0) {
+            return {};
+        }
+        const firstPart = this.parts[0];
+        if (firstPart.style.stroke === undefined
+            || firstPart.style.stroke.width === 0) {
+            return {
+                color: firstPart.style.fill,
+            };
+        }
+        return {
+            color: firstPart.style.stroke.color,
+        };
+    }
+    updateStyle(style) {
+        return createRestyleComponentCommand(this.getStyle(), style, this);
+    }
+    forceStyle(style, editor) {
+        if (!style.color) {
+            return;
+        }
+        this.parts = this.parts.map((part) => {
+            const newStyle = Object.assign(Object.assign({}, part.style), { stroke: part.style.stroke ? Object.assign({}, part.style.stroke) : undefined });
+            // Change the stroke color if a stroked shape. Else,
+            // change the fill.
+            if (newStyle.stroke && newStyle.stroke.width > 0) {
+                newStyle.stroke.color = style.color;
+            }
+            else {
+                newStyle.fill = style.color;
+            }
+            return {
+                path: part.path,
+                startPoint: part.startPoint,
+                commands: part.commands,
+                style: newStyle,
+            };
+        });
+        if (editor) {
+            editor.image.queueRerenderOf(this);
+            editor.queueRerender();
+        }
+    }
+    intersects(line) {
+        for (const part of this.parts) {
+            if (part.path.intersection(line).length > 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+    render(canvas, visibleRect) {
+        var _a, _b;
+        canvas.startObject(this.getBBox());
+        for (const part of this.parts) {
+            const bbox = this.bboxForPart(part.path.bbox, part.style);
+            if (visibleRect) {
+                if (!bbox.intersects(visibleRect)) {
+                    continue;
+                }
+                const muchBiggerThanVisible = bbox.size.x > visibleRect.size.x * 2 || bbox.size.y > visibleRect.size.y * 2;
+                if (muchBiggerThanVisible && !part.path.roughlyIntersects(visibleRect, (_b = (_a = part.style.stroke) === null || _a === void 0 ? void 0 : _a.width) !== null && _b !== void 0 ? _b : 0)) {
+                    continue;
+                }
+            }
+            canvas.drawPath(part);
+        }
+        canvas.endObject(this.getLoadSaveData());
+    }
+    getProportionalRenderingTime() {
+        return this.approximateRenderingTime;
+    }
+    // Grows the bounding box for a given stroke part based on that part's style.
+    bboxForPart(origBBox, style) {
+        if (!style.stroke) {
+            return origBBox;
+        }
+        return origBBox.grownBy(style.stroke.width / 2);
+    }
+    applyTransformation(affineTransfm) {
+        this.contentBBox = Rect2.empty;
+        let isFirstPart = true;
+        // Update each part
+        this.parts = this.parts.map((part) => {
+            const newPath = part.path.transformedBy(affineTransfm);
+            const newStyle = Object.assign(Object.assign({}, part.style), { stroke: part.style.stroke ? Object.assign({}, part.style.stroke) : undefined });
+            // Approximate the scale factor.
+            if (newStyle.stroke) {
+                const scaleFactor = affineTransfm.getScaleFactor();
+                newStyle.stroke.width *= scaleFactor;
+            }
+            const newBBox = this.bboxForPart(newPath.bbox, newStyle);
+            if (isFirstPart) {
+                this.contentBBox = newBBox;
+                isFirstPart = false;
+            }
+            else {
+                this.contentBBox = this.contentBBox.union(newBBox);
+            }
+            return {
+                path: newPath,
+                startPoint: newPath.startPoint,
+                commands: newPath.parts,
+                style: newStyle,
+            };
+        });
+    }
+    /**
+     * @returns the {@link Path.union} of all paths that make up this stroke.
+     */
+    getPath() {
+        let result = null;
+        for (const part of this.parts) {
+            if (result) {
+                result = result.union(part.path);
+            }
+            else {
+                result !== null && result !== void 0 ? result : (result = part.path);
+            }
+        }
+        return result !== null && result !== void 0 ? result : Path.empty;
+    }
+    description(localization) {
+        return localization.stroke;
+    }
+    createClone() {
+        return new Stroke(this.parts);
+    }
+    serializeToJSON() {
+        return this.parts.map(part => {
+            return {
+                style: styleToJSON(part.style),
+                path: part.path.serialize(),
+            };
+        });
+    }
+    /** @internal */
+    static deserializeFromJSON(json) {
+        if (typeof json === 'string') {
+            json = JSON.parse(json);
+        }
+        if (typeof json !== 'object' || typeof json.length !== 'number') {
+            throw new Error(`${json} is missing required field, parts, or parts is of the wrong type.`);
+        }
+        const pathSpec = json.map((part) => {
+            const style = styleFromJSON(part.style);
+            return Path.fromString(part.path).toRenderable(style);
+        });
+        return new Stroke(pathSpec);
+    }
+}
+AbstractComponent.registerComponent('stroke', Stroke.deserializeFromJSON);

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

@@ -0,0 +1,75 @@
+import SerializableCommand from '../commands/SerializableCommand';
+import LineSegment2 from '../math/LineSegment2';
+import Mat33 from '../math/Mat33';
+import Rect2 from '../math/Rect2';
+import Editor from '../Editor';
+import AbstractRenderer from '../rendering/renderers/AbstractRenderer';
+import { TextRenderingStyle } from '../rendering/TextRenderingStyle';
+import AbstractComponent from './AbstractComponent';
+import { ImageComponentLocalization } from './localization';
+import RestyleableComponent, { ComponentStyle } from './RestylableComponent';
+/**
+ * Displays text.
+ */
+export default class TextComponent extends AbstractComponent implements RestyleableComponent {
+    protected readonly textObjects: Array<string | TextComponent>;
+    private transform;
+    private style;
+    protected contentBBox: Rect2;
+    readonly isRestylableComponent: true;
+    /**
+     * Creates a new text object from a list of component text or child TextComponents.
+     *
+     * @see {@link fromLines}
+     */
+    constructor(textObjects: Array<string | TextComponent>, transform: Mat33, style: TextRenderingStyle);
+    static applyTextStyles(ctx: CanvasRenderingContext2D, style: TextRenderingStyle): void;
+    private static textMeasuringCtx;
+    private static estimateTextDimens;
+    private static getTextDimens;
+    private computeBBoxOfPart;
+    private recomputeBBox;
+    private renderInternal;
+    render(canvas: AbstractRenderer, _visibleRect?: Rect2): void;
+    getProportionalRenderingTime(): number;
+    intersects(lineSegment: LineSegment2): boolean;
+    getStyle(): ComponentStyle;
+    updateStyle(style: ComponentStyle): SerializableCommand;
+    forceStyle(style: ComponentStyle, editor: Editor | null): void;
+    getTextStyle(): {
+        renderingStyle: {
+            fill: import("../Color4").default;
+            stroke: {
+                color: import("../Color4").default;
+                width: number;
+            } | undefined;
+        };
+        size: number;
+        fontFamily: string;
+        fontWeight?: string | undefined;
+        fontVariant?: string | undefined;
+    };
+    getBaselinePos(): import("../lib").Vec3;
+    getTransform(): Mat33;
+    protected applyTransformation(affineTransfm: Mat33): void;
+    protected createClone(): AbstractComponent;
+    getText(): string;
+    description(localizationTable: ImageComponentLocalization): string;
+    protected serializeToJSON(): Record<string, any>;
+    static deserializeFromString(json: any): TextComponent;
+    /**
+     * Creates a `TextComponent` from `lines`.
+     *
+     * @example
+     * ```ts
+     * const textStyle = {
+     *   size: 12,
+     *   fontFamily: 'serif',
+     *   renderingStyle: { fill: Color4.black },
+     * };
+     *
+     * const text = TextComponent.fromLines('foo\nbar'.split('\n'), Mat33.identity, textStyle);
+     * ```
+     */
+    static fromLines(lines: string[], transform: Mat33, style: TextRenderingStyle): AbstractComponent;
+}

package/dist/mjs/src/components/TextComponent.mjs

@@ -0,0 +1,274 @@
+import  LineSegment2  from '../math/LineSegment2.mjs';
+import  Mat33  from '../math/Mat33.mjs';
+import  Rect2  from '../math/Rect2.mjs';
+import  { Vec2 }  from '../math/Vec2.mjs';
+import  { cloneTextStyle, textStyleFromJSON, textStyleToJSON }  from '../rendering/TextRenderingStyle.mjs';
+import  AbstractComponent  from './AbstractComponent.mjs';
+import  { createRestyleComponentCommand }  from './RestylableComponent.mjs';
+const componentTypeId = 'text';
+/**
+ * Displays text.
+ */
+export default class TextComponent extends AbstractComponent {
+    /**
+     * Creates a new text object from a list of component text or child TextComponents.
+     *
+     * @see {@link fromLines}
+     */
+    constructor(textObjects, transform, style) {
+        super(componentTypeId);
+        this.textObjects = textObjects;
+        this.transform = transform;
+        this.style = style;
+        // eslint-disable-next-line @typescript-eslint/prefer-as-const
+        this.isRestylableComponent = true;
+        this.recomputeBBox();
+        // If this has no direct children, choose a style representative of this' content
+        // (useful for estimating the style of the TextComponent).
+        const hasDirectContent = textObjects.some(obj => typeof obj === 'string');
+        if (!hasDirectContent && textObjects.length > 0) {
+            this.style = textObjects[0].getTextStyle();
+        }
+    }
+    static applyTextStyles(ctx, style) {
+        var _a, _b;
+        // Quote the font family if necessary.
+        const fontFamily = style.fontFamily.match(/\s/) ? style.fontFamily.replace(/["]/g, '\\"') : style.fontFamily;
+        ctx.font = [
+            ((_a = style.size) !== null && _a !== void 0 ? _a : 12) + 'px',
+            (_b = style.fontWeight) !== null && _b !== void 0 ? _b : '',
+            `${fontFamily}`,
+            style.fontWeight
+        ].join(' ');
+        ctx.textAlign = 'left';
+    }
+    // Roughly estimate the bounding box of `text`. Use if no CanvasRenderingContext2D is available.
+    static estimateTextDimens(text, style) {
+        const widthEst = text.length * style.size;
+        const heightEst = style.size;
+        // Text is drawn with (0, 0) as its baseline. As such, the majority of the text's height should
+        // be above (0, 0).
+        return new Rect2(0, -heightEst * 2 / 3, widthEst, heightEst);
+    }
+    // Returns the bounding box of `text`. This is approximate if no Canvas is available.
+    static getTextDimens(text, style) {
+        var _a, _b;
+        (_a = TextComponent.textMeasuringCtx) !== null && _a !== void 0 ? _a : (TextComponent.textMeasuringCtx = (_b = document.createElement('canvas').getContext('2d')) !== null && _b !== void 0 ? _b : null);
+        if (!TextComponent.textMeasuringCtx) {
+            return this.estimateTextDimens(text, style);
+        }
+        const ctx = TextComponent.textMeasuringCtx;
+        TextComponent.applyTextStyles(ctx, style);
+        const measure = ctx.measureText(text);
+        // Text is drawn with (0,0) at the bottom left of the baseline.
+        const textY = -measure.actualBoundingBoxAscent;
+        const textHeight = measure.actualBoundingBoxAscent + measure.actualBoundingBoxDescent;
+        return new Rect2(0, textY, measure.width, textHeight);
+    }
+    computeBBoxOfPart(part) {
+        if (typeof part === 'string') {
+            const textBBox = TextComponent.getTextDimens(part, this.style);
+            return textBBox.transformedBoundingBox(this.transform);
+        }
+        else {
+            const bbox = part.contentBBox.transformedBoundingBox(this.transform);
+            return bbox;
+        }
+    }
+    recomputeBBox() {
+        let bbox = null;
+        for (const textObject of this.textObjects) {
+            const currentBBox = this.computeBBoxOfPart(textObject);
+            bbox !== null && bbox !== void 0 ? bbox : (bbox = currentBBox);
+            bbox = bbox.union(currentBBox);
+        }
+        this.contentBBox = bbox !== null && bbox !== void 0 ? bbox : Rect2.empty;
+    }
+    renderInternal(canvas) {
+        const cursor = this.transform;
+        for (const textObject of this.textObjects) {
+            if (typeof textObject === 'string') {
+                canvas.drawText(textObject, cursor, this.style);
+            }
+            else {
+                canvas.pushTransform(cursor);
+                textObject.renderInternal(canvas);
+                canvas.popTransform();
+            }
+        }
+    }
+    render(canvas, _visibleRect) {
+        canvas.startObject(this.contentBBox);
+        this.renderInternal(canvas);
+        canvas.endObject(this.getLoadSaveData());
+    }
+    getProportionalRenderingTime() {
+        return this.textObjects.length;
+    }
+    intersects(lineSegment) {
+        // Convert canvas space to internal space.
+        const invTransform = this.transform.inverse();
+        const p1InThisSpace = invTransform.transformVec2(lineSegment.p1);
+        const p2InThisSpace = invTransform.transformVec2(lineSegment.p2);
+        lineSegment = new LineSegment2(p1InThisSpace, p2InThisSpace);
+        for (const subObject of this.textObjects) {
+            if (typeof subObject === 'string') {
+                const textBBox = TextComponent.getTextDimens(subObject, this.style);
+                // TODO: Use a better intersection check. Perhaps draw the text onto a CanvasElement and
+                // use pixel-testing to check for intersection with its contour.
+                if (textBBox.getEdges().some(edge => lineSegment.intersection(edge) !== null)) {
+                    return true;
+                }
+            }
+            else {
+                if (subObject.intersects(lineSegment)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    getStyle() {
+        return {
+            color: this.style.renderingStyle.fill,
+            // Make a copy
+            textStyle: Object.assign(Object.assign({}, this.style), { renderingStyle: Object.assign({}, this.style.renderingStyle) }),
+        };
+    }
+    updateStyle(style) {
+        return createRestyleComponentCommand(this.getStyle(), style, this);
+    }
+    forceStyle(style, editor) {
+        if (style.textStyle) {
+            this.style = cloneTextStyle(style.textStyle);
+        }
+        else if (style.color) {
+            this.style = Object.assign(Object.assign({}, this.style), { renderingStyle: Object.assign(Object.assign({}, this.style.renderingStyle), { fill: style.color }) });
+        }
+        else {
+            return;
+        }
+        for (const child of this.textObjects) {
+            if (child instanceof TextComponent) {
+                child.forceStyle(style, editor);
+            }
+        }
+        if (editor) {
+            editor.image.queueRerenderOf(this);
+            editor.queueRerender();
+        }
+    }
+    // See this.getStyle
+    getTextStyle() {
+        return cloneTextStyle(this.style);
+    }
+    getBaselinePos() {
+        return this.transform.transformVec2(Vec2.zero);
+    }
+    getTransform() {
+        return this.transform;
+    }
+    applyTransformation(affineTransfm) {
+        this.transform = affineTransfm.rightMul(this.transform);
+        this.recomputeBBox();
+    }
+    createClone() {
+        const clonedTextObjects = this.textObjects.map(obj => {
+            if (typeof obj === 'string') {
+                return obj;
+            }
+            else {
+                return obj.createClone();
+            }
+        });
+        return new TextComponent(clonedTextObjects, this.transform, this.style);
+    }
+    getText() {
+        const result = [];
+        for (const textObject of this.textObjects) {
+            if (typeof textObject === 'string') {
+                result.push(textObject);
+            }
+            else {
+                result.push(textObject.getText());
+            }
+        }
+        return result.join('\n');
+    }
+    description(localizationTable) {
+        return localizationTable.text(this.getText());
+    }
+    // Do not rely on the output of `serializeToJSON` taking any particular format.
+    serializeToJSON() {
+        const serializableStyle = textStyleToJSON(this.style);
+        const serializedTextObjects = this.textObjects.map(text => {
+            if (typeof text === 'string') {
+                return {
+                    text,
+                };
+            }
+            else {
+                return {
+                    json: text.serializeToJSON(),
+                };
+            }
+        });
+        return {
+            textObjects: serializedTextObjects,
+            transform: this.transform.toArray(),
+            style: serializableStyle,
+        };
+    }
+    // @internal
+    static deserializeFromString(json) {
+        if (typeof json === 'string') {
+            json = JSON.parse(json);
+        }
+        const style = textStyleFromJSON(json.style);
+        const textObjects = json.textObjects.map((data) => {
+            var _a;
+            if (((_a = data.text) !== null && _a !== void 0 ? _a : null) !== null) {
+                return data.text;
+            }
+            return TextComponent.deserializeFromString(data.json);
+        });
+        json.transform = json.transform.filter((elem) => typeof elem === 'number');
+        if (json.transform.length !== 9) {
+            throw new Error(`Unable to deserialize transform, ${json.transform}.`);
+        }
+        const transformData = json.transform;
+        const transform = new Mat33(...transformData);
+        return new TextComponent(textObjects, transform, style);
+    }
+    /**
+     * Creates a `TextComponent` from `lines`.
+     *
+     * @example
+     * ```ts
+     * const textStyle = {
+     *   size: 12,
+     *   fontFamily: 'serif',
+     *   renderingStyle: { fill: Color4.black },
+     * };
+     *
+     * const text = TextComponent.fromLines('foo\nbar'.split('\n'), Mat33.identity, textStyle);
+     * ```
+     */
+    static fromLines(lines, transform, style) {
+        let lastComponent = null;
+        const components = [];
+        for (const line of lines) {
+            let position = Vec2.zero;
+            if (lastComponent) {
+                const lineMargin = Math.floor(style.size);
+                position = lastComponent.getBBox().bottomLeft.plus(Vec2.unitY.times(lineMargin));
+            }
+            const component = new TextComponent([line], Mat33.translation(position), style);
+            components.push(component);
+            lastComponent = component;
+        }
+        return new TextComponent(components, transform, style);
+    }
+}
+TextComponent.textMeasuringCtx = null;
+AbstractComponent.registerComponent(componentTypeId, (data) => TextComponent.deserializeFromString(data));

package/dist/mjs/src/components/UnknownSVGObject.d.ts

@@ -0,0 +1,18 @@
+import LineSegment2 from '../math/LineSegment2';
+import Mat33 from '../math/Mat33';
+import Rect2 from '../math/Rect2';
+import AbstractRenderer from '../rendering/renderers/AbstractRenderer';
+import AbstractComponent from './AbstractComponent';
+import { ImageComponentLocalization } from './localization';
+export default class UnknownSVGObject extends AbstractComponent {
+    private svgObject;
+    protected contentBBox: Rect2;
+    constructor(svgObject: SVGElement);
+    render(canvas: AbstractRenderer, _visibleRect?: Rect2): void;
+    intersects(lineSegment: LineSegment2): boolean;
+    protected applyTransformation(_affineTransfm: Mat33): void;
+    isSelectable(): boolean;
+    protected createClone(): AbstractComponent;
+    description(localization: ImageComponentLocalization): string;
+    protected serializeToJSON(): string | null;
+}

package/dist/mjs/src/components/UnknownSVGObject.mjs

@@ -0,0 +1,44 @@
+//
+// Stores objects loaded from an SVG that aren't recognised by the editor.
+// @internal
+// @packageDocumentation
+//
+import  Rect2  from '../math/Rect2.mjs';
+import  SVGRenderer  from '../rendering/renderers/SVGRenderer.mjs';
+import  AbstractComponent  from './AbstractComponent.mjs';
+const componentId = 'unknown-svg-object';
+export default class UnknownSVGObject extends AbstractComponent {
+    constructor(svgObject) {
+        super(componentId);
+        this.svgObject = svgObject;
+        this.contentBBox = Rect2.of(svgObject.getBoundingClientRect());
+    }
+    render(canvas, _visibleRect) {
+        if (!(canvas instanceof SVGRenderer)) {
+            // Don't draw unrenderable objects if we can't
+            return;
+        }
+        canvas.drawSVGElem(this.svgObject);
+    }
+    intersects(lineSegment) {
+        return this.contentBBox.getEdges().some(edge => edge.intersection(lineSegment) !== null);
+    }
+    applyTransformation(_affineTransfm) {
+    }
+    isSelectable() {
+        return false;
+    }
+    createClone() {
+        return new UnknownSVGObject(this.svgObject.cloneNode(true));
+    }
+    description(localization) {
+        return localization.svgObject;
+    }
+    serializeToJSON() {
+        return JSON.stringify({
+            html: this.svgObject.outerHTML,
+        });
+    }
+}
+// null: Do not deserialize UnknownSVGObjects.
+AbstractComponent.registerComponent(componentId, null);

package/dist/mjs/src/components/builders/ArrowBuilder.d.ts

@@ -0,0 +1,19 @@
+import Rect2 from '../../math/Rect2';
+import AbstractRenderer from '../../rendering/renderers/AbstractRenderer';
+import { StrokeDataPoint } from '../../types';
+import Viewport from '../../Viewport';
+import AbstractComponent from '../AbstractComponent';
+import { ComponentBuilder, ComponentBuilderFactory } from './types';
+export declare const makeArrowBuilder: ComponentBuilderFactory;
+export default class ArrowBuilder implements ComponentBuilder {
+    private readonly startPoint;
+    private readonly viewport;
+    private endPoint;
+    constructor(startPoint: StrokeDataPoint, viewport: Viewport);
+    private getLineWidth;
+    getBBox(): Rect2;
+    private buildPreview;
+    build(): AbstractComponent;
+    preview(renderer: AbstractRenderer): void;
+    addPoint(point: StrokeDataPoint): void;
+}