js-draw 0.23.1 → 0.24.0

package/dist/cjs/rendering/renderers/AbstractRenderer.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var Path_1 = require("../../math/shapes/Path");
+var Vec2_1 = require("../../math/Vec2");
+var RenderingStyle_1 = require("../RenderingStyle");
+/**
+ * Abstract base class for renderers.
+ *
+ * @see {@link EditorImage.render}
+ */
+var AbstractRenderer = /** @class */ (function () {
+    function AbstractRenderer(viewport) {
+        this.viewport = viewport;
+        // If null, this' transformation is linked to the Viewport
+        this.selfTransform = null;
+        this.transformStack = [];
+        this.objectLevel = 0;
+        this.currentPaths = null;
+    }
+    // this.canvasToScreen, etc. should be used instead of the corresponding
+    // methods on Viewport.
+    AbstractRenderer.prototype.getViewport = function () { return this.viewport; };
+    AbstractRenderer.prototype.setDraftMode = function (_draftMode) { };
+    AbstractRenderer.prototype.flushPath = function () {
+        if (!this.currentPaths) {
+            return;
+        }
+        var lastStyle = null;
+        for (var _i = 0, _a = this.currentPaths; _i < _a.length; _i++) {
+            var path = _a[_i];
+            var startPoint = path.startPoint, commands = path.commands, style = path.style;
+            if (!lastStyle || !(0, RenderingStyle_1.stylesEqual)(lastStyle, style)) {
+                if (lastStyle) {
+                    this.endPath(lastStyle);
+                }
+                this.beginPath(startPoint);
+                lastStyle = style;
+            }
+            else {
+                this.moveTo(startPoint);
+            }
+            for (var _b = 0, commands_1 = commands; _b < commands_1.length; _b++) {
+                var command = commands_1[_b];
+                if (command.kind === Path_1.PathCommandType.LineTo) {
+                    this.lineTo(command.point);
+                }
+                else if (command.kind === Path_1.PathCommandType.MoveTo) {
+                    this.moveTo(command.point);
+                }
+                else if (command.kind === Path_1.PathCommandType.CubicBezierTo) {
+                    this.traceCubicBezierCurve(command.controlPoint1, command.controlPoint2, command.endPoint);
+                }
+                else if (command.kind === Path_1.PathCommandType.QuadraticBezierTo) {
+                    this.traceQuadraticBezierCurve(command.controlPoint, command.endPoint);
+                }
+            }
+        }
+        if (lastStyle) {
+            this.endPath(lastStyle);
+        }
+        this.currentPaths = [];
+    };
+    /**
+     * Draws a styled path. If within an object started by {@link startObject},
+     * the resultant path may not be visible until {@link endObject} is called.
+     */
+    AbstractRenderer.prototype.drawPath = function (path) {
+        // If we're being called outside of an object,
+        // we can't delay rendering
+        if (this.objectLevel === 0) {
+            this.currentPaths = [path];
+            this.flushPath();
+            this.currentPaths = null;
+        }
+        else {
+            // Otherwise, don't render paths all at once. This prevents faint lines between
+            // segments of the same stroke from being visible.
+            this.currentPaths.push(path);
+        }
+    };
+    // Strokes a rectangle. Boundary lines have width [lineWidth] and are filled with [lineFill].
+    // This is equivalent to `drawPath(Path.fromRect(...).toRenderable(...))`.
+    AbstractRenderer.prototype.drawRect = function (rect, lineWidth, lineFill) {
+        var path = Path_1.default.fromRect(rect, lineWidth);
+        this.drawPath(path.toRenderable(lineFill));
+    };
+    /** Draws a filled rectangle. */
+    AbstractRenderer.prototype.fillRect = function (rect, fill) {
+        var path = Path_1.default.fromRect(rect);
+        this.drawPath(path.toRenderable({ fill: fill }));
+    };
+    /**
+     * This should be called whenever a new object is being drawn.
+     *
+     * @param _boundingBox The bounding box of the object to be drawn.
+     * @param _clip Whether content outside `_boundingBox` should be drawn. Renderers
+     *              that override this method are not required to support `_clip`.
+     */
+    AbstractRenderer.prototype.startObject = function (_boundingBox, _clip) {
+        if (this.objectLevel > 0) {
+            this.flushPath();
+        }
+        this.currentPaths = [];
+        this.objectLevel++;
+    };
+    /**
+     * Notes the end of an object.
+     * @param _loaderData - a map from strings to JSON-ifyable objects
+     * and contains properties attached to the object by whatever loader loaded the image. This
+     * is used to preserve attributes not supported by js-draw when loading/saving an image.
+     * Renderers may ignore this.
+     *
+     * @param _objectTags - a list of labels (e.g. `className`s) to be attached to the object.
+     * Renderers may ignore this.
+     */
+    AbstractRenderer.prototype.endObject = function (_loaderData, _objectTags) {
+        // Render the paths all at once
+        this.flushPath();
+        this.currentPaths = null;
+        this.objectLevel--;
+        if (this.objectLevel < 0) {
+            throw new Error('More objects have ended than have been started (negative object nesting level)!');
+        }
+    };
+    AbstractRenderer.prototype.getNestingLevel = function () {
+        return this.objectLevel;
+    };
+    // Returns true iff other can be rendered onto this without data loss.
+    AbstractRenderer.prototype.canRenderFromWithoutDataLoss = function (_other) {
+        return false;
+    };
+    // MUST throw if other and this are not of the same base class.
+    AbstractRenderer.prototype.renderFromOtherOfSameType = function (_renderTo, other) {
+        throw new Error("Unable to render from ".concat(other, ": Not implemented"));
+    };
+    // Set a transformation to apply to things before rendering,
+    // replacing the viewport's transform.
+    AbstractRenderer.prototype.setTransform = function (transform) {
+        this.selfTransform = transform;
+    };
+    AbstractRenderer.prototype.pushTransform = function (transform) {
+        this.transformStack.push(this.selfTransform);
+        this.setTransform(this.getCanvasToScreenTransform().rightMul(transform));
+    };
+    AbstractRenderer.prototype.popTransform = function () {
+        var _a;
+        if (this.transformStack.length === 0) {
+            throw new Error('Unable to pop more transforms than have been pushed!');
+        }
+        this.setTransform((_a = this.transformStack.pop()) !== null && _a !== void 0 ? _a : null);
+    };
+    // Get the matrix that transforms a vector on the canvas to a vector on this'
+    // rendering target.
+    AbstractRenderer.prototype.getCanvasToScreenTransform = function () {
+        if (this.selfTransform) {
+            return this.selfTransform;
+        }
+        return this.viewport.canvasToScreenTransform;
+    };
+    AbstractRenderer.prototype.canvasToScreen = function (vec) {
+        return this.getCanvasToScreenTransform().transformVec2(vec);
+    };
+    AbstractRenderer.prototype.getSizeOfCanvasPixelOnScreen = function () {
+        return this.getCanvasToScreenTransform().transformVec3(Vec2_1.Vec2.unitX).length();
+    };
+    return AbstractRenderer;
+}());
+exports.default = AbstractRenderer;

