js-draw 0.23.1 → 0.24.0

package/src/components/util/StrokeSmoother.ts

@@ -0,0 +1,302 @@
+import { Point2, Vec2 } from '../../math/Vec2';
+import Rect2 from '../../math/shapes/Rect2';
+import LineSegment2 from '../../math/shapes/LineSegment2';
+import { StrokeDataPoint } from '../../types';
+import QuadraticBezier from '../../math/shapes/QuadraticBezier';
+
+export interface Curve {
+	startPoint: Vec2;
+	startWidth: number;
+
+	controlPoint: Vec2;
+
+	endWidth: number;
+	endPoint: Vec2;
+}
+
+type OnCurveAddedCallback = (curve: Curve|null)=>void;
+
+// Handles stroke smoothing
+export class StrokeSmoother {
+	private isFirstSegment: boolean = true;
+
+	private buffer: Point2[];
+	private lastPoint: StrokeDataPoint;
+	private lastExitingVec: Vec2|null = null;
+	private currentCurve: QuadraticBezier|null = null;
+	private curveStartWidth: number;
+	private curveEndWidth: number;
+
+	// Stroke smoothing and tangent approximation
+	private momentum: Vec2;
+	private bbox: Rect2;
+
+	public constructor(
+		private startPoint: StrokeDataPoint,
+
+		// Maximum distance from the actual curve (irrespective of stroke width)
+		// for which a point is considered 'part of the curve'.
+		// Note that the maximum will be smaller if the stroke width is less than
+		// [maxFitAllowed].
+		private minFitAllowed: number,
+		private maxFitAllowed: number,
+
+		private onCurveAdded: OnCurveAddedCallback,
+	) {
+		this.lastPoint = this.startPoint;
+
+		this.buffer = [this.startPoint.pos];
+		this.momentum = Vec2.zero;
+		this.currentCurve = null;
+		this.curveStartWidth = startPoint.width;
+
+		this.bbox = new Rect2(this.startPoint.pos.x, this.startPoint.pos.y, 0, 0);
+	}
+
+	public getBBox(): Rect2 {
+		return this.bbox;
+	}
+
+	public preview(): Curve|null {
+		if (!this.currentCurve) {
+			return null;
+		}
+
+		return this.currentSegmentToPath();
+	}
+
+	// Returns the distance between the start, control, and end points of the curve.
+	private approxCurrentCurveLength() {
+		if (!this.currentCurve) {
+			return 0;
+		}
+		const startPt = this.currentCurve.p0;
+		const controlPt = this.currentCurve.p1;
+		const endPt = this.currentCurve.p2;
+		const toControlDist = startPt.minus(controlPt).length();
+		const toEndDist = endPt.minus(controlPt).length();
+		return toControlDist + toEndDist;
+	}
+
+	public finalizeCurrentCurve() {
+		// Case where no points have been added
+		if (!this.currentCurve) {
+			return;
+		}
+
+		this.onCurveAdded(this.currentSegmentToPath());
+
+		const lastPoint = this.buffer[this.buffer.length - 1];
+		this.lastExitingVec = this.currentCurve.p2.minus(this.currentCurve.p1);
+		console.assert(this.lastExitingVec.magnitude() !== 0, 'lastExitingVec has zero length!');
+
+		// Use the last two points to start a new curve (the last point isn't used
+		// in the current curve and we want connected curves to share end points)
+		this.buffer = [
+			this.buffer[this.buffer.length - 2], lastPoint,
+		];
+		this.currentCurve = null;
+
+		this.isFirstSegment = false;
+	}
+
+	// Returns [upper curve, connector, lower curve]
+	private currentSegmentToPath() {
+		if (this.currentCurve == null) {
+			throw new Error('Invalid State: currentCurve is null!');
+		}
+
+		const startVec = this.currentCurve.normal(0).normalized();
+
+		if (!isFinite(startVec.magnitude())) {
+			throw new Error(`startVec(${startVec}) is NaN or ∞`);
+		}
+
+		const startPt = this.currentCurve.at(0);
+		const endPt = this.currentCurve.at(1);
+		const controlPoint = this.currentCurve.p1;
+
+		return {
+			startPoint: startPt,
+			controlPoint,
+			endPoint: endPt,
+			startWidth: this.curveStartWidth,
+			endWidth: this.curveEndWidth,
+		};
+	}
+
+	// Compute the direction of the velocity at the end of this.buffer
+	private computeExitingVec(): Vec2 {
+		return this.momentum.normalized().times(this.lastPoint.width / 2);
+	}
+
+	public addPoint(newPoint: StrokeDataPoint) {
+		if (this.lastPoint) {
+			// Ignore points that are identical
+			const fuzzEq = 1e-10;
+			const deltaTime = newPoint.time - this.lastPoint.time;
+			if (newPoint.pos.eq(this.lastPoint.pos, fuzzEq) || deltaTime === 0) {
+				return;
+			} else if (isNaN(newPoint.pos.magnitude())) {
+				console.warn('Discarding NaN point.', newPoint);
+				return;
+			}
+
+			const threshold = Math.min(this.lastPoint.width, newPoint.width) / 3;
+			const shouldSnapToInitial = this.startPoint.pos.minus(newPoint.pos).magnitude() < threshold
+				&& this.isFirstSegment;
+
+			// Snap to the starting point if the stroke is contained within a small ball centered
+			// at the starting point.
+			// This allows us to create a circle/dot at the start of the stroke.
+			if (shouldSnapToInitial) {
+				return;
+			}
+
+			const velocity = newPoint.pos.minus(this.lastPoint.pos).times(1 / (deltaTime) * 1000);
+			this.momentum = this.momentum.lerp(velocity, 0.9);
+		}
+
+		const lastPoint = this.lastPoint ?? newPoint;
+		this.lastPoint = newPoint;
+
+		this.buffer.push(newPoint.pos);
+		const pointRadius = newPoint.width;
+		const prevEndWidth = this.curveEndWidth;
+		this.curveEndWidth = pointRadius;
+
+		// recompute bbox
+		this.bbox = this.bbox.grownToPoint(newPoint.pos, pointRadius);
+
+		// If the last curve just ended or it's the first curve,
+		if (this.currentCurve === null) {
+			const p1 = lastPoint.pos;
+			const p2 = lastPoint.pos.plus(this.lastExitingVec ?? Vec2.unitX);
+			const p3 = newPoint.pos;
+
+			// Quadratic Bézier curve
+			this.currentCurve = new QuadraticBezier(p1, p2, p3);
+			console.assert(!isNaN(p1.magnitude()) && !isNaN(p2.magnitude()) && !isNaN(p3.magnitude()), 'Expected !NaN');
+
+			if (this.isFirstSegment) {
+				// The start of a curve often lacks accurate pressure information. Update it.
+				this.curveStartWidth = (this.curveStartWidth + pointRadius) / 2;
+			}
+			else {
+				this.curveStartWidth = prevEndWidth;
+			}
+		}
+
+		// If there isn't an entering vector (e.g. because this.isFirstCurve), approximate it.
+		let enteringVec = this.lastExitingVec;
+		if (!enteringVec) {
+			let sampleIdx = Math.ceil(this.buffer.length / 2);
+			if (sampleIdx === 0 || sampleIdx >= this.buffer.length) {
+				sampleIdx = this.buffer.length - 1;
+			}
+
+			enteringVec = this.buffer[sampleIdx].minus(this.buffer[0]);
+		}
+
+		let exitingVec = this.computeExitingVec();
+
+		// Find the intersection between the entering vector and the exiting vector
+		const maxRelativeLength = 2;
+		const segmentStart = this.buffer[0];
+		const segmentEnd = newPoint.pos;
+		const startEndDist = segmentEnd.minus(segmentStart).magnitude();
+		const maxControlPointDist = maxRelativeLength * startEndDist;
+
+		// Exit in cases where we would divide by zero
+		if (maxControlPointDist === 0 || exitingVec.magnitude() === 0 || !isFinite(exitingVec.magnitude())) {
+			return;
+		}
+
+		console.assert(isFinite(enteringVec.magnitude()), 'Pre-normalized enteringVec has NaN or ∞ magnitude!');
+
+		enteringVec = enteringVec.normalized();
+		exitingVec = exitingVec.normalized();
+
+		console.assert(isFinite(enteringVec.magnitude()), 'Normalized enteringVec has NaN or ∞ magnitude!');
+
+		const lineFromStart = new LineSegment2(
+			segmentStart,
+			segmentStart.plus(enteringVec.times(maxControlPointDist))
+		);
+		const lineFromEnd = new LineSegment2(
+			segmentEnd.minus(exitingVec.times(maxControlPointDist)),
+			segmentEnd
+		);
+		const intersection = lineFromEnd.intersection(lineFromStart);
+
+		// Position the control point at this intersection
+		let controlPoint: Point2|null = null;
+		if (intersection) {
+			controlPoint = intersection.point;
+		}
+
+		// No intersection or the intersection is one of the end points?
+		if (!controlPoint || segmentStart.eq(controlPoint) || segmentEnd.eq(controlPoint)) {
+			// Position the control point closer to the first -- the connecting
+			// segment will be roughly a line.
+			controlPoint = segmentStart.plus(enteringVec.times(startEndDist / 4));
+		}
+
+		console.assert(!segmentStart.eq(controlPoint, 1e-11), 'Start and control points are equal!');
+		console.assert(!controlPoint.eq(segmentEnd, 1e-11), 'Control and end points are equal!');
+
+		const prevCurve = this.currentCurve;
+		this.currentCurve = new QuadraticBezier(segmentStart, controlPoint, segmentEnd);
+
+		if (isNaN(this.currentCurve.normal(0).magnitude())) {
+			console.error('NaN normal at 0. Curve:', this.currentCurve);
+			this.currentCurve = prevCurve;
+		}
+
+		// Should we start making a new curve? Check whether all buffer points are within
+		// ±strokeWidth of the curve.
+		const curveMatchesPoints = (curve: QuadraticBezier): boolean => {
+			const minFit = Math.min(Math.max(
+				Math.min(this.curveStartWidth, this.curveEndWidth) / 4,
+				this.minFitAllowed
+			), this.maxFitAllowed);
+
+			// The sum of distances greater than minFit must not exceed this:
+			const maxNonMatchingDistSum = minFit;
+
+			// Sum of distances greater than minFit.
+			let nonMatchingDistSum = 0;
+
+			for (const point of this.buffer) {
+				let dist = curve.approximateDistance(point);
+
+				if (dist > minFit) {
+					// Use the more accurate distance function
+					dist = curve.distance(point);
+
+					nonMatchingDistSum += Math.max(0, dist - minFit);
+					if (nonMatchingDistSum > maxNonMatchingDistSum) {
+						return false; // false: Curve doesn't match points well enough.
+					}
+				}
+			}
+			return true;
+		};
+
+		if (this.buffer.length > 3 && this.approxCurrentCurveLength() > this.curveStartWidth / 2) {
+			if (!curveMatchesPoints(this.currentCurve)) {
+				// Use a curve that better fits the points
+				this.currentCurve = prevCurve;
+				this.curveEndWidth = prevEndWidth;
+
+				// Reset the last point -- the current point was not added to the curve.
+				this.lastPoint = lastPoint;
+
+				this.finalizeCurrentCurve();
+				return;
+			}
+		}
+	}
+}
+
+export default StrokeSmoother;

