commit toward svgcanvas/svgedit isolation

src/svgcanvas/coords.js

@@ -7,11 +7,11 @@
 
 import {
   snapToGrid, assignAttributes, getBBox, getRefElem, findDefs
-} from '../common/utilities.js';
+} from './utilities.js';
 import {
   transformPoint, transformListToTransform, matrixMultiply, transformBox
-} from '../common/math.js';
-import {getTransformList} from '../common/svgtransformlist.js';
+} from './math.js';
+import {getTransformList} from './svgtransformlist.js';
 
 const $ = jQuery;
 

src/svgcanvas/copy-elem.js

@@ -3,7 +3,7 @@
 import jQueryPluginSVG from '../common/jQuery.attr.js'; // Needed for SVG attribute setting and array form with `attr`
 import {isWebkit} from '../common/browser.js';
 import {convertPath} from './path.js';
-import {preventClickDefault} from '../common/utilities.js';
+import {preventClickDefault} from './utilities.js';
 
 // Constants
 const $ = jQueryPluginSVG(jQuery);

src/svgcanvas/draw.js

@@ -13,7 +13,7 @@ import {NS} from '../common/namespaces.js';
 import {isOpera} from '../common/browser.js';
 import {
   toXml, getElem
-} from '../common/utilities.js';
+} from './utilities.js';
 import {
   copyElem as utilCopyElem
 } from './copy-elem.js';

src/svgcanvas/elem-get-set.js

@@ -11,7 +11,7 @@ import {NS} from '../common/namespaces.js';
 import {
   getVisibleElements, getStrokedBBoxDefaultVisible, findDefs,
   walkTree, isNullish, getHref, setHref, getElem
-} from '../common/utilities.js';
+} from './utilities.js';
 import {
   convertToNum
 } from '../common/units.js';

src/svgcanvas/event.js

@@ -9,16 +9,16 @@ import jQueryPluginSVG from '../common/jQuery.attr.js'; // Needed for SVG attrib
 import {
   assignAttributes, cleanupElement, getElem, getRotationAngle, snapToGrid, walkTree,
   getBBox as utilsGetBBox, isNullish, preventClickDefault, setHref
-} from '../common/utilities.js';
+} from './utilities.js';
 import {
   convertAttrs
 } from '../common/units.js';
 import {
   transformPoint, hasMatrixTransform, getMatrix, snapToAngle
-} from '../common/math.js';
+} from './math.js';
 import {
   getTransformList
-} from '../common/svgtransformlist.js';
+} from './svgtransformlist.js';
 import {
   supportsNonScalingStroke, isWebkit
 } from '../common/browser.js';

src/svgcanvas/history.js

@@ -6,8 +6,8 @@
  * @copyright 2010 Jeff Schiller
  */
 
-import {getHref, setHref, getRotationAngle, isNullish} from '../common/utilities.js';
-import {removeElementFromListMap} from '../common/svgtransformlist.js';
+import {getHref, setHref, getRotationAngle, isNullish} from './utilities.js';
+import {removeElementFromListMap} from './svgtransformlist.js';
 
 /**
 * Group: Undo/Redo history management.

src/svgcanvas/json.js

@@ -5,7 +5,7 @@
  *
  * @copyright 2010 Alexis Deveria, 2010 Jeff Schiller
  */
-import {getElem, assignAttributes, cleanupElement} from '../common/utilities.js';
+import {getElem, assignAttributes, cleanupElement} from './utilities.js';
 import {NS} from '../common/namespaces.js';
 
 let jsonContext_ = null;

src/svgcanvas/layer.js

@@ -8,7 +8,7 @@
  */
 
 import {NS} from '../common/namespaces.js';
-import {toXml, walkTree, isNullish} from '../common/utilities.js';
+import {toXml, walkTree, isNullish} from './utilities.js';
 
 const $ = jQuery;
 

src/svgcanvas/math.js

