js-draw 0.18.1 → 0.19.0

package/dist/cjs/src/localizations/en.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const localization_1 = require("../localization");
+// Default localizations are already in English.
+const localization = Object.assign({}, localization_1.defaultEditorLocalization);
+exports.default = localization;

package/dist/cjs/src/localizations/es.d.ts

@@ -0,0 +1,3 @@
+import { EditorLocalization } from '../localization';
+declare const localization: EditorLocalization;
+export default localization;

package/dist/cjs/src/localizations/es.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const localization_1 = require("../localization");
+// A partial Spanish localization.
+const localization = Object.assign(Object.assign({}, localization_1.defaultEditorLocalization), { 
+    // Strings for the main editor interface
+    // (see src/localization.ts)
+    loading: (percentage) => `Cargando: ${percentage}%...`, imageEditor: 'Editor de dibujos', undoAnnouncement: (commandDescription) => `${commandDescription} fue deshecho`, redoAnnouncement: (commandDescription) => `${commandDescription} fue rehecho`, undo: 'Deshace', redo: 'Rehace', 
+    // Strings for the toolbar
+    // (see src/toolbar/localization.ts)
+    pen: 'Lapiz', eraser: 'Borrador', select: 'Selecciona', thicknessLabel: 'Tamaño: ', colorLabel: 'Color: ', doneLoading: 'El cargado terminó', fontLabel: 'Fuente: ', anyDevicePanning: 'Mover la pantalla con todo dispotivo', touchPanning: 'Mover la pantalla con un dedo', touchPanTool: 'Instrumento de mover la pantalla con un dedo', outlinedRectanglePen: 'Rectángulo con nada más que un borde', filledRectanglePen: 'Rectángulo sin borde', linePen: 'Línea', arrowPen: 'Flecha', freehandPen: 'Dibuja sin restricción de forma', selectObjectType: 'Forma de dibuja:', handTool: 'Mover', zoom: 'Zoom', resetView: 'Reiniciar vista', resizeImageToSelection: 'Redimensionar la imagen a lo que está seleccionado', deleteSelection: 'Borra la selección', duplicateSelection: 'Duplica la selección', pickColorFromScreen: 'Selecciona un color de la pantalla', clickToPickColorAnnouncement: 'Haga un clic en la pantalla para seleccionar un color', dropdownShown(toolName) {
+        return `Menú por ${toolName} es visible`;
+    }, dropdownHidden: function (toolName) {
+        return `Menú por ${toolName} fue ocultado`;
+    }, colorChangedAnnouncement: function (color) {
+        return `Color fue cambiado a ${color}`;
+    }, keyboardPanZoom: 'Mover la pantalla con el teclado', penTool: function (penId) {
+        return `Lapiz ${penId}`;
+    }, selectionTool: 'Selecciona', eraserTool: 'Borrador', textTool: 'Texto', enterTextToInsert: 'Entra texto', textSize: 'Tamaño', rerenderAsText: 'Redibuja la pantalla al texto', lockRotation: 'Bloquea rotación', image: 'Imagen', imageSize: (size, units) => `Tamaño del imagen: ${size} ${units}`, imageLoadError: (message) => `Error cargando imagen: ${message}`, toggleOverflow: 'Más', documentProperties: 'Fondo', imageWidthOption: 'Ancho: ', imageHeightOption: 'Alto: ', backgroundColor: 'Color de fondo: ' });
+exports.default = localization;

package/dist/cjs/src/localizations/getLocalizationTable.d.ts

@@ -0,0 +1,3 @@
+import { EditorLocalization } from '../localization';
+declare const getLocalizationTable: (userLocales?: readonly string[]) => EditorLocalization;
+export default getLocalizationTable;