package/src/components/util/describeComponentList.ts

@@ -0,0 +1,18 @@
+import AbstractComponent from '../AbstractComponent';
+import { ImageComponentLocalization } from '../localization';
+
+// Returns the description of all given elements, if identical, otherwise,
+// returns null.
+export default (localizationTable: ImageComponentLocalization, elems: AbstractComponent[]) => {
+	if (elems.length === 0) {
+		return null;
+	}
+
+	const description = elems[0].description(localizationTable);
+	for (const elem of elems) {
+		if (elem.description(localizationTable) !== description) {
+			return null;
+		}
+	}
+	return description;
+};

package/src/lib.ts

@@ -0,0 +1,69 @@
+/**
+ * The main entrypoint for the NPM package. Everything exported by this file
+ * is available through the [`js-draw` package](https://www.npmjs.com/package/js-draw).
+ *
+ * @example
+ * ```
+ * import { Editor, Vec3, Mat33 } from 'js-draw';
+ *
+ * // Apply js-draw CSS
+ * import 'js-draw/styles';
+ * // If your bundler doesn't support the above, try
+ * // import 'js-draw/bundledStyles';
+ *
+ * (async () => {
+ *   const editor = new Editor(document.body);
+ *   const toolbar = editor.addToolbar();
+ *   editor.getRootElement().style.height = '600px';
+ *
+ *   await editor.loadFromSVG(`
+ *       <svg viewBox="0 0 500 500" width="500" height="500" version="1.1" baseProfile="full" xmlns="http://www.w3.org/2000/svg">
+ *           <style id="js-draw-style-sheet">path{stroke-linecap:round;stroke-linejoin:round;}text{white-space:pre;}</style>
+ *           <path d="M500,500L500,0L0,0L0,500L500,500" fill="#423131bf" class="js-draw-image-background"></path>
+ *           <text style="transform: matrix(1, 0, 0, 1, 57, 192); font-family: serif; font-size: 32px; fill: rgb(204, 102, 51);">Testing...</text>
+ *       </svg>
+ *   `);
+ *
+ *   toolbar.addActionButton({
+ *      label: 'Save',
+ *      icon: editor.icons.makeSaveIcon(),
+ *   }, () => {
+ *       const saveData = editor.toSVG().outerHTML;
+ *
+ *       // Do something with saveData
+ *   });
+ * })();
+ * ```
+ *
+ * @see
+ * {@link Editor}
+ * {@link Editor.loadFromSVG}
+ * {@link HTMLToolbar.addActionButton }
+ *
+ * @packageDocumentation
+ */
+
+import Editor, { EditorSettings } from './Editor';
+export { default as EditorImage } from './EditorImage';
+export * from './types';
+export { default as getLocalizationTable, matchingLocalizationTable } from './localizations/getLocalizationTable';
+export * from './localization';
+
+export { default as Color4 } from './Color4';
+export { default as SVGLoader } from './SVGLoader';
+export { default as Viewport } from './Viewport';
+export * from './math/lib';
+export * from './components/lib';
+export * from './commands/lib';
+export * from './tools/lib';
+export * from './toolbar/lib';
+export * from './rendering/lib';
+export * from './testing/lib';
+export * from './shortcuts/lib';
+export { default as EventDispatcher } from './EventDispatcher';
+export { default as Pointer, PointerDevice } from './Pointer';
+export { default as HTMLToolbar } from './toolbar/HTMLToolbar';
+export { default as UndoRedoHistory } from './UndoRedoHistory';
+
+export { Editor, EditorSettings };
+export default Editor;