@@ -0,0 +1,222 @@
+/**
+ * Mathematical utilities.
+ * @module math
+ * @license MIT
+ *
+ * @copyright 2010 Alexis Deveria, 2010 Jeff Schiller
+ */
+
+/**
+* @typedef {PlainObject} module:math.AngleCoord45
+* @property {Float} x - The angle-snapped x value
+* @property {Float} y - The angle-snapped y value
+* @property {Integer} a - The angle at which to snap
+*/
+
+/**
+* @typedef {PlainObject} module:math.XYObject
+* @property {Float} x
+* @property {Float} y
+*/
+
+import {NS} from '../common/namespaces.js';
+import {getTransformList} from './svgtransformlist.js';
+
+// Constants
+const NEAR_ZERO = 1e-14;
+
+// Throw away SVGSVGElement used for creating matrices/transforms.
+const svg = document.createElementNS(NS.SVG, 'svg');
+
+/**
+ * A (hopefully) quicker function to transform a point by a matrix
+ * (this function avoids any DOM calls and just does the math).
+ * @function module:math.transformPoint
+ * @param {Float} x - Float representing the x coordinate
+ * @param {Float} y - Float representing the y coordinate
+ * @param {SVGMatrix} m - Matrix object to transform the point with
+ * @returns {module:math.XYObject} An x, y object representing the transformed point
+*/
+export const transformPoint = function (x, y, m) {
+  return {x: m.a * x + m.c * y + m.e, y: m.b * x + m.d * y + m.f};
+};
+
+/**
+ * Helper function to check if the matrix performs no actual transform
+ * (i.e. exists for identity purposes).
+ * @function module:math.isIdentity
+ * @param {SVGMatrix} m - The matrix object to check
+ * @returns {boolean} Indicates whether or not the matrix is 1,0,0,1,0,0
+*/
+export const isIdentity = function (m) {
+  return (m.a === 1 && m.b === 0 && m.c === 0 && m.d === 1 && m.e === 0 && m.f === 0);
+};
+
+/**
+ * This function tries to return a `SVGMatrix` that is the multiplication `m1 * m2`.
+ * We also round to zero when it's near zero.
+ * @function module:math.matrixMultiply
+ * @param {...SVGMatrix} args - Matrix objects to multiply
+ * @returns {SVGMatrix} The matrix object resulting from the calculation
+*/
+export const matrixMultiply = function (...args) {
+  const m = args.reduceRight((prev, m1) => {
+    return m1.multiply(prev);
+  });
+
+  if (Math.abs(m.a) < NEAR_ZERO) { m.a = 0; }
+  if (Math.abs(m.b) < NEAR_ZERO) { m.b = 0; }
+  if (Math.abs(m.c) < NEAR_ZERO) { m.c = 0; }
+  if (Math.abs(m.d) < NEAR_ZERO) { m.d = 0; }
+  if (Math.abs(m.e) < NEAR_ZERO) { m.e = 0; }
+  if (Math.abs(m.f) < NEAR_ZERO) { m.f = 0; }
+
+  return m;
+};
+
+/**
+ * See if the given transformlist includes a non-indentity matrix transform.
+ * @function module:math.hasMatrixTransform
+ * @param {SVGTransformList} [tlist] - The transformlist to check
+ * @returns {boolean} Whether or not a matrix transform was found
+*/
+export const hasMatrixTransform = function (tlist) {
+  if (!tlist) { return false; }
+  let num = tlist.numberOfItems;
+  while (num--) {
+    const xform = tlist.getItem(num);
+    if (xform.type === 1 && !isIdentity(xform.matrix)) { return true; }
+  }
+  return false;
+};
+
+/**
+* @typedef {PlainObject} module:math.TransformedBox An object with the following values
+* @property {module:math.XYObject} tl - The top left coordinate
+* @property {module:math.XYObject} tr - The top right coordinate
+* @property {module:math.XYObject} bl - The bottom left coordinate
+* @property {module:math.XYObject} br - The bottom right coordinate
+* @property {PlainObject} aabox - Object with the following values:
+* @property {Float} aabox.x - Float with the axis-aligned x coordinate
+* @property {Float} aabox.y - Float with the axis-aligned y coordinate
+* @property {Float} aabox.width - Float with the axis-aligned width coordinate
+* @property {Float} aabox.height - Float with the axis-aligned height coordinate
+*/
+
+/**
+ * Transforms a rectangle based on the given matrix.
+ * @function module:math.transformBox
+ * @param {Float} l - Float with the box's left coordinate
+ * @param {Float} t - Float with the box's top coordinate
+ * @param {Float} w - Float with the box width
+ * @param {Float} h - Float with the box height
+ * @param {SVGMatrix} m - Matrix object to transform the box by
+ * @returns {module:math.TransformedBox}
+*/
+export const transformBox = function (l, t, w, h, m) {
+  const tl = transformPoint(l, t, m),
+    tr = transformPoint((l + w), t, m),
+    bl = transformPoint(l, (t + h), m),
+    br = transformPoint((l + w), (t + h), m),
+
+    minx = Math.min(tl.x, tr.x, bl.x, br.x),
+    maxx = Math.max(tl.x, tr.x, bl.x, br.x),
+    miny = Math.min(tl.y, tr.y, bl.y, br.y),
+    maxy = Math.max(tl.y, tr.y, bl.y, br.y);
+
+  return {
+    tl,
+    tr,
+    bl,
+    br,
+    aabox: {
+      x: minx,
+      y: miny,
+      width: (maxx - minx),
+      height: (maxy - miny)
+    }
+  };
+};
+
+/**
+ * This returns a single matrix Transform for a given Transform List
+ * (this is the equivalent of `SVGTransformList.consolidate()` but unlike
+ * that method, this one does not modify the actual `SVGTransformList`).
+ * This function is very liberal with its `min`, `max` arguments.
+ * @function module:math.transformListToTransform
+ * @param {SVGTransformList} tlist - The transformlist object
+ * @param {Integer} [min=0] - Optional integer indicating start transform position
+ * @param {Integer} [max] - Optional integer indicating end transform position;
+ *   defaults to one less than the tlist's `numberOfItems`
+ * @returns {SVGTransform} A single matrix transform object
+*/
+export const transformListToTransform = function (tlist, min, max) {
+  if (!tlist) {
+    // Or should tlist = null have been prevented before this?
+    return svg.createSVGTransformFromMatrix(svg.createSVGMatrix());
+  }
+  min = min || 0;
+  max = max || (tlist.numberOfItems - 1);
+  min = Number.parseInt(min);
+  max = Number.parseInt(max);
+  if (min > max) { const temp = max; max = min; min = temp; }
+  let m = svg.createSVGMatrix();
+  for (let i = min; i <= max; ++i) {
+    // if our indices are out of range, just use a harmless identity matrix
+    const mtom = (i >= 0 && i < tlist.numberOfItems
+      ? tlist.getItem(i).matrix
+      : svg.createSVGMatrix());
+    m = matrixMultiply(m, mtom);
+  }
+  return svg.createSVGTransformFromMatrix(m);
+};
+
+/**
+ * Get the matrix object for a given element.
+ * @function module:math.getMatrix
+ * @param {Element} elem - The DOM element to check
+ * @returns {SVGMatrix} The matrix object associated with the element's transformlist
+*/
+export const getMatrix = function (elem) {
+  const tlist = getTransformList(elem);
+  return transformListToTransform(tlist).matrix;
+};
+
+/**
+ * Returns a 45 degree angle coordinate associated with the two given
+ * coordinates.
+ * @function module:math.snapToAngle
+ * @param {Integer} x1 - First coordinate's x value
+ * @param {Integer} y1 - First coordinate's y value
+ * @param {Integer} x2 - Second coordinate's x value
+ * @param {Integer} y2 - Second coordinate's y value
+ * @returns {module:math.AngleCoord45}
+*/
+export const snapToAngle = function (x1, y1, x2, y2) {
+  const snap = Math.PI / 4; // 45 degrees
+  const dx = x2 - x1;
+  const dy = y2 - y1;
+  const angle = Math.atan2(dy, dx);
+  const dist = Math.sqrt(dx * dx + dy * dy);
+  const snapangle = Math.round(angle / snap) * snap;
+
+  return {
+    x: x1 + dist * Math.cos(snapangle),
+    y: y1 + dist * Math.sin(snapangle),
+    a: snapangle
+  };
+};
+
+/**
+ * Check if two rectangles (BBoxes objects) intersect each other.
+ * @function module:math.rectsIntersect
+ * @param {SVGRect} r1 - The first BBox-like object
+ * @param {SVGRect} r2 - The second BBox-like object
+ * @returns {boolean} True if rectangles intersect
+ */
+export const rectsIntersect = function (r1, r2) {
+  return r2.x < (r1.x + r1.width) &&
+    (r2.x + r2.width) > r1.x &&
+    r2.y < (r1.y + r1.height) &&
+    (r2.y + r2.height) > r1.y;
+};