package/dist/cjs/src/localizations/getLocalizationTable.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const localization_1 = require("../localization");
+const de_1 = __importDefault(require("./de"));
+const en_1 = __importDefault(require("./en"));
+const es_1 = __importDefault(require("./es"));
+const allLocales = {
+    de: de_1.default,
+    en: en_1.default,
+    es: es_1.default,
+};
+// [locale]: A string in the format languageCode_Region or just languageCode. For example, en_US.
+const languageFromLocale = (locale) => {
+    const matches = /^(\w+)[_-](\w+)$/.exec(locale);
+    if (!matches) {
+        // If not in languageCode_region format, the locale should be the
+        // languageCode. Return that.
+        return locale;
+    }
+    return matches[1];
+};
+const getLocalizationTable = (userLocales) => {
+    userLocales !== null && userLocales !== void 0 ? userLocales : (userLocales = navigator.languages);
+    let prevLanguage;
+    for (const locale of userLocales) {
+        const language = languageFromLocale(locale);
+        // If the specific localization of the language is not available, but
+        // a localization for the language is,
+        if (prevLanguage && language !== prevLanguage) {
+            if (prevLanguage in allLocales) {
+                return allLocales[prevLanguage];
+            }
+        }
+        // If the full locale (e.g. en_US) is available,
+        if (locale in allLocales) {
+            return allLocales[locale];
+        }
+        prevLanguage = language;
+    }
+    if (prevLanguage && prevLanguage in allLocales) {
+        return allLocales[prevLanguage];
+    }
+    else {
+        return localization_1.defaultEditorLocalization;
+    }
+};
+exports.default = getLocalizationTable;

package/dist/cjs/src/math/LineSegment2.d.ts

@@ -0,0 +1,24 @@
+import Mat33 from './Mat33';
+import Rect2 from './Rect2';
+import { Vec2, Point2 } from './Vec2';
+interface IntersectionResult {
+    point: Point2;
+    t: number;
+}
+export default class LineSegment2 {
+    private readonly point1;
+    private readonly point2;
+    readonly direction: Vec2;
+    readonly length: number;
+    readonly bbox: Rect2;
+    constructor(point1: Point2, point2: Point2);
+    get p1(): Point2;
+    get p2(): Point2;
+    get(t: number): Point2;
+    intersection(other: LineSegment2): IntersectionResult | null;
+    intersects(other: LineSegment2): boolean;
+    closestPointTo(target: Point2): import("./Vec3").default;
+    transformedBy(affineTransfm: Mat33): LineSegment2;
+    toString(): string;
+}
+export {};

