js-draw 0.23.1 → 0.24.0

package/dist/cjs/types.js

@@ -0,0 +1,38 @@
+"use strict";
+// Types related to the image editor
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UndoEventType = exports.EditorEventType = exports.InputEvtType = void 0;
+var InputEvtType;
+(function (InputEvtType) {
+    InputEvtType[InputEvtType["PointerDownEvt"] = 0] = "PointerDownEvt";
+    InputEvtType[InputEvtType["PointerMoveEvt"] = 1] = "PointerMoveEvt";
+    InputEvtType[InputEvtType["PointerUpEvt"] = 2] = "PointerUpEvt";
+    InputEvtType[InputEvtType["GestureCancelEvt"] = 3] = "GestureCancelEvt";
+    InputEvtType[InputEvtType["WheelEvt"] = 4] = "WheelEvt";
+    InputEvtType[InputEvtType["KeyPressEvent"] = 5] = "KeyPressEvent";
+    InputEvtType[InputEvtType["KeyUpEvent"] = 6] = "KeyUpEvent";
+    InputEvtType[InputEvtType["CopyEvent"] = 7] = "CopyEvent";
+    InputEvtType[InputEvtType["PasteEvent"] = 8] = "PasteEvent";
+})(InputEvtType || (exports.InputEvtType = InputEvtType = {}));
+var EditorEventType;
+(function (EditorEventType) {
+    EditorEventType[EditorEventType["ToolEnabled"] = 0] = "ToolEnabled";
+    EditorEventType[EditorEventType["ToolDisabled"] = 1] = "ToolDisabled";
+    EditorEventType[EditorEventType["ToolUpdated"] = 2] = "ToolUpdated";
+    EditorEventType[EditorEventType["UndoRedoStackUpdated"] = 3] = "UndoRedoStackUpdated";
+    EditorEventType[EditorEventType["CommandDone"] = 4] = "CommandDone";
+    EditorEventType[EditorEventType["CommandUndone"] = 5] = "CommandUndone";
+    EditorEventType[EditorEventType["ObjectAdded"] = 6] = "ObjectAdded";
+    EditorEventType[EditorEventType["ViewportChanged"] = 7] = "ViewportChanged";
+    EditorEventType[EditorEventType["DisplayResized"] = 8] = "DisplayResized";
+    EditorEventType[EditorEventType["ColorPickerToggled"] = 9] = "ColorPickerToggled";
+    EditorEventType[EditorEventType["ColorPickerColorSelected"] = 10] = "ColorPickerColorSelected";
+    EditorEventType[EditorEventType["ToolbarDropdownShown"] = 11] = "ToolbarDropdownShown";
+})(EditorEventType || (exports.EditorEventType = EditorEventType = {}));
+// Types of `EditorUndoStackUpdated` events.
+var UndoEventType;
+(function (UndoEventType) {
+    UndoEventType[UndoEventType["CommandDone"] = 0] = "CommandDone";
+    UndoEventType[UndoEventType["CommandUndone"] = 1] = "CommandUndone";
+    UndoEventType[UndoEventType["CommandRedone"] = 2] = "CommandRedone";
+})(UndoEventType || (exports.UndoEventType = UndoEventType = {}));

package/dist/cjs/util/assertions.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertIsNumberArray = exports.assertIsNumber = exports.assertUnreachable = void 0;
+/**
+ * Compile-time assertion that a branch of code is unreachable.
+ * @internal
+ */
+var assertUnreachable = function (key) {
+    // See https://stackoverflow.com/a/39419171/17055750
+    throw new Error("Should be unreachable. Key: ".concat(key, "."));
+};
+exports.assertUnreachable = assertUnreachable;
+/**
+ * Throws an exception if the typeof given value is not a number or `value` is NaN.
+ *
+ * @example
+ * ```ts
+ * const foo: unknown = 3;
+ * assertIsNumber(foo);
+ *
+ * assertIsNumber('hello, world'); // throws an Error.
+ * ```
+ *
+ *
+ */
+var assertIsNumber = function (value, allowNaN) {
+    if (allowNaN === void 0) { allowNaN = false; }
+    if (typeof value !== 'number' || (!allowNaN && isNaN(value))) {
+        throw new Error('Given value is not a number');
+        // return false;
+    }
+    return true;
+};
+exports.assertIsNumber = assertIsNumber;
+/**
+ * Throws if any of `values` is not of type number.
+ */
+var assertIsNumberArray = function (values, allowNaN) {
+    if (allowNaN === void 0) { allowNaN = false; }
+    if (typeof values !== 'object') {
+        throw new Error('Asserting isNumberArray: Given entity is not an array');
+    }
+    if (!(0, exports.assertIsNumber)(values['length'])) {
+        return false;
+    }
+    for (var _i = 0, values_1 = values; _i < values_1.length; _i++) {
+        var value = values_1[_i];
+        if (!(0, exports.assertIsNumber)(value, allowNaN)) {
+            return false;
+        }
+    }
+    return true;
+};
+exports.assertIsNumberArray = assertIsNumberArray;