src/svgcanvas/paste-elem.js

@@ -3,7 +3,7 @@
 import jQueryPluginSVG from '../common/jQuery.attr.js'; // Needed for SVG attribute setting and array form with `attr`
 import {
   getStrokedBBoxDefaultVisible
-} from '../common/utilities.js';
+} from './utilities.js';
 import * as hstry from './history.js';
 // Constants
 const $ = jQueryPluginSVG(jQuery);

src/svgcanvas/path-actions.js

@@ -9,16 +9,16 @@
 
 import {NS} from '../common/namespaces.js';
 import {shortFloat} from '../common/units.js';
-import {getTransformList} from '../common/svgtransformlist.js';
+import {getTransformList} from './svgtransformlist.js';
 import {ChangeElementCommand, BatchCommand} from './history.js';
 import {
   transformPoint, snapToAngle, rectsIntersect,
   transformListToTransform
-} from '../common/math.js';
+} from './math.js';
 import {
   assignAttributes, getElem, getRotationAngle, snapToGrid, isNullish,
   getBBox as utilsGetBBox
-} from '../common/utilities.js';
+} from './utilities.js';
 import {
   isWebkit
 } from '../common/browser.js';

src/svgcanvas/path-method.js

@@ -11,11 +11,11 @@ import {NS} from '../common/namespaces.js';
 import {ChangeElementCommand} from './history.js';
 import {
   transformPoint, getMatrix
-} from '../common/math.js';
+} from './math.js';
 import {
   assignAttributes, getRotationAngle, isNullish,
   getElem
-} from '../common/utilities.js';
+} from './utilities.js';
 import {
   supportsPathInsertItemBefore, supportsPathReplaceItem, isWebkit
 } from '../common/browser.js';