package/dist/cjs/rendering/renderers/CanvasRenderer.d.ts

@@ -0,0 +1,63 @@
+import Mat33 from '../../math/Mat33';
+import Rect2 from '../../math/shapes/Rect2';
+import { Point2, Vec2 } from '../../math/Vec2';
+import Vec3 from '../../math/Vec3';
+import Viewport from '../../Viewport';
+import RenderingStyle from '../RenderingStyle';
+import TextRenderingStyle from '../TextRenderingStyle';
+import AbstractRenderer, { RenderableImage, RenderablePathSpec } from './AbstractRenderer';
+/**
+ * Renders onto a `CanvasRenderingContext2D`.
+ *
+ * @example
+ * ```ts
+ * const editor = new Editor(document.body);
+ *
+ * const canvas = document.createElement('canvas');
+ * const ctx = canvas.getContext('2d');
+ *
+ * // Ensure that the canvas can fit the entire rendering
+ * const viewport = editor.image.getImportExportViewport();
+ * canvas.width = viewport.getScreenRectSize().x;
+ * canvas.height = viewport.getScreenRectSize().y;
+ *
+ * // Render editor.image onto the renderer
+ * const renderer = new CanvasRenderer(ctx, viewport);
+ * editor.image.render(renderer, viewport);
+ * ```
+ */
+export default class CanvasRenderer extends AbstractRenderer {
+    private ctx;
+    private ignoreObjectsAboveLevel;
+    private ignoringObject;
+    private currentObjectBBox;
+    private minSquareCurveApproxDist;
+    private minRenderSizeAnyDimen;
+    private minRenderSizeBothDimens;
+    /**
+     * Creates a new `CanvasRenderer` that renders to the given rendering context.
+     * The `viewport` is used to determine the translation/rotation/scaling of the content
+     * to draw.
+     */
+    constructor(ctx: CanvasRenderingContext2D, viewport: Viewport);
+    private transformBy;
+    canRenderFromWithoutDataLoss(other: AbstractRenderer): boolean;
+    renderFromOtherOfSameType(transformBy: Mat33, other: AbstractRenderer): void;
+    setDraftMode(draftMode: boolean): void;
+    displaySize(): Vec2;
+    clear(): void;
+    protected beginPath(startPoint: Point2): void;
+    protected endPath(style: RenderingStyle): void;
+    protected lineTo(point: Point2): void;
+    protected moveTo(point: Point2): void;
+    protected traceCubicBezierCurve(p1: Point2, p2: Point2, p3: Point2): void;
+    protected traceQuadraticBezierCurve(controlPoint: Vec3, endPoint: Vec3): void;
+    drawPath(path: RenderablePathSpec): void;
+    drawText(text: string, transform: Mat33, style: TextRenderingStyle): void;
+    drawImage(image: RenderableImage): void;
+    private clipLevels;
+    startObject(boundingBox: Rect2, clip?: boolean): void;
+    endObject(): void;
+    drawPoints(...points: Point2[]): void;
+    isTooSmallToRender(rect: Rect2): boolean;
+}