package/dist/cjs/util/fileToBase64.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var fileToBase64 = function (file, onprogress) {
+    var reader = new FileReader();
+    return new Promise(function (resolve, reject) {
+        reader.onload = function () { return resolve(reader.result); };
+        reader.onerror = reject;
+        reader.onabort = reject;
+        reader.onprogress = function (evt) {
+            onprogress === null || onprogress === void 0 ? void 0 : onprogress(evt);
+        };
+        reader.readAsDataURL(file);
+    });
+};
+exports.default = fileToBase64;

package/dist/cjs/util/untilNextAnimationFrame.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/** @internal */
+var untilNextAnimationFrame = function () {
+    return new Promise(function (resolve) {
+        requestAnimationFrame(function () { return resolve(); });
+    });
+};
+exports.default = untilNextAnimationFrame;

package/dist/cjs/util/waitForAll.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Resolves when all given promises have resolved. If no promises are given,
+ * does not return a Promise.
+ */
+var waitForAll = function (results) {
+    // If any are Promises...
+    if (results.some(function (command) { return command && command['then']; })) {
+        // Wait for all commands to finish.
+        return Promise.all(results)
+            // Ensure we return a Promise<void> and not a Promise<void[]>
+            .then(function () { });
+    }
+    return;
+};
+exports.default = waitForAll;

package/dist/cjs/util/waitForTimeout.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Returns a promise that resolves after `timeout` milliseconds.
+var waitForTimeout = function (timeout) {
+    return new Promise(function (resolve) {
+        setTimeout(function () { return resolve(); }, timeout);
+    });
+};
+exports.default = waitForTimeout;

package/dist/mjs/Color4.mjs