package/src/localization.ts

@@ -0,0 +1,34 @@
+import { CommandLocalization, defaultCommandLocalization } from './commands/localization';
+import { defaultComponentLocalization, ImageComponentLocalization } from './components/localization';
+import { defaultTextRendererLocalization, TextRendererLocalization } from './rendering/localization';
+import { defaultToolbarLocalization, ToolbarLocalization } from './toolbar/localization';
+import { defaultToolLocalization, ToolLocalization } from './tools/localization';
+
+
+export interface EditorLocalization extends ToolbarLocalization, ToolLocalization, CommandLocalization, ImageComponentLocalization, TextRendererLocalization {
+	accessibilityInputInstructions: string;
+	undoAnnouncement: (actionDescription: string)=> string;
+	redoAnnouncement: (actionDescription: string)=> string;
+	doneLoading: string;
+	loading: (percentage: number)=>string;
+	imageEditor: string;
+}
+
+export const defaultEditorLocalization: EditorLocalization = {
+	...defaultToolbarLocalization,
+	...defaultToolLocalization,
+	...defaultCommandLocalization,
+	...defaultComponentLocalization,
+	...defaultTextRendererLocalization,
+	accessibilityInputInstructions: [
+		'Press "t" to read the contents of the viewport as text.',
+		'Use the arrow keys to move the viewport, click and drag to draw strokes.',
+		'Press "w" to zoom in and "s" to zoom out.',
+	].join(' '),
+	loading: (percentage: number) => `Loading ${percentage}%...`,
+	imageEditor: 'Image Editor',
+	doneLoading: 'Done loading',
+
+	undoAnnouncement: (commandDescription: string) => `Undid ${commandDescription}`,
+	redoAnnouncement: (commandDescription: string) => `Redid ${commandDescription}`,
+};