package/dist/cjs/rendering/renderers/CanvasRenderer.js

@@ -0,0 +1,263 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var Color4_1 = require("../../Color4");
+var TextComponent_1 = require("../../components/TextComponent");
+var Path_1 = require("../../math/shapes/Path");
+var Vec2_1 = require("../../math/Vec2");
+var AbstractRenderer_1 = require("./AbstractRenderer");
+/**
+ * Renders onto a `CanvasRenderingContext2D`.
+ *
+ * @example
+ * ```ts
+ * const editor = new Editor(document.body);
+ *
+ * const canvas = document.createElement('canvas');
+ * const ctx = canvas.getContext('2d');
+ *
+ * // Ensure that the canvas can fit the entire rendering
+ * const viewport = editor.image.getImportExportViewport();
+ * canvas.width = viewport.getScreenRectSize().x;
+ * canvas.height = viewport.getScreenRectSize().y;
+ *
+ * // Render editor.image onto the renderer
+ * const renderer = new CanvasRenderer(ctx, viewport);
+ * editor.image.render(renderer, viewport);
+ * ```
+ */
+var CanvasRenderer = /** @class */ (function (_super) {
+    __extends(CanvasRenderer, _super);
+    /**
+     * Creates a new `CanvasRenderer` that renders to the given rendering context.
+     * The `viewport` is used to determine the translation/rotation/scaling of the content
+     * to draw.
+     */
+    function CanvasRenderer(ctx, viewport) {
+        var _this = _super.call(this, viewport) || this;
+        _this.ctx = ctx;
+        _this.ignoreObjectsAboveLevel = null;
+        _this.ignoringObject = false;
+        _this.currentObjectBBox = null;
+        _this.clipLevels = [];
+        _this.setDraftMode(false);
+        return _this;
+    }
+    CanvasRenderer.prototype.transformBy = function (transformBy) {
+        // From MDN, transform(a,b,c,d,e,f)
+        // takes input such that
+        // ⎡ a c e ⎤
+        // ⎢ b d f ⎥ transforms content drawn to [ctx].
+        // ⎣ 0 0 1 ⎦
+        this.ctx.transform(transformBy.a1, transformBy.b1, // a, b
+        transformBy.a2, transformBy.b2, // c, d
+        transformBy.a3, transformBy.b3);
+    };
+    CanvasRenderer.prototype.canRenderFromWithoutDataLoss = function (other) {
+        return other instanceof CanvasRenderer;
+    };
+    CanvasRenderer.prototype.renderFromOtherOfSameType = function (transformBy, other) {
+        if (!(other instanceof CanvasRenderer)) {
+            throw new Error("".concat(other, " cannot be rendered onto ").concat(this));
+        }
+        transformBy = this.getCanvasToScreenTransform().rightMul(transformBy);
+        this.ctx.save();
+        this.transformBy(transformBy);
+        this.ctx.drawImage(other.ctx.canvas, 0, 0);
+        this.ctx.restore();
+    };
+    // Set parameters for lower/higher quality rendering
+    CanvasRenderer.prototype.setDraftMode = function (draftMode) {
+        if (draftMode) {
+            this.minSquareCurveApproxDist = 9;
+            this.minRenderSizeBothDimens = 2;
+            this.minRenderSizeAnyDimen = 0.5;
+        }
+        else {
+            this.minSquareCurveApproxDist = 0.5;
+            this.minRenderSizeBothDimens = 0.2;
+            this.minRenderSizeAnyDimen = 1e-6;
+        }
+    };
+    CanvasRenderer.prototype.displaySize = function () {
+        return Vec2_1.Vec2.of(this.ctx.canvas.clientWidth, this.ctx.canvas.clientHeight);
+    };
+    CanvasRenderer.prototype.clear = function () {
+        this.ctx.clearRect(0, 0, this.ctx.canvas.width, this.ctx.canvas.height);
+    };
+    CanvasRenderer.prototype.beginPath = function (startPoint) {
+        startPoint = this.canvasToScreen(startPoint);
+        this.ctx.beginPath();
+        this.ctx.moveTo(startPoint.x, startPoint.y);
+    };
+    CanvasRenderer.prototype.endPath = function (style) {
+        this.ctx.fillStyle = style.fill.toHexString();
+        this.ctx.fill();
+        if (style.stroke) {
+            this.ctx.strokeStyle = style.stroke.color.toHexString();
+            this.ctx.lineWidth = this.getSizeOfCanvasPixelOnScreen() * style.stroke.width;
+            this.ctx.lineCap = 'round';
+            this.ctx.lineJoin = 'round';
+            this.ctx.stroke();
+        }
+        this.ctx.closePath();
+    };
+    CanvasRenderer.prototype.lineTo = function (point) {
+        point = this.canvasToScreen(point);
+        this.ctx.lineTo(point.x, point.y);
+    };
+    CanvasRenderer.prototype.moveTo = function (point) {
+        point = this.canvasToScreen(point);
+        this.ctx.moveTo(point.x, point.y);
+    };
+    CanvasRenderer.prototype.traceCubicBezierCurve = function (p1, p2, p3) {
+        p1 = this.canvasToScreen(p1);
+        p2 = this.canvasToScreen(p2);
+        p3 = this.canvasToScreen(p3);
+        // Approximate the curve if small enough.
+        var delta1 = p2.minus(p1);
+        var delta2 = p3.minus(p2);
+        if (delta1.magnitudeSquared() < this.minSquareCurveApproxDist
+            && delta2.magnitudeSquared() < this.minSquareCurveApproxDist) {
+            this.ctx.lineTo(p3.x, p3.y);
+        }
+        else {
+            this.ctx.bezierCurveTo(p1.x, p1.y, p2.x, p2.y, p3.x, p3.y);
+        }
+    };
+    CanvasRenderer.prototype.traceQuadraticBezierCurve = function (controlPoint, endPoint) {
+        controlPoint = this.canvasToScreen(controlPoint);
+        endPoint = this.canvasToScreen(endPoint);
+        // Approximate the curve with a line if small enough
+        var delta = controlPoint.minus(endPoint);
+        if (delta.magnitudeSquared() < this.minSquareCurveApproxDist) {
+            this.ctx.lineTo(endPoint.x, endPoint.y);
+        }
+        else {
+            this.ctx.quadraticCurveTo(controlPoint.x, controlPoint.y, endPoint.x, endPoint.y);
+        }
+    };
+    CanvasRenderer.prototype.drawPath = function (path) {
+        var _a;
+        if (this.ignoringObject) {
+            return;
+        }
+        // If part of a huge object, it might be worth trimming the path
+        if ((_a = this.currentObjectBBox) === null || _a === void 0 ? void 0 : _a.containsRect(this.getViewport().visibleRect)) {
+            // Try to trim/remove parts of the path outside of the bounding box.
+            path = Path_1.default.visualEquivalent(path, this.getViewport().visibleRect);
+        }
+        _super.prototype.drawPath.call(this, path);
+    };
+    CanvasRenderer.prototype.drawText = function (text, transform, style) {
+        this.ctx.save();
+        transform = this.getCanvasToScreenTransform().rightMul(transform);
+        this.transformBy(transform);
+        TextComponent_1.default.applyTextStyles(this.ctx, style);
+        if (style.renderingStyle.fill.a !== 0) {
+            this.ctx.fillStyle = style.renderingStyle.fill.toHexString();
+            this.ctx.fillText(text, 0, 0);
+        }
+        if (style.renderingStyle.stroke) {
+            this.ctx.strokeStyle = style.renderingStyle.stroke.color.toHexString();
+            this.ctx.lineWidth = style.renderingStyle.stroke.width;
+            this.ctx.strokeText(text, 0, 0);
+        }
+        this.ctx.restore();
+    };
+    CanvasRenderer.prototype.drawImage = function (image) {
+        this.ctx.save();
+        var transform = this.getCanvasToScreenTransform().rightMul(image.transform);
+        this.transformBy(transform);
+        this.ctx.drawImage(image.image, 0, 0);
+        this.ctx.restore();
+    };
+    CanvasRenderer.prototype.startObject = function (boundingBox, clip) {
+        if (this.isTooSmallToRender(boundingBox)) {
+            this.ignoreObjectsAboveLevel = this.getNestingLevel();
+            this.ignoringObject = true;
+        }
+        _super.prototype.startObject.call(this, boundingBox);
+        this.currentObjectBBox = boundingBox;
+        if (!this.ignoringObject && clip) {
+            // Don't clip if it would only remove content already trimmed by
+            // the edge of the screen.
+            var clippedIsOutsideScreen = boundingBox.containsRect(this.getViewport().visibleRect);
+            if (!clippedIsOutsideScreen) {
+                this.clipLevels.push(this.objectLevel);
+                this.ctx.save();
+                this.ctx.beginPath();
+                for (var _i = 0, _a = boundingBox.corners; _i < _a.length; _i++) {
+                    var corner = _a[_i];
+                    var screenCorner = this.canvasToScreen(corner);
+                    this.ctx.lineTo(screenCorner.x, screenCorner.y);
+                }
+                this.ctx.clip();
+            }
+        }
+    };
+    CanvasRenderer.prototype.endObject = function () {
+        // Cache this.objectLevel — it may be decremented by super.endObject.
+        var objectLevel = this.objectLevel;
+        this.currentObjectBBox = null;
+        _super.prototype.endObject.call(this);
+        if (!this.ignoringObject && this.clipLevels.length > 0) {
+            if (this.clipLevels[this.clipLevels.length - 1] === objectLevel) {
+                this.ctx.restore();
+                this.clipLevels.pop();
+            }
+        }
+        // If exiting an object with a too-small-to-draw bounding box,
+        if (this.ignoreObjectsAboveLevel !== null && this.getNestingLevel() <= this.ignoreObjectsAboveLevel) {
+            this.ignoreObjectsAboveLevel = null;
+            this.ignoringObject = false;
+        }
+    };
+    // @internal
+    CanvasRenderer.prototype.drawPoints = function () {
+        var points = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            points[_i] = arguments[_i];
+        }
+        var pointRadius = 10;
+        for (var i = 0; i < points.length; i++) {
+            var point = this.canvasToScreen(points[i]);
+            this.ctx.beginPath();
+            this.ctx.arc(point.x, point.y, pointRadius, 0, Math.PI * 2);
+            this.ctx.fillStyle = Color4_1.default.ofRGBA(0.5 + Math.sin(i) / 2, 1.0, 0.5 + Math.cos(i * 0.2) / 4, 0.5).toHexString();
+            this.ctx.fill();
+            this.ctx.stroke();
+            this.ctx.closePath();
+            this.ctx.textAlign = 'center';
+            this.ctx.textBaseline = 'middle';
+            this.ctx.fillStyle = 'black';
+            this.ctx.fillText("".concat(i), point.x, point.y, pointRadius * 2);
+        }
+    };
+    // @internal
+    CanvasRenderer.prototype.isTooSmallToRender = function (rect) {
+        // Should we ignore all objects within this object's bbox?
+        var diagonal = this.getCanvasToScreenTransform().transformVec3(rect.size);
+        var bothDimenMinSize = this.minRenderSizeBothDimens;
+        var bothTooSmall = Math.abs(diagonal.x) < bothDimenMinSize && Math.abs(diagonal.y) < bothDimenMinSize;
+        var anyDimenMinSize = this.minRenderSizeAnyDimen;
+        var anyTooSmall = Math.abs(diagonal.x) < anyDimenMinSize || Math.abs(diagonal.y) < anyDimenMinSize;
+        return bothTooSmall || anyTooSmall;
+    };
+    return CanvasRenderer;
+}(AbstractRenderer_1.default));
+exports.default = CanvasRenderer;