src/svgcanvas/path.js

@@ -7,14 +7,14 @@
  * @copyright 2011 Alexis Deveria, 2011 Jeff Schiller
  */
 
-import {getTransformList} from '../common/svgtransformlist.js';
+import {getTransformList} from './svgtransformlist.js';
 import {shortFloat} from '../common/units.js';
-import {transformPoint} from '../common/math.js';
+import {transformPoint} from './math.js';
 import {
   getRotationAngle, getBBox,
   getRefElem, findDefs, isNullish,
   getBBox as utilsGetBBox
-} from '../common/utilities.js';
+} from './utilities.js';
 import {
   init as pathMethodInit, insertItemBeforeMethod, ptObjToArrMethod, getGripPtMethod,
   getPointFromGripMethod, addPointGripMethod, getGripContainerMethod, addCtrlGripMethod,

src/svgcanvas/recalculate.js

@@ -9,14 +9,14 @@ import jQueryPluginSVG from '../common/jQuery.attr.js'; // Needed for SVG attrib
 import {NS} from '../common/namespaces.js';
 import {convertToNum} from '../common/units.js';
 import {isWebkit} from '../common/browser.js';
-import {getTransformList} from '../common/svgtransformlist.js';
-import {getRotationAngle, getHref, getBBox, getRefElem, isNullish} from '../common/utilities.js';
+import {getTransformList} from './svgtransformlist.js';
+import {getRotationAngle, getHref, getBBox, getRefElem, isNullish} from './utilities.js';
 import {BatchCommand, ChangeElementCommand} from './history.js';
 import {remapElement} from './coords.js';
 import {
   isIdentity, matrixMultiply, transformPoint, transformListToTransform,
   hasMatrixTransform
-} from '../common/math.js';
+} from './math.js';
 
 const $ = jQueryPluginSVG(jQuery);
 

src/svgcanvas/sanitize.js

@@ -8,7 +8,7 @@
 
 import {getReverseNS, NS} from '../common/namespaces.js';
 import {isGecko} from '../common/browser.js';
-import {getHref, setHref, getUrlFromAttr} from '../common/utilities.js';
+import {getHref, setHref, getUrlFromAttr} from './utilities.js';
 
 const REVERSE_NS = getReverseNS();
 

src/svgcanvas/select.js

@@ -8,9 +8,9 @@
  */
 
 import {isTouch, isWebkit} from '../common/browser.js'; // , isOpera
-import {getRotationAngle, getBBox, getStrokedBBox, isNullish} from '../common/utilities.js';
-import {transformListToTransform, transformBox, transformPoint} from '../common/math.js';
-import {getTransformList} from '../common/svgtransformlist.js';
+import {getRotationAngle, getBBox, getStrokedBBox, isNullish} from './utilities.js';
+import {transformListToTransform, transformBox, transformPoint} from './math.js';
+import {getTransformList} from './svgtransformlist.js';
 
 const $ = jQuery;
 

src/svgcanvas/selected-elem.js

@@ -13,13 +13,13 @@ import * as pathModule from './path.js';
 import {
   isNullish, getStrokedBBoxDefaultVisible, setHref, getElem, getHref, getVisibleElements,
   findDefs, getRotationAngle, getRefElem, getBBox as utilsGetBBox, walkTreePost, assignAttributes
-} from '../common/utilities.js';
+} from './utilities.js';
 import {
   transformPoint, matrixMultiply, transformListToTransform
-} from '../common/math.js';
+} from './math.js';
 import {
   getTransformList
-} from '../common/svgtransformlist.js';
+} from './svgtransformlist.js';
 import {
   recalculateDimensions
 } from './recalculate.js';