package/src/localizations/de.ts

@@ -0,0 +1,146 @@
+import { defaultEditorLocalization, EditorLocalization } from '../localization';
+
+// German localization
+const localization: EditorLocalization = {
+	...defaultEditorLocalization,
+
+	pen: 'Stift',
+	eraser: 'Radierer',
+	select: 'Auswahl',
+	handTool: 'Verschieben',
+
+	zoom: 'Vergrößerung',
+
+	image: 'Bild',
+	inputAltText: 'Alt-Text: ',
+	chooseFile: 'Wähle Datei: ',
+	submit: 'Absenden',
+	cancel: 'Abbrechen',
+
+	resetView: 'Ansicht zurücksetzen',
+
+	thicknessLabel: 'Dicke: ',
+	colorLabel: 'Farbe: ',
+	fontLabel: 'Schriftart: ',
+	textSize: 'Größe: ',
+
+	resizeImageToSelection: 'Bildgröße an Auswahl anpassen',
+	deleteSelection: 'Auswahl löschen',
+	duplicateSelection: 'Auswahl duplizieren',
+
+	undo: 'Rückgängig',
+	redo: 'Wiederholen',
+
+	pickColorFromScreen: 'Farbe von Bildschirm auswählen',
+	clickToPickColorAnnouncement: 'Klicke auf den Bildschirm, um eine Farbe auszuwählen',
+	selectionToolKeyboardShortcuts: 'Auswahl-Werkzeug: Verwende die Pfeiltasten, um ausgewählte Elemente zu verschieben und ‚i‘ und ‚o‘, um ihre Größe zu ändern.',
+	touchPanning: 'Ansicht mit Touchscreen verschieben',
+	anyDevicePanning: 'Ansicht mit jedem Eingabegerät verschieben',
+
+	selectPenType: 'Objekt-Typ: ',
+	freehandPen: 'Freihand',
+	pressureSensitiveFreehandPen: 'Stift (druckempfindlich)',
+	arrowPen: 'Pfeil',
+	linePen: 'Linie',
+	outlinedRectanglePen: 'Umrissenes Rechteck',
+	filledRectanglePen: 'Ausgefülltes Rechteck',
+
+	lockRotation: 'Sperre Rotation',
+	paste: 'Einfügen',
+
+	dropdownShown: (toolName) =>`Dropdown-Menü für ${toolName} angezeigt`,
+	dropdownHidden: (toolName) =>`Dropdown-Menü für ${toolName} versteckt`,
+	zoomLevel: (zoomPercent) =>`Vergößerung: ${zoomPercent}%`,
+	colorChangedAnnouncement: (color) =>`Farbe zu ${color} geändert`,
+
+	imageSize: (size, units) => `Bild-Größe: ${size} ${units}`,
+	imageLoadError: (message) => `Fehler beim Laden des Bildes: ${message}`,
+	errorImageHasZeroSize: 'Fehler: Bild hat Größe Null',
+
+	penTool: (penNumber) =>`Stift ${penNumber}`,
+
+	selectionTool: 'Auswahl',
+	eraserTool: 'Radiergummi',
+	touchPanTool: 'Ansicht mit Touchscreen verschieben',
+	twoFingerPanZoomTool: 'Ansicht verschieben und vergrößern',
+	undoRedoTool: 'Rückgängig/Wiederholen',
+	rightClickDragPanTool: 'Rechtsklick-Ziehen',
+	pipetteTool: 'Farbe von Bildschirm auswählen',
+	keyboardPanZoom: 'Tastaturkürzel zum Verschieben/Vergrößern der Ansicht',
+	textTool: 'Text',
+	enterTextToInsert: 'Einzufügender Text',
+	changeTool: 'Wechsle Werkzeug',
+	pasteHandler: 'Copy-Paste-Handler',
+	findLabel: 'Finde',
+	toNextMatch: 'Nächstes',
+	closeFindDialog: 'Schließen',
+	findDialogShown: 'Finde-Dialog angezeigt',
+	findDialogHidden: 'Finde-Dialog versteckt',
+	focusedFoundText: (matchIdx, totalMatches) => `Sieh Treffer ${matchIdx} von ${totalMatches} an`,
+
+	toolEnabledAnnouncement: (toolName) =>`${toolName} aktiviert`,
+	toolDisabledAnnouncement: (toolName) =>`${toolName} deaktiviert`,
+	updatedViewport: 'Transformierte Ansicht',
+	transformedElements: (elemCount) =>`${elemCount} Element${1 === elemCount ? '' : 'e'} transformiert`,
+	resizeOutputCommand: (newSize) =>`Bildgröße auf ${newSize.w}x${newSize.h} geändert`,
+	addElementAction: (componentDescription) =>`${componentDescription} hinzugefügt`,
+	eraseAction: (elemDescription, countErased)=>`${countErased} ${elemDescription} gelöscht`,
+	duplicateAction: (elemDescription, countErased)=>`${countErased} ${elemDescription} dupliziert`,
+	inverseOf: (actionDescription) =>`${actionDescription} umgekehrt`,
+
+	elements: 'Elemente',
+	erasedNoElements: 'Nichts entfernt',
+	duplicatedNoElements: 'Nichts dupliziert',
+	rotatedBy: (degrees) =>`${Math.abs(degrees)} Grad ${degrees < 0 ? 'im Uhrzeigersinn' : 'gegen den Uhrzeigersinn'} gedreht`,
+
+	movedLeft: 'Nacht links bewegt',
+	movedUp: 'Nacht oben bewegt',
+	movedDown: 'Nacht unten bewegt',
+	movedRight: 'Nacht rechts bewegt',
+	zoomedOut: 'Ansicht verkleinert',
+	zoomedIn: 'Ansicht vergrößert',
+
+	selectedElements: (count) =>`${count} Element${ 1 === count ? '' : 'e' } ausgewählt`,
+	stroke: 'Strich',
+	svgObject: 'SVG-Objekt',
+
+	text: (text) =>`Text-Objekt: ${text}`,
+	pathNodeCount: (count) =>`Es gibt ${count} sichtbare Pfad-Objekte.`,
+	textNodeCount: (count) =>`Es gibt ${count} sichtbare Text-Knotenpunkte.`,
+	textNode: (content) =>`Text: ${content}`,
+
+	imageNodeCount: (nodeCount) => `Es gibt ${nodeCount} sichtbare Bild-Knoten.`,
+	imageNode: label => `Bild: ${label}`,
+	unlabeledImageNode: 'Bild ohne Label',
+
+	rerenderAsText: 'Als Text darstellen',
+	accessibilityInputInstructions: 'Drücke ‚t‘, um den Inhalt des Ansichtsfensters als Text zu lesen. Verwende die Pfeiltasten, um die Ansicht zu verschieben, und klicke und ziehe, um Striche zu zeichnen. Drücke ‚w‘ zum Vergrößern und ‚s‘ zum Verkleinern der Ansicht.',
+
+	loading: percentage =>`Laden ${percentage}%...`,
+	doneLoading: 'Laden fertig',
+
+	imageEditor: 'Bild-Editor',
+	undoAnnouncement: (commandDescription) =>`${commandDescription} rückgängig gemacht`,
+	redoAnnouncement: (commandDescription) =>`${commandDescription} wiederholt`,
+	reformatSelection: 'Formatiere Auswahl',
+	documentProperties: 'Seite',
+	backgroundColor: 'Hintergrundfarbe: ',
+	imageWidthOption: 'Breite: ',
+	imageHeightOption: 'Höhe: ',
+	useGridOption: 'Gitter: ',
+	toggleOverflow: 'Mehr',
+	selectAllTool: 'Alle auswählen',
+	soundExplorer: 'Klangbasierte Bilderkundung',
+	disableAccessibilityExploreTool: 'Deaktiviere klangbasierte Erkundung',
+	enableAccessibilityExploreTool: 'Aktiviere klangbasierte Erkundung',
+	copied: (count, description) => `${count} ${description} kopiert`,
+	pasted: (count, description) => `${count} ${description} eingefügt`,
+	unionOf: (actionDescription, actionCount) => `Vereinigung: ${actionCount} ${actionDescription}`,
+	emptyBackground: 'Leerer Hintergrund',
+	filledBackgroundWithColor: (color) => `Gefüllter Hintergrund (${color})`,
+	restyledElement: (elementDescription) => `${elementDescription} umgestaltet`,
+
+
+};
+
+export default localization;