package/dist/cjs/rendering/renderers/DummyRenderer.d.ts

@@ -0,0 +1,35 @@
+import Mat33 from '../../math/Mat33';
+import Rect2 from '../../math/shapes/Rect2';
+import { Point2, Vec2 } from '../../math/Vec2';
+import Vec3 from '../../math/Vec3';
+import Viewport from '../../Viewport';
+import RenderingStyle from '../RenderingStyle';
+import TextRenderingStyle from '../TextRenderingStyle';
+import AbstractRenderer, { RenderableImage } from './AbstractRenderer';
+export default class DummyRenderer extends AbstractRenderer {
+    clearedCount: number;
+    renderedPathCount: number;
+    lastFillStyle: RenderingStyle | null;
+    lastPoint: Point2 | null;
+    objectNestingLevel: number;
+    lastText: string | null;
+    lastImage: RenderableImage | null;
+    pointBuffer: Point2[];
+    constructor(viewport: Viewport);
+    displaySize(): Vec2;
+    clear(): void;
+    protected beginPath(startPoint: Vec3): void;
+    protected endPath(style: RenderingStyle): void;
+    protected lineTo(point: Vec3): void;
+    protected moveTo(point: Point2): void;
+    protected traceCubicBezierCurve(p1: Vec3, p2: Vec3, p3: Vec3): void;
+    protected traceQuadraticBezierCurve(controlPoint: Vec3, endPoint: Vec3): void;
+    drawPoints(..._points: Vec3[]): void;
+    drawText(text: string, _transform: Mat33, _style: TextRenderingStyle): void;
+    drawImage(image: RenderableImage): void;
+    startObject(boundingBox: Rect2, _clip: boolean): void;
+    endObject(): void;
+    isTooSmallToRender(_rect: Rect2): boolean;
+    canRenderFromWithoutDataLoss(other: AbstractRenderer): boolean;
+    renderFromOtherOfSameType(transform: Mat33, other: AbstractRenderer): void;
+}