src/svgcanvas/selection.js

@@ -9,12 +9,12 @@
 import {NS} from '../common/namespaces.js';
 import {
   isNullish, getBBox as utilsGetBBox, getStrokedBBoxDefaultVisible
-} from '../common/utilities.js';
-import {transformPoint, transformListToTransform, rectsIntersect} from '../common/math.js';
+} from './utilities.js';
+import {transformPoint, transformListToTransform, rectsIntersect} from './math.js';
 import jQueryPluginSVG from '../common/jQuery.attr.js';
 import {
   getTransformList
-} from '../common/svgtransformlist.js';
+} from './svgtransformlist.js';
 import * as hstry from './history.js';
 
 const {BatchCommand} = hstry;

src/svgcanvas/svg-exec.js

@@ -14,11 +14,11 @@ import {
   text2xml, cleanupElement, findDefs, getHref, preventClickDefault,
   toXml, getStrokedBBoxDefaultVisible, encode64, createObjectURL,
   dataURLToObjectURL, walkTree, getBBox as utilsGetBBox
-} from '../common/utilities.js';
+} from './utilities.js';
 import {
   transformPoint, transformListToTransform
-} from '../common/math.js';
-import {resetListMap} from '../common/svgtransformlist.js';
+} from './math.js';
+import {resetListMap} from './svgtransformlist.js';
 import {
   convertUnit, shortFloat, convertToNum
 } from '../common/units.js';

src/svgcanvas/svgcanvas.js

@@ -78,12 +78,13 @@ import {
   findDefs, getHref, setHref, getRefElem, getRotationAngle, getPathBBox,
   preventClickDefault, walkTree, getBBoxOfElementAsPath, convertToPath, encode64, decode64,
   getVisibleElements, dropXMLInternalSubset, init as utilsInit,
-  getBBox as utilsGetBBox, getStrokedBBoxDefaultVisible, isNullish
-} from '../common/utilities.js';
+  getBBox as utilsGetBBox, getStrokedBBoxDefaultVisible, isNullish, blankPageObjectURL,
+  $id, $qa, $qq
+} from './utilities.js';
 import {
   transformPoint, matrixMultiply, hasMatrixTransform, transformListToTransform,
   isIdentity, transformBox
-} from '../common/math.js';
+} from './math.js';
 import {
   convertToNum, getTypeMap, init as unitsInit
 } from '../common/units.js';
@@ -97,7 +98,7 @@ import {
 } from '../common/browser.js'; // , supportsEditableText
 import {
   getTransformList, SVGTransformList as SVGEditTransformList
-} from '../common/svgtransformlist.js';
+} from './svgtransformlist.js';
 import {
   remapElement,
   init as coordsInit
@@ -2743,4 +2744,14 @@ class SvgCanvas {
   } // End constructor
 } // End class
 
+// attach utilities function to the class that are used by SvgEdit so
+// we can avoid using the whole utilities.js file in svgEdit.js
+SvgCanvas.isNullish = isNullish;
+SvgCanvas.encode64 = encode64;
+SvgCanvas.decode64 = decode64;
+SvgCanvas.$id = $id;
+SvgCanvas.$qq = $qq;
+SvgCanvas.$qa = $qa;
+SvgCanvas.blankPageObjectURL = blankPageObjectURL;
+
 export default SvgCanvas;

src/svgcanvas/svgroot.js

@@ -6,7 +6,7 @@
  * @copyright 2010 Alexis Deveria, 2010 Jeff Schiller
  */
 import {NS} from '../common/namespaces.js';