package/src/localizations/en.ts

@@ -0,0 +1,8 @@
+import { defaultEditorLocalization, EditorLocalization } from '../localization';
+
+// Default localizations are already in English.
+const localization: EditorLocalization = {
+	...defaultEditorLocalization,
+};
+
+export default localization;

package/src/localizations/es.ts

@@ -0,0 +1,74 @@
+import { defaultEditorLocalization, EditorLocalization } from '../localization';
+
+// A partial Spanish localization.
+const localization: EditorLocalization = {
+	...defaultEditorLocalization,
+
+	// Strings for the main editor interface
+	// (see src/localization.ts)
+	loading: (percentage: number) => `Cargando: ${percentage}%...`,
+	imageEditor: 'Editor de dibujos',
+
+	undoAnnouncement: (commandDescription: string) => `${commandDescription} fue deshecho`,
+	redoAnnouncement: (commandDescription: string) => `${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',
+	selectPenType: '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: string): string {
+		return `Menú por ${toolName} es visible`;
+	},
+	dropdownHidden: function (toolName: string): string {
+		return `Menú por ${toolName} fue ocultado`;
+	},
+	colorChangedAnnouncement: function (color: string): string {
+		return `Color fue cambiado a ${color}`;
+	},
+	keyboardPanZoom: 'Mover la pantalla con el teclado',
+	penTool: function (penId: number): string {
+		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: number, units: string) => `Tamaño del imagen: ${size} ${units}`,
+	imageLoadError: (message: string)=> `Error cargando imagen: ${message}`,
+	toggleOverflow: 'Más',
+
+	documentProperties: 'Fondo',
+	imageWidthOption: 'Ancho: ',
+	imageHeightOption: 'Alto: ',
+	backgroundColor: 'Color de fondo: '
+};
+
+export default localization;

package/src/localizations/getLocalizationTable.test.ts

@@ -0,0 +1,27 @@
+
+import { defaultEditorLocalization } from '../localization';
+import en from './en';
+import es from './es';
+import getLocalizationTable from './getLocalizationTable';
+
+describe('getLocalizationTable', () => {
+	it('should return the en localization for es_TEST', () => {
+		expect(getLocalizationTable([ 'es_TEST' ]) === es).toBe(true);
+	});
+
+	it('should return the default localization for unsupported language', () => {
+		expect(getLocalizationTable([ 'test' ]) === defaultEditorLocalization).toBe(true);
+	});
+
+	it('should return the first localization matching a language in the list of user locales', () => {
+		expect(getLocalizationTable([ 'test_TEST1', 'test_TEST2', 'test_TEST3', 'en_TEST', 'notalanguage']) === en).toBe(true);
+	});
+
+	it('should return the default localization for unsupported language', () => {
+		expect(getLocalizationTable([ 'test' ]) === defaultEditorLocalization).toBe(true);
+	});
+
+	it('should return first of user\'s supported languages', () => {
+		expect(getLocalizationTable([ 'es_MX', 'es_ES', 'en_US' ]) === es).toBe(true);
+	});
+});