package/dist/cjs/src/math/LineSegment2.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Rect2_1 = __importDefault(require("./Rect2"));
+const Vec2_1 = require("./Vec2");
+class LineSegment2 {
+    constructor(point1, point2) {
+        this.point1 = point1;
+        this.point2 = point2;
+        this.bbox = Rect2_1.default.bboxOf([point1, point2]);
+        this.direction = point2.minus(point1);
+        this.length = this.direction.magnitude();
+        // Normalize
+        if (this.length > 0) {
+            this.direction = this.direction.times(1 / this.length);
+        }
+    }
+    // Accessors to make LineSegment2 compatible with bezier-js's
+    // interface
+    get p1() {
+        return this.point1;
+    }
+    get p2() {
+        return this.point2;
+    }
+    get(t) {
+        return this.point1.plus(this.direction.times(t));
+    }
+    intersection(other) {
+        // We want x₁(t) = x₂(t) and y₁(t) = y₂(t)
+        // Observe that
+        // x = this.point1.x + this.direction.x · t₁
+        //   = other.point1.x + other.direction.x · t₂
+        // Thus,
+        //  t₁ = (x - this.point1.x) / this.direction.x
+        //     = (y - this.point1.y) / this.direction.y
+        // and
+        //  t₂ = (x - other.point1.x) / other.direction.x
+        // (and similarly for y)
+        //
+        // Letting o₁ₓ = this.point1.x, o₂ₓ = other.point1.x,
+        //         d₁ᵧ = this.direction.y, ...
+        //
+        // We can substitute these into the equations for y:
+        // y = o₁ᵧ + d₁ᵧ · (x - o₁ₓ) / d₁ₓ
+        //   = o₂ᵧ + d₂ᵧ · (x - o₂ₓ) / d₂ₓ
+        // ⇒ o₁ᵧ - o₂ᵧ = d₂ᵧ · (x - o₂ₓ) / d₂ₓ - d₁ᵧ · (x - o₁ₓ) / d₁ₓ
+        //            = (d₂ᵧ/d₂ₓ)(x) - (d₂ᵧ/d₂ₓ)(o₂ₓ) - (d₁ᵧ/d₁ₓ)(x) + (d₁ᵧ/d₁ₓ)(o₁ₓ)
+        //            = (x)(d₂ᵧ/d₂ₓ - d₁ᵧ/d₁ₓ) - (d₂ᵧ/d₂ₓ)(o₂ₓ) + (d₁ᵧ/d₁ₓ)(o₁ₓ)
+        // ⇒ (x)(d₂ᵧ/d₂ₓ - d₁ᵧ/d₁ₓ) = o₁ᵧ - o₂ᵧ + (d₂ᵧ/d₂ₓ)(o₂ₓ) - (d₁ᵧ/d₁ₓ)(o₁ₓ)
+        // ⇒ x = (o₁ᵧ - o₂ᵧ + (d₂ᵧ/d₂ₓ)(o₂ₓ) - (d₁ᵧ/d₁ₓ)(o₁ₓ))/(d₂ᵧ/d₂ₓ - d₁ᵧ/d₁ₓ)
+        //     = (d₁ₓd₂ₓ)(o₁ᵧ - o₂ᵧ + (d₂ᵧ/d₂ₓ)(o₂ₓ) - (d₁ᵧ/d₁ₓ)(o₁ₓ))/(d₂ᵧd₁ₓ - d₁ᵧd₂ₓ)
+        //     = ((o₁ᵧ - o₂ᵧ)((d₁ₓd₂ₓ)) + (d₂ᵧd₁ₓ)(o₂ₓ) - (d₁ᵧd₂ₓ)(o₁ₓ))/(d₂ᵧd₁ₓ - d₁ᵧd₂ₓ)
+        // ⇒ y = o₁ᵧ + d₁ᵧ · (x - o₁ₓ) / d₁ₓ = ...
+        let resultPoint, resultT;
+        if (this.direction.x === 0) {
+            // Vertical line: Where does the other have x = this.point1.x?
+            // x = o₁ₓ = o₂ₓ + d₂ₓ · (y - o₂ᵧ) / d₂ᵧ
+            // ⇒ (o₁ₓ - o₂ₓ)(d₂ᵧ/d₂ₓ) + o₂ᵧ = y
+            // Avoid division by zero
+            if (other.direction.x === 0 || this.direction.y === 0) {
+                return null;
+            }
+            const xIntersect = this.point1.x;
+            const yIntersect = (this.point1.x - other.point1.x) * other.direction.y / other.direction.x + other.point1.y;
+            resultPoint = Vec2_1.Vec2.of(xIntersect, yIntersect);
+            resultT = (yIntersect - this.point1.y) / this.direction.y;
+        }
+        else {
+            // From above,
+            // x = ((o₁ᵧ - o₂ᵧ)(d₁ₓd₂ₓ) + (d₂ᵧd₁ₓ)(o₂ₓ) - (d₁ᵧd₂ₓ)(o₁ₓ))/(d₂ᵧd₁ₓ - d₁ᵧd₂ₓ)
+            const numerator = ((this.point1.y - other.point1.y) * this.direction.x * other.direction.x
+                + this.direction.x * other.direction.y * other.point1.x
+                - this.direction.y * other.direction.x * this.point1.x);
+            const denominator = (other.direction.y * this.direction.x
+                - this.direction.y * other.direction.x);
+            // Avoid dividing by zero. It means there is no intersection
+            if (denominator === 0) {
+                return null;
+            }
+            const xIntersect = numerator / denominator;
+            const t1 = (xIntersect - this.point1.x) / this.direction.x;
+            const yIntersect = this.point1.y + this.direction.y * t1;
+            resultPoint = Vec2_1.Vec2.of(xIntersect, yIntersect);
+            resultT = (xIntersect - this.point1.x) / this.direction.x;
+        }
+        // Ensure the result is in this/the other segment.
+        const resultToP1 = resultPoint.minus(this.point1).magnitude();
+        const resultToP2 = resultPoint.minus(this.point2).magnitude();
+        const resultToP3 = resultPoint.minus(other.point1).magnitude();
+        const resultToP4 = resultPoint.minus(other.point2).magnitude();
+        if (resultToP1 > this.length
+            || resultToP2 > this.length
+            || resultToP3 > other.length
+            || resultToP4 > other.length) {
+            return null;
+        }
+        return {
+            point: resultPoint,
+            t: resultT,
+        };
+    }
+    intersects(other) {
+        return this.intersection(other) !== null;
+    }
+    // Returns the closest point on this to [target]
+    closestPointTo(target) {
+        // Distance from P1 along this' direction.
+        const projectedDistFromP1 = target.minus(this.p1).dot(this.direction);
+        const projectedDistFromP2 = this.length - projectedDistFromP1;
+        const projection = this.p1.plus(this.direction.times(projectedDistFromP1));
+        if (projectedDistFromP1 > 0 && projectedDistFromP1 < this.length) {
+            return projection;
+        }
+        if (Math.abs(projectedDistFromP2) < Math.abs(projectedDistFromP1)) {
+            return this.p2;
+        }
+        else {
+            return this.p1;
+        }
+    }
+    transformedBy(affineTransfm) {
+        return new LineSegment2(affineTransfm.transformVec2(this.p1), affineTransfm.transformVec2(this.p2));
+    }
+    toString() {
+        return `LineSegment(${this.p1.toString()}, ${this.p2.toString()})`;
+    }
+}
+exports.default = LineSegment2;