@@ -0,0 +1,260 @@
+import  Vec3  from './math/Vec3.mjs';
+var Color4 = /** @class */ (function () {
+    function Color4(
+    /** Red component. Should be in the range [0, 1]. */
+    r, 
+    /** Green component. `g` ∈ [0, 1] */
+    g, 
+    /** Blue component. `b` ∈ [0, 1] */
+    b, 
+    /** Alpha/transparent component. `a` ∈ [0, 1]. 0 = transparent */
+    a) {
+        this.r = r;
+        this.g = g;
+        this.b = b;
+        this.a = a;
+        this.hexString = null;
+    }
+    /**
+     * Create a color from red, green, blue components. The color is fully opaque (`a = 1.0`).
+     *
+     * Each component should be in the range [0, 1].
+     */
+    Color4.ofRGB = function (red, green, blue) {
+        return Color4.ofRGBA(red, green, blue, 1.0);
+    };
+    Color4.ofRGBA = function (red, green, blue, alpha) {
+        red = Math.max(0, Math.min(red, 1));
+        green = Math.max(0, Math.min(green, 1));
+        blue = Math.max(0, Math.min(blue, 1));
+        alpha = Math.max(0, Math.min(alpha, 1));
+        return new Color4(red, green, blue, alpha);
+    };
+    Color4.fromHex = function (hexString) {
+        var _a;
+        // Remove starting '#' (if present)
+        hexString = ((_a = hexString.match(/^[#]?(.*)$/)) !== null && _a !== void 0 ? _a : [])[1];
+        hexString = hexString.toUpperCase();
+        if (!hexString.match(/^[0-9A-F]+$/)) {
+            throw new Error("".concat(hexString, " is not in a valid format."));
+        }
+        // RGBA or RGB
+        if (hexString.length === 3 || hexString.length === 4) {
+            // Each character is a component
+            var components_1 = hexString.split('');
+            // Convert to RRGGBBAA or RRGGBB format
+            hexString = components_1.map(function (component) { return "".concat(component, "0"); }).join('');
+        }
+        if (hexString.length === 6) {
+            // Alpha component
+            hexString += 'FF';
+        }
+        var components = [];
+        for (var i = 2; i <= hexString.length; i += 2) {
+            var chunk = hexString.substring(i - 2, i);
+            components.push(parseInt(chunk, 16) / 255);
+        }
+        if (components.length !== 4) {
+            throw new Error("Unable to parse ".concat(hexString, ": Wrong number of components."));
+        }
+        return Color4.ofRGBA(components[0], components[1], components[2], components[3]);
+    };
+    /** Like fromHex, but can handle additional colors if an `HTMLCanvasElement` is available. */
+    Color4.fromString = function (text) {
+        if (text.startsWith('#')) {
+            return Color4.fromHex(text);
+        }
+        if (text === 'none' || text === 'transparent') {
+            return Color4.transparent;
+        }
+        // rgba?: Match both rgb and rgba strings.
+        // ([,0-9.]+): Match any string of only numeric, '.' and ',' characters.
+        var rgbRegex = /^rgba?\(([,0-9.]+)\)$/i;
+        var rgbMatch = text.replace(/\s*/g, '').match(rgbRegex);
+        if (rgbMatch) {
+            var componentsListStr = rgbMatch[1];
+            var componentsList = JSON.parse("[ ".concat(componentsListStr, " ]"));
+            if (componentsList.length === 3) {
+                return Color4.ofRGB(componentsList[0] / 255, componentsList[1] / 255, componentsList[2] / 255);
+            }
+            else if (componentsList.length === 4) {
+                return Color4.ofRGBA(componentsList[0] / 255, componentsList[1] / 255, componentsList[2] / 255, componentsList[3]);
+            }
+            else {
+                throw new Error("RGB string, ".concat(text, ", has wrong number of components: ").concat(componentsList.length));
+            }
+        }
+        // Otherwise, try to use an HTMLCanvasElement to determine the color.
+        // Note: We may be unable to create an HTMLCanvasElement if running as a unit test.
+        var canvas = document.createElement('canvas');
+        canvas.width = 1;
+        canvas.height = 1;
+        var ctx = canvas.getContext('2d');
+        ctx.fillStyle = text;
+        ctx.fillRect(0, 0, 1, 1);
+        var data = ctx.getImageData(0, 0, 1, 1);
+        var red = data.data[0] / 255;
+        var green = data.data[1] / 255;
+        var blue = data.data[2] / 255;
+        var alpha = data.data[3] / 255;
+        return Color4.ofRGBA(red, green, blue, alpha);
+    };
+    /** @returns true if `this` and `other` are approximately equal. */
+    Color4.prototype.eq = function (other) {
+        if (other == null) {
+            return false;
+        }
+        // If both completely transparent,
+        if (this.a === 0 && other.a === 0) {
+            return true;
+        }
+        return this.toHexString() === other.toHexString();
+    };
+    /**
+     * If `fractionTo` is not in the range [0, 1], it will be clamped to the nearest number
+     * in that range. For example, `a.mix(b, -1)` is equivalent to `a.mix(b, 0)`.
+     *
+     * @returns a color `fractionTo` of the way from this color to `other`.
+     *
+     * @example
+     * ```ts
+     * Color4.ofRGB(1, 0, 0).mix(Color4.ofRGB(0, 1, 0), 0.1) // -> Color4(0.9, 0.1, 0)
+     * ```
+     */
+    Color4.prototype.mix = function (other, fractionTo) {
+        fractionTo = Math.min(Math.max(fractionTo, 0), 1);
+        var fractionOfThis = 1 - fractionTo;
+        return new Color4(this.r * fractionOfThis + other.r * fractionTo, this.g * fractionOfThis + other.g * fractionTo, this.b * fractionOfThis + other.b * fractionTo, this.a * fractionOfThis + other.a * fractionTo);
+    };
+    /**
+     * @returns the component-wise average of `colors`, or `Color4.transparent` if `colors` is empty.
+     */
+    Color4.average = function (colors) {
+        var averageA = 0;
+        var averageR = 0;
+        var averageG = 0;
+        var averageB = 0;
+        for (var _i = 0, colors_1 = colors; _i < colors_1.length; _i++) {
+            var color = colors_1[_i];
+            averageA += color.a;
+            averageR += color.r;
+            averageG += color.g;
+            averageB += color.b;
+        }
+        if (colors.length > 0) {
+            averageA /= colors.length;
+            averageR /= colors.length;
+            averageG /= colors.length;
+            averageB /= colors.length;
+        }
+        return new Color4(averageR, averageG, averageB, averageA);
+    };
+    /**
+     * Converts to (hue, saturation, value).
+     * See also https://en.wikipedia.org/wiki/HSL_and_HSV#General_approach
+     *
+     * The resultant hue is represented in radians and is thus in [0, 2pi].
+     */
+    Color4.prototype.asHSV = function () {
+        // Ref: https://en.wikipedia.org/wiki/HSL_and_HSV#General_approach
+        //
+        // HUE:
+        // First, consider the unit cube. Rotate it such that one vertex is at the origin
+        // of a plane and its three neighboring vertices are equidistant from that plane:
+        //
+        //         /\
+        //       /  | \
+        //   2 /    3   \ 1
+        //     \    |   /
+        //       \  | /
+        //   .     \/      .
+        //
+        //        .
+        //
+        // Let z be up and (x, y, 0) be in the plane.
+        //
+        // Label vectors 1,2,3 with R, G, and B, respectively. Let R's projection into the plane
+        // lie along the x axis.
+        //
+        // Because R is a unit vector and R, G, B are equidistant from the plane, they must
+        // form 30-60-90 triangles, which have side lengths proportional to (1, √3, 2)
+        //
+        //       /|
+        //    1/  | (√3)/2
+        //    /   |
+        //      1/2
+        //
+        var minComponent = Math.min(this.r, this.g, this.b);
+        var maxComponent = Math.max(this.r, this.g, this.b);
+        var chroma = maxComponent - minComponent;
+        var hue;
+        // See https://en.wikipedia.org/wiki/HSL_and_HSV#General_approach
+        if (chroma === 0) {
+            hue = 0;
+        }
+        else if (this.r >= this.g && this.r >= this.b) {
+            hue = ((this.g - this.b) / chroma) % 6;
+        }
+        else if (this.g >= this.r && this.g >= this.b) {
+            hue = (this.b - this.r) / chroma + 2;
+        }
+        else {
+            hue = (this.r - this.g) / chroma + 4;
+        }
+        // Convert to degree representation, then to radians.
+        hue *= 60;
+        hue *= Math.PI / 180;
+        // Ensure positivity.
+        if (hue < 0) {
+            hue += Math.PI * 2;
+        }
+        var value = maxComponent;
+        var saturation = value > 0 ? chroma / value : 0;
+        return Vec3.of(hue, saturation, value);
+    };
+    /**
+     * @returns a hexadecimal color string representation of `this`, in the form `#rrggbbaa`.
+     *
+     * @example
+     * ```
+     * Color4.red.toHexString(); // -> #ff0000ff
+     * ```
+     */
+    Color4.prototype.toHexString = function () {
+        if (this.hexString) {
+            return this.hexString;
+        }
+        var componentToHex = function (component) {
+            var res = Math.round(255 * component).toString(16);
+            if (res.length === 1) {
+                return "0".concat(res);
+            }
+            return res;
+        };
+        var alpha = componentToHex(this.a);
+        var red = componentToHex(this.r);
+        var green = componentToHex(this.g);
+        var blue = componentToHex(this.b);
+        if (alpha === 'ff') {
+            return "#".concat(red).concat(green).concat(blue);
+        }
+        this.hexString = "#".concat(red).concat(green).concat(blue).concat(alpha);
+        return this.hexString;
+    };
+    Color4.prototype.toString = function () {
+        return this.toHexString();
+    };
+    Color4.transparent = Color4.ofRGBA(0, 0, 0, 0);
+    Color4.red = Color4.ofRGB(1.0, 0.0, 0.0);
+    Color4.green = Color4.ofRGB(0.0, 1.0, 0.0);
+    Color4.blue = Color4.ofRGB(0.0, 0.0, 1.0);
+    Color4.purple = Color4.ofRGB(0.5, 0.2, 0.5);
+    Color4.yellow = Color4.ofRGB(1, 1, 0.1);
+    Color4.clay = Color4.ofRGB(0.8, 0.4, 0.2);
+    Color4.black = Color4.ofRGB(0, 0, 0);
+    Color4.gray = Color4.ofRGB(0.5, 0.5, 0.5);
+    Color4.white = Color4.ofRGB(1, 1, 1);
+    return Color4;
+}());
+export default Color4;
+export { Color4 };

package/dist/mjs/Color4.test.d.ts

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