package/dist/cjs/rendering/renderers/DummyRenderer.js

@@ -0,0 +1,132 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var Vec2_1 = require("../../math/Vec2");
+var AbstractRenderer_1 = require("./AbstractRenderer");
+// Renderer that outputs almost nothing. Useful for automated tests.
+var DummyRenderer = /** @class */ (function (_super) {
+    __extends(DummyRenderer, _super);
+    function DummyRenderer(viewport) {
+        var _this = _super.call(this, viewport) || this;
+        // Variables that track the state of what's been rendered
+        _this.clearedCount = 0;
+        _this.renderedPathCount = 0;
+        _this.lastFillStyle = null;
+        _this.lastPoint = null;
+        _this.objectNestingLevel = 0;
+        _this.lastText = null;
+        _this.lastImage = null;
+        // List of points drawn since the last clear.
+        _this.pointBuffer = [];
+        return _this;
+    }
+    DummyRenderer.prototype.displaySize = function () {
+        // Do we have a stored viewport size?
+        var viewportSize = this.getViewport().getScreenRectSize();
+        // Don't use a 0x0 viewport — DummyRenderer is often used
+        // for tests that run without a display, so pretend we have a
+        // reasonable-sized display.
+        if (viewportSize.x === 0 || viewportSize.y === 0) {
+            return Vec2_1.Vec2.of(640, 480);
+        }
+        return viewportSize;
+    };
+    DummyRenderer.prototype.clear = function () {
+        this.clearedCount++;
+        this.renderedPathCount = 0;
+        this.pointBuffer = [];
+        this.lastText = null;
+        this.lastImage = null;
+        // Ensure all objects finished rendering
+        if (this.objectNestingLevel > 0) {
+            throw new Error("Within an object while clearing! Nesting level: ".concat(this.objectNestingLevel));
+        }
+    };
+    DummyRenderer.prototype.beginPath = function (startPoint) {
+        this.lastPoint = startPoint;
+        this.pointBuffer.push(startPoint);
+    };
+    DummyRenderer.prototype.endPath = function (style) {
+        this.renderedPathCount++;
+        this.lastFillStyle = style;
+    };
+    DummyRenderer.prototype.lineTo = function (point) {
+        point = this.canvasToScreen(point);
+        this.lastPoint = point;
+        this.pointBuffer.push(point);
+    };
+    DummyRenderer.prototype.moveTo = function (point) {
+        point = this.canvasToScreen(point);
+        this.lastPoint = point;
+        this.pointBuffer.push(point);
+    };
+    DummyRenderer.prototype.traceCubicBezierCurve = function (p1, p2, p3) {
+        p1 = this.canvasToScreen(p1);
+        p2 = this.canvasToScreen(p2);
+        p3 = this.canvasToScreen(p3);
+        this.lastPoint = p3;
+        this.pointBuffer.push(p1, p2, p3);
+    };
+    DummyRenderer.prototype.traceQuadraticBezierCurve = function (controlPoint, endPoint) {
+        controlPoint = this.canvasToScreen(controlPoint);
+        endPoint = this.canvasToScreen(endPoint);
+        this.lastPoint = endPoint;
+        this.pointBuffer.push(controlPoint, endPoint);
+    };
+    DummyRenderer.prototype.drawPoints = function () {
+        var _points = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            _points[_i] = arguments[_i];
+        }
+        // drawPoints is intended for debugging.
+        // As such, it is unlikely to be the target of automated tests.
+    };
+    DummyRenderer.prototype.drawText = function (text, _transform, _style) {
+        this.lastText = text;
+    };
+    DummyRenderer.prototype.drawImage = function (image) {
+        this.lastImage = image;
+    };
+    DummyRenderer.prototype.startObject = function (boundingBox, _clip) {
+        _super.prototype.startObject.call(this, boundingBox);
+        this.objectNestingLevel += 1;
+    };
+    DummyRenderer.prototype.endObject = function () {
+        _super.prototype.endObject.call(this);
+        this.objectNestingLevel -= 1;
+    };
+    DummyRenderer.prototype.isTooSmallToRender = function (_rect) {
+        return false;
+    };
+    DummyRenderer.prototype.canRenderFromWithoutDataLoss = function (other) {
+        return other instanceof DummyRenderer;
+    };
+    DummyRenderer.prototype.renderFromOtherOfSameType = function (transform, other) {
+        var _a;
+        if (!(other instanceof DummyRenderer)) {
+            throw new Error("".concat(other, " cannot be rendered onto ").concat(this));
+        }
+        this.renderedPathCount += other.renderedPathCount;
+        this.lastFillStyle = other.lastFillStyle;
+        this.lastPoint = other.lastPoint;
+        (_a = this.pointBuffer).push.apply(_a, other.pointBuffer.map(function (point) {
+            return transform.transformVec2(point);
+        }));
+    };
+    return DummyRenderer;
+}(AbstractRenderer_1.default));
+exports.default = DummyRenderer;

package/dist/cjs/rendering/renderers/DummyRenderer.test.d.ts

@@ -0,0 +1 @@
+export {};