js-draw 0.25.1 → 1.0.1

package/dist/mjs/EventDispatcher.mjs

@@ -15,42 +15,39 @@
  * ```
  *
  */
-var EventDispatcher = /** @class */ (function () {
-    function EventDispatcher() {
+export default class EventDispatcher {
+    constructor() {
         this.listeners = {};
     }
-    EventDispatcher.prototype.dispatch = function (eventName, event) {
-        var listenerList = this.listeners[eventName];
+    dispatch(eventName, event) {
+        const listenerList = this.listeners[eventName];
         if (listenerList) {
-            for (var i = 0; i < listenerList.length; i++) {
+            for (let i = 0; i < listenerList.length; i++) {
                 listenerList[i](event);
             }
         }
-    };
-    EventDispatcher.prototype.on = function (eventName, callback) {
-        var _this = this;
+    }
+    on(eventName, callback) {
         if (!this.listeners[eventName])
             this.listeners[eventName] = [];
         this.listeners[eventName].push(callback);
         return {
             // Retuns false if the listener has already been removed, true otherwise.
-            remove: function () {
-                var originalListeners = _this.listeners[eventName];
-                _this.off(eventName, callback);
-                return originalListeners.length !== _this.listeners[eventName].length;
+            remove: () => {
+                const originalListeners = this.listeners[eventName];
+                this.off(eventName, callback);
+                return originalListeners.length !== this.listeners[eventName].length;
             },
         };
-    };
+    }
     /** Removes an event listener. This is equivalent to calling `.remove()` on the object returned by `.on`. */
-    EventDispatcher.prototype.off = function (eventName, callback) {
-        var listeners = this.listeners[eventName];
+    off(eventName, callback) {
+        const listeners = this.listeners[eventName];
         if (!listeners)
             return;
         // Replace the current list of listeners with a new, shortened list.
         // This allows any iterators over this.listeners to continue iterating
         // without skipping elements.
-        this.listeners[eventName] = listeners.filter(function (otherCallback) { return otherCallback !== callback; });
-    };
-    return EventDispatcher;
-}());
-export default EventDispatcher;
+        this.listeners[eventName] = listeners.filter(otherCallback => otherCallback !== callback);
+    }
+}

package/dist/mjs/Pointer.d.ts

@@ -1,4 +1,4 @@
-import { Point2, Vec2 } from './math/Vec2';
+import { Point2, Vec2 } from '@js-draw/math';
 import Viewport from './Viewport';
 export declare enum PointerDevice {
     Pen = 0,
@@ -27,6 +27,8 @@ export default class Pointer {
     lockedToXYAxesScreen(originPointScreen: Vec2, viewport: Viewport): Pointer;
     /** @see {@link withCanvasPosition} */
     withScreenPosition(screenPos: Point2, viewport: Viewport): Pointer;
+    /** Returns a copy of this pointer with a changed timestamp. */
+    withTimestamp(timeStamp: number): Pointer;
     /**
      * Returns a copy of this pointer with a new position. The screen position is determined
      * by the given `canvasPos`.

package/dist/mjs/Pointer.mjs

@@ -1,4 +1,4 @@
-import  { Vec2 }  from './math/Vec2.mjs';
+import { Vec2 } from '@js-draw/math';
 export var PointerDevice;
 (function (PointerDevice) {
     PointerDevice[PointerDevice["Pen"] = 0] = "Pen";
@@ -10,8 +10,8 @@ export var PointerDevice;
 })(PointerDevice || (PointerDevice = {}));
 // Provides a snapshot containing information about a pointer. A Pointer
 // object is immutable — it will not be updated when the pointer's information changes.
-var Pointer = /** @class */ (function () {
-    function Pointer(
+export default class Pointer {
+    constructor(
     // The (x, y) position of the pointer relative to the top-left corner
     // of the visible canvas.
     screenPos, 
@@ -20,7 +20,7 @@ var Pointer = /** @class */ (function () {
     canvasPos, pressure, isPrimary, down, device, 
     // Unique ID for the pointer
     id, 
-    // Numeric timestamp (milliseconds, as from `(new Date).getTime()`)
+    // Numeric timestamp (milliseconds, as from `performance.now()`).
     timeStamp) {
         this.screenPos = screenPos;
         this.canvasPos = canvasPos;
@@ -36,21 +36,21 @@ var Pointer = /** @class */ (function () {
      * pointer based on the current zoom). Returns a new Pointer and does not modify
      * this.
      */
-    Pointer.prototype.snappedToGrid = function (viewport) {
-        var snappedCanvasPos = viewport.snapToGrid(this.canvasPos);
+    snappedToGrid(viewport) {
+        const snappedCanvasPos = viewport.snapToGrid(this.canvasPos);
         return this.withCanvasPosition(snappedCanvasPos, viewport);
-    };
+    }
     // Snap this pointer to the X or Y axis (whichever is closer), where (0,0)
     // is considered to be at `originPointScreen`.
     // @internal
-    Pointer.prototype.lockedToXYAxesScreen = function (originPointScreen, viewport) {
-        var current = this.screenPos;
-        var currentFromStart = current.minus(originPointScreen);
+    lockedToXYAxesScreen(originPointScreen, viewport) {
+        const current = this.screenPos;
+        const currentFromStart = current.minus(originPointScreen);
         // Determine whether the last point was closer to being on the
         // x- or y- axis.
-        var projOntoXAxis = Vec2.unitX.times(currentFromStart.x);
-        var projOntoYAxis = Vec2.unitY.times(currentFromStart.y);
-        var pos;
+        const projOntoXAxis = Vec2.unitX.times(currentFromStart.x);
+        const projOntoYAxis = Vec2.unitY.times(currentFromStart.y);
+        let pos;
         if (currentFromStart.dot(projOntoXAxis) > currentFromStart.dot(projOntoYAxis)) {
             pos = projOntoXAxis;
         }
@@ -59,64 +59,60 @@ var Pointer = /** @class */ (function () {
         }
         pos = pos.plus(originPointScreen);
         return this.withScreenPosition(pos, viewport);
-    };
+    }
     /** @see {@link withCanvasPosition} */
-    Pointer.prototype.withScreenPosition = function (screenPos, viewport) {
-        var canvasPos = viewport.screenToCanvas(screenPos);
+    withScreenPosition(screenPos, viewport) {
+        const canvasPos = viewport.screenToCanvas(screenPos);
         return this.withCanvasPosition(canvasPos, viewport);
-    };
+    }
+    /** Returns a copy of this pointer with a changed timestamp. */
+    withTimestamp(timeStamp) {
+        return new Pointer(this.screenPos, this.canvasPos, this.pressure, this.isPrimary, this.down, this.device, this.id, timeStamp);
+    }
     /**
      * Returns a copy of this pointer with a new position. The screen position is determined
      * by the given `canvasPos`.
      */
-    Pointer.prototype.withCanvasPosition = function (canvasPos, viewport) {
-        var screenPos = viewport.canvasToScreen(canvasPos);
+    withCanvasPosition(canvasPos, viewport) {
+        const screenPos = viewport.canvasToScreen(canvasPos);
         return new Pointer(screenPos, canvasPos, this.pressure, this.isPrimary, this.down, this.device, this.id, this.timeStamp);
-    };
+    }
     // Creates a Pointer from a DOM event. If `relativeTo` is given, (0, 0) in screen coordinates is
     // considered the top left of `relativeTo`.
-    Pointer.ofEvent = function (evt, isDown, viewport, relativeTo) {
-        var _a, _b;
-        var screenPos = Vec2.of(evt.clientX, evt.clientY);
+    static ofEvent(evt, isDown, viewport, relativeTo) {
+        let screenPos = Vec2.of(evt.clientX, evt.clientY);
         if (relativeTo) {
-            var bbox = relativeTo.getBoundingClientRect();
+            const bbox = relativeTo.getBoundingClientRect();
             screenPos = screenPos.minus(Vec2.of(bbox.left, bbox.top));
         }
-        var pointerTypeToDevice = {
+        const pointerTypeToDevice = {
             'mouse': PointerDevice.PrimaryButtonMouse,
             'pen': PointerDevice.Pen,
             'touch': PointerDevice.Touch,
         };
-        var device = (_a = pointerTypeToDevice[evt.pointerType]) !== null && _a !== void 0 ? _a : PointerDevice.Other;
-        var eraserButtonMask = 0x20;
+        let device = pointerTypeToDevice[evt.pointerType] ?? PointerDevice.Other;
+        const eraserButtonMask = 0x20;
         if (device === PointerDevice.Pen && (evt.buttons & eraserButtonMask) !== 0) {
             device = PointerDevice.Eraser;
         }
-        var timeStamp = (new Date()).getTime();
-        var canvasPos = viewport.roundPoint(viewport.screenToCanvas(screenPos));
+        const timeStamp = evt.timeStamp;
+        const canvasPos = viewport.roundPoint(viewport.screenToCanvas(screenPos));
         if (device === PointerDevice.PrimaryButtonMouse) {
             if (evt.buttons & 0x2) {
                 device = PointerDevice.RightButtonMouse;
             }
-            // Commented out to work around a bug in old versions of Chrome:
-            // Left mouse up events were being given type "other".
+            // Commented out: Mouse up events seem to not satisfy this condition on mouse up.
             // else if (!(evt.buttons & 0x1)) {
             //	device = PointerDevice.Other;
             //}
         }
-        return new Pointer(screenPos, canvasPos, (_b = evt.pressure) !== null && _b !== void 0 ? _b : null, evt.isPrimary, isDown, device, evt.pointerId, timeStamp);
-    };
+        return new Pointer(screenPos, canvasPos, evt.pressure ?? null, evt.isPrimary, isDown, device, evt.pointerId, timeStamp);
+    }
     // Create a new Pointer from a point on the canvas.
     // Intended for unit tests.
-    Pointer.ofCanvasPoint = function (canvasPos, isDown, viewport, id, device, isPrimary, pressure) {
-        if (id === void 0) { id = 0; }
-        if (device === void 0) { device = PointerDevice.Pen; }
-        if (isPrimary === void 0) { isPrimary = true; }
-        if (pressure === void 0) { pressure = null; }
-        var screenPos = viewport.canvasToScreen(canvasPos);
-        var timeStamp = (new Date()).getTime();
+    static ofCanvasPoint(canvasPos, isDown, viewport, id = 0, device = PointerDevice.Pen, isPrimary = true, pressure = null) {
+        const screenPos = viewport.canvasToScreen(canvasPos);
+        const timeStamp = (new Date()).getTime();
         return new Pointer(screenPos, canvasPos, pressure, isPrimary, isDown, device, id, timeStamp);
-    };
-    return Pointer;
-}());
-export default Pointer;
+    }
+}

package/dist/mjs/SVGLoader.d.ts

@@ -1,8 +1,9 @@
-import Rect2 from './math/shapes/Rect2';
+import { Rect2 } from '@js-draw/math';
 import { ComponentAddedListener, ImageLoader, OnDetermineExportRectListener, OnProgressListener } from './types';
 export declare const defaultSVGViewRect: Rect2;
 export declare const svgAttributesDataKey = "svgAttrs";
 export declare const svgStyleAttributesDataKey = "svgStyleAttrs";
+export declare const svgLoaderAttributeContainerID = "svgContainerID";
 export type SVGLoaderUnknownAttribute = [string, string];
 export type SVGLoaderUnknownStyleAttribute = {
     key: string;
@@ -30,6 +31,11 @@ export default class SVGLoader implements ImageLoader {
     private addText;
     private addImage;
     private addUnknownNode;
+    private containerGroupIDs;
+    private encounteredIDs;
+    private startGroup;
+    private endGroup;
+    private addComponent;
     private updateViewBox;
     private updateSVGAttrs;
     private visit;