-import {text2xml} from '../common/utilities.js';
+import {text2xml} from './utilities.js';
 
 /**
 * @function module:svgcanvas.svgRootElement svgRootElement the svg node and its children.

src/svgcanvas/svgtransformlist.js

@@ -0,0 +1,393 @@
+/**
+ * Partial polyfill of `SVGTransformList`
+ * @module SVGTransformList
+ *
+ * @license MIT
+ *
+ * @copyright 2010 Alexis Deveria, 2010 Jeff Schiller
+ */
+
+import {NS} from '../common/namespaces.js';
+import {supportsNativeTransformLists} from '../common/browser.js';
+
+const svgroot = document.createElementNS(NS.SVG, 'svg');
+
+/**
+ * Helper function to convert `SVGTransform` to a string.
+ * @param {SVGTransform} xform
+ * @returns {string}
+ */
+function transformToString (xform) {
+  const m = xform.matrix;
+  let text = '';
+  switch (xform.type) {
+  case 1: // MATRIX
+    text = 'matrix(' + [m.a, m.b, m.c, m.d, m.e, m.f].join(',') + ')';
+    break;
+  case 2: // TRANSLATE
+    text = 'translate(' + m.e + ',' + m.f + ')';
+    break;
+  case 3: // SCALE
+    text = (m.a === m.d) ? `scale(${m.a})` : `scale(${m.a},${m.d})`;
+    break;
+  case 4: { // ROTATE
+    let cx = 0;
+    let cy = 0;
+    // this prevents divide by zero
+    if (xform.angle !== 0) {
+      const K = 1 - m.a;
+      cy = (K * m.f + m.b * m.e) / (K * K + m.b * m.b);
+      cx = (m.e - m.b * cy) / K;
+    }
+    text = 'rotate(' + xform.angle + ' ' + cx + ',' + cy + ')';
+    break;
+  }
+  }
+  return text;
+}
+
+/**
+ * Map of SVGTransformList objects.
+ */
+let listMap_ = {};
+
+/**
+* @interface module:SVGTransformList.SVGEditTransformList
+* @property {Integer} numberOfItems unsigned long
+*/
+/**
+* @function module:SVGTransformList.SVGEditTransformList#clear
+* @returns {void}
+*/
+/**
+* @function module:SVGTransformList.SVGEditTransformList#initialize
+* @param {SVGTransform} newItem
+* @returns {SVGTransform}
+*/
+/**
+* DOES NOT THROW DOMException, INDEX_SIZE_ERR.
+* @function module:SVGTransformList.SVGEditTransformList#getItem
+* @param {Integer} index unsigned long
+* @returns {SVGTransform}
+*/
+/**
+* DOES NOT THROW DOMException, INDEX_SIZE_ERR.
+* @function module:SVGTransformList.SVGEditTransformList#insertItemBefore
+* @param {SVGTransform} newItem
+* @param {Integer} index unsigned long
+* @returns {SVGTransform}
+*/
+/**
+* DOES NOT THROW DOMException, INDEX_SIZE_ERR.
+* @function module:SVGTransformList.SVGEditTransformList#replaceItem
+* @param {SVGTransform} newItem
+* @param {Integer} index unsigned long
+* @returns {SVGTransform}
+*/
+/**
+* DOES NOT THROW DOMException, INDEX_SIZE_ERR.
+* @function module:SVGTransformList.SVGEditTransformList#removeItem
+* @param {Integer} index unsigned long
+* @returns {SVGTransform}
+*/
+/**
+* @function module:SVGTransformList.SVGEditTransformList#appendItem
+* @param {SVGTransform} newItem
+* @returns {SVGTransform}
+*/
+/**
+* NOT IMPLEMENTED.
+* @ignore
+* @function module:SVGTransformList.SVGEditTransformList#createSVGTransformFromMatrix
+* @param {SVGMatrix} matrix
+* @returns {SVGTransform}
+*/
+/**
+* NOT IMPLEMENTED.
+* @ignore
+* @function module:SVGTransformList.SVGEditTransformList#consolidate
+* @returns {SVGTransform}
+*/
+
+/**
+* SVGTransformList implementation for Webkit.
+* These methods do not currently raise any exceptions.
+* These methods also do not check that transforms are being inserted.  This is basically
+* implementing as much of SVGTransformList that we need to get the job done.
+* @implements {module:SVGTransformList.SVGEditTransformList}
+*/
+export class SVGTransformList { // eslint-disable-line no-shadow
+  /**
+  * @param {Element} elem
+  * @returns {SVGTransformList}
+  */
+  constructor (elem) {
+    this._elem = elem || null;
+    this._xforms = [];
+    // TODO: how do we capture the undo-ability in the changed transform list?
+    this._update = function () {
+      let tstr = '';
+      // /* const concatMatrix = */ svgroot.createSVGMatrix();
+      for (let i = 0; i < this.numberOfItems; ++i) {
+        const xform = this._list.getItem(i);
+        tstr += transformToString(xform) + ' ';
+      }
+      this._elem.setAttribute('transform', tstr);
+    };
+    this._list = this;
+    this._init = function () {
+      // Transform attribute parser
+      let str = this._elem.getAttribute('transform');
+      if (!str) { return; }
+
+      // TODO: Add skew support in future
+      const re = /\s*((scale|matrix|rotate|translate)\s*\(.*?\))\s*,?\s*/;
+      // const re = /\s*(?<xform>(?:scale|matrix|rotate|translate)\s*\(.*?\))\s*,?\s*/;
+      let m = true;
+      while (m) {
+        m = str.match(re);
+        str = str.replace(re, '');
+        if (m && m[1]) {
+          const x = m[1];
+          const bits = x.split(/\s*\(/);
+          const name = bits[0];
+          const valBits = bits[1].match(/\s*(.*?)\s*\)/);
+          valBits[1] = valBits[1].replace(/(\d)-/g, '$1 -');
+          const valArr = valBits[1].split(/[, ]+/);
+          const letters = 'abcdef'.split('');
+          /*
+        if (m && m.groups.xform) {
+          const x = m.groups.xform;
+          const [name, bits] = x.split(/\s*\(/);
+          const valBits = bits.match(/\s*(?<nonWhitespace>.*?)\s*\)/);
+          valBits.groups.nonWhitespace = valBits.groups.nonWhitespace.replace(
+            /(?<digit>\d)-/g, '$<digit> -'
+          );
+          const valArr = valBits.groups.nonWhitespace.split(/[, ]+/);
+          const letters = [...'abcdef'];
+          */
+          const mtx = svgroot.createSVGMatrix();
+          Object.values(valArr).forEach(function (item, i) {
+            valArr[i] = Number.parseFloat(item);
+            if (name === 'matrix') {
+              mtx[letters[i]] = valArr[i];
+            }
+          });
+          const xform = svgroot.createSVGTransform();
+          const fname = 'set' + name.charAt(0).toUpperCase() + name.slice(1);
+          const values = name === 'matrix' ? [mtx] : valArr;
+
+          if (name === 'scale' && values.length === 1) {
+            values.push(values[0]);
+          } else if (name === 'translate' && values.length === 1) {
+            values.push(0);
+          } else if (name === 'rotate' && values.length === 1) {
+            values.push(0, 0);
+          }
+          xform[fname](...values);
+          this._list.appendItem(xform);
+        }
+      }
+    };
+    this._removeFromOtherLists = function (item) {
+      if (item) {
+        // Check if this transform is already in a transformlist, and
+        // remove it if so.
+        Object.values(listMap_).some((tl) => {
+          for (let i = 0, len = tl._xforms.length; i < len; ++i) {
+            if (tl._xforms[i] === item) {
+              tl.removeItem(i);
+              return true;
+            }
+          }
+          return false;
+        });
+      }
+    };
+
+    this.numberOfItems = 0;
+  }
+  /**
+  * @returns {void}
+  */
+  clear () {
+    this.numberOfItems = 0;
+    this._xforms = [];
+  }
+
+  /**
+  * @param {SVGTransform} newItem
+  * @returns {void}
+  */
+  initialize (newItem) {
+    this.numberOfItems = 1;
+    this._removeFromOtherLists(newItem);
+    this._xforms = [newItem];
+  }
+
+  /**
+  * @param {Integer} index unsigned long
+  * @throws {Error}
+  * @returns {SVGTransform}
+  */
+  getItem (index) {
+    if (index < this.numberOfItems && index >= 0) {
+      return this._xforms[index];
+    }
+    const err = new Error('DOMException with code=INDEX_SIZE_ERR');
+    err.code = 1;
+    throw err;
+  }
+
+  /**
+  * @param {SVGTransform} newItem
+  * @param {Integer} index unsigned long
+  * @returns {SVGTransform}
+  */
+  insertItemBefore (newItem, index) {
+    let retValue = null;
+    if (index >= 0) {
+      if (index < this.numberOfItems) {
+        this._removeFromOtherLists(newItem);
+        const newxforms = new Array(this.numberOfItems + 1);
+        // TODO: use array copying and slicing
+        let i;
+        for (i = 0; i < index; ++i) {
+          newxforms[i] = this._xforms[i];
+        }
+        newxforms[i] = newItem;
+        for (let j = i + 1; i < this.numberOfItems; ++j, ++i) {
+          newxforms[j] = this._xforms[i];
+        }
+        this.numberOfItems++;
+        this._xforms = newxforms;
+        retValue = newItem;
+        this._list._update();
+      } else {
+        retValue = this._list.appendItem(newItem);
+      }
+    }
+    return retValue;
+  }
+
+  /**
+  * @param {SVGTransform} newItem
+  * @param {Integer} index unsigned long
+  * @returns {SVGTransform}
+  */
+  replaceItem (newItem, index) {
+    let retValue = null;
+    if (index < this.numberOfItems && index >= 0) {
+      this._removeFromOtherLists(newItem);
+      this._xforms[index] = newItem;
+      retValue = newItem;
+      this._list._update();
+    }
+    return retValue;
+  }
+
+  /**
+  * @param {Integer} index unsigned long
+  * @throws {Error}
+  * @returns {SVGTransform}
+  */
+  removeItem (index) {
+    if (index < this.numberOfItems && index >= 0) {
+      const retValue = this._xforms[index];
+      const newxforms = new Array(this.numberOfItems - 1);
+      let i;
+      for (i = 0; i < index; ++i) {
+        newxforms[i] = this._xforms[i];
+      }
+      for (let j = i; j < this.numberOfItems - 1; ++j, ++i) {
+        newxforms[j] = this._xforms[i + 1];
+      }
+      this.numberOfItems--;
+      this._xforms = newxforms;
+      this._list._update();
+      return retValue;
+    }
+    const err = new Error('DOMException with code=INDEX_SIZE_ERR');
+    err.code = 1;
+    throw err;
+  }
+
+  /**
+  * @param {SVGTransform} newItem
+  * @returns {SVGTransform}
+  */
+  appendItem (newItem) {
+    this._removeFromOtherLists(newItem);
+    this._xforms.push(newItem);
+    this.numberOfItems++;
+    this._list._update();
+    return newItem;
+  }
+}
+
+/**
+* @function module:SVGTransformList.resetListMap
+* @returns {void}
+*/
+export const resetListMap = function () {
+  listMap_ = {};
+};
+
+/**
+ * Removes transforms of the given element from the map.
+ * @function module:SVGTransformList.removeElementFromListMap
+ * @param {Element} elem - a DOM Element
+ * @returns {void}
+ */
+export let removeElementFromListMap = function (elem) { // eslint-disable-line import/no-mutable-exports
+  if (elem.id && listMap_[elem.id]) {
+    delete listMap_[elem.id];
+  }
+};
+
+/**
+* Returns an object that behaves like a `SVGTransformList` for the given DOM element.
+* @function module:SVGTransformList.getTransformList
+* @param {Element} elem - DOM element to get a transformlist from
+* @todo The polyfill should have `SVGAnimatedTransformList` and this should use it
+* @returns {SVGAnimatedTransformList|SVGTransformList}
+*/
+export const getTransformList = function (elem) {
+  if (!supportsNativeTransformLists()) {
+    const id = elem.id || 'temp';
+    let t = listMap_[id];
+    if (!t || id === 'temp') {
+      listMap_[id] = new SVGTransformList(elem);
+      listMap_[id]._init();
+      t = listMap_[id];
+    }
+    return t;
+  }
+  if (elem.transform) {
+    return elem.transform.baseVal;
+  }
+  if (elem.gradientTransform) {
+    return elem.gradientTransform.baseVal;
+  }
+  if (elem.patternTransform) {
+    return elem.patternTransform.baseVal;
+  }
+
+  return null;
+};
+
+/**
+* @callback module:SVGTransformList.removeElementFromListMap
+* @param {Element} elem
+* @returns {void}
+*/
+/**
+* Replace `removeElementFromListMap` for unit-testing.
+* @function module:SVGTransformList.changeRemoveElementFromListMap
+* @param {module:SVGTransformList.removeElementFromListMap} cb Passed a single argument `elem`
+* @returns {void}
+*/
+
+export const changeRemoveElementFromListMap = function (cb) { // eslint-disable-line promise/prefer-await-to-callbacks
+  removeElementFromListMap = cb;
+};

src/svgcanvas/text-actions.js

@@ -10,10 +10,10 @@ import jQueryPluginSVG from '../common/jQuery.attr.js';
 import {NS} from '../common/namespaces.js';
 import {
   transformPoint, getMatrix
-} from '../common/math.js';
+} from './math.js';
 import {
   assignAttributes, getElem, getBBox as utilsGetBBox
-} from '../common/utilities.js';
+} from './utilities.js';
 import {
   supportsGoodTextCharPos
 } from '../common/browser.js';

src/svgcanvas/undo.js

@@ -8,16 +8,16 @@ import * as draw from './draw.js';
 import * as hstry from './history.js';
 import {
   getRotationAngle, getBBox as utilsGetBBox, isNullish, setHref, getStrokedBBoxDefaultVisible
-} from '../common/utilities.js';
+} from './utilities.js';
 import {
   isGecko
 } from '../common/browser.js';
 import {
   transformPoint, transformListToTransform
-} from '../common/math.js';
+} from './math.js';
 import {
   getTransformList
-} from '../common/svgtransformlist.js';
+} from './svgtransformlist.js';
 
 const {
   UndoManager, HistoryEventTypes