package/dist/cjs/src/math/Mat33.d.ts

@@ -0,0 +1,118 @@
+import { Point2, Vec2 } from './Vec2';
+import Vec3 from './Vec3';
+export type Mat33Array = [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+/**
+ * Represents a three dimensional linear transformation or
+ * a two-dimensional affine transformation. (An affine transformation scales/rotates/shears
+ * **and** translates while a linear transformation just scales/rotates/shears).
+ */
+export default class Mat33 {
+    readonly a1: number;
+    readonly a2: number;
+    readonly a3: number;
+    readonly b1: number;
+    readonly b2: number;
+    readonly b3: number;
+    readonly c1: number;
+    readonly c2: number;
+    readonly c3: number;
+    private readonly rows;
+    /**
+     * Creates a matrix from inputs in the form,
+     * ```
+     * ⎡ a1 a2 a3 ⎤
+     * ⎢ b1 b2 b3 ⎥
+     * ⎣ c1 c2 c3 ⎦
+     * ```
+     */
+    constructor(a1: number, a2: number, a3: number, b1: number, b2: number, b3: number, c1: number, c2: number, c3: number);
+    /**
+     * Creates a matrix from the given rows:
+     * ```
+     *  ⎡ r1.x r1.y r1.z ⎤
+     *  ⎢ r2.x r2.y r2.z ⎥
+     *  ⎣ r3.x r3.y r3.z ⎦
+     * ```
+     */
+    static ofRows(r1: Vec3, r2: Vec3, r3: Vec3): Mat33;
+    static identity: Mat33;
+    /**
+     * Either returns the inverse of this, or, if this matrix is singular/uninvertable,
+     * returns Mat33.identity.
+     *
+     * This may cache the computed inverse and return the cached version instead of recomputing
+     * it.
+     */
+    inverse(): Mat33;
+    invertable(): boolean;
+    private cachedInverse;
+    private computeInverse;
+    transposed(): Mat33;
+    rightMul(other: Mat33): Mat33;
+    /**
+     * Applies this as an affine transformation to the given vector.
+     * Returns a transformed version of `other`.
+     */
+    transformVec2(other: Vec2): Vec2;
+    /**
+     * Applies this as a linear transformation to the given vector (doesn't translate).
+     * This is the standard way of transforming vectors in ℝ³.
+     */
+    transformVec3(other: Vec3): Vec3;
+    /** @returns true iff this is the identity matrix. */
+    isIdentity(): boolean;
+    /** Returns true iff this = other ± fuzz */
+    eq(other: Mat33, fuzz?: number): boolean;
+    toString(): string;
+    /**
+     * ```
+     * result[0] = top left element
+     * result[1] = element at row zero, column 1
+     * ...
+     * ```
+     */
+    toArray(): Mat33Array;
+    /**
+     * @example
+     * ```
+     * new Mat33(
+     *  1, 2, 3,
+     *  4, 5, 6,
+     *  7, 8, 9,
+     * ).mapEntries(component => component - 1);
+     * // → ⎡ 0, 1, 2 ⎤
+     * //   ⎢ 3, 4, 5 ⎥
+     * //   ⎣ 6, 7, 8 ⎦
+     * ```
+     */
+    mapEntries(mapping: (component: number) => number): Mat33;
+    /** Estimate the scale factor of this matrix (based on the first row). */
+    getScaleFactor(): number;
+    /** Constructs a 3x3 translation matrix (for translating `Vec2`s) */
+    static translation(amount: Vec2): Mat33;
+    static zRotation(radians: number, center?: Point2): Mat33;
+    static scaling2D(amount: number | Vec2, center?: Point2): Mat33;
+    /** @see {@link fromCSSMatrix} */
+    toCSSMatrix(): string;
+    /**
+     * Converts a CSS-form `matrix(a, b, c, d, e, f)` to a Mat33.
+     *
+     * Note that such a matrix has the form,
+     * ```
+     * ⎡ a c e ⎤
+     * ⎢ b d f ⎥
+     * ⎣ 0 0 1 ⎦
+     * ```
+     */
+    static fromCSSMatrix(cssString: string): Mat33;
+}