path2d-polyfill 1.2.2 → 2.0.0-beta.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.esm.js DELETED
@@ -1,652 +0,0 @@
1
- var ARG_LENGTH = {
2
- a: 7,
3
- c: 6,
4
- h: 1,
5
- l: 2,
6
- m: 2,
7
- q: 4,
8
- s: 4,
9
- t: 2,
10
- v: 1,
11
- z: 0
12
- };
13
- var SEGMENT_PATTERN = /([astvzqmhlc])([^astvzqmhlc]*)/gi;
14
- var NUMBER = /-?[0-9]*\.?[0-9]+(?:e[-+]?\d+)?/gi;
15
-
16
- function parseValues(args) {
17
- var numbers = args.match(NUMBER);
18
- return numbers ? numbers.map(Number) : [];
19
- }
20
- /**
21
- * parse an svg path data string. Generates an Array
22
- * of commands where each command is an Array of the
23
- * form `[command, arg1, arg2, ...]`
24
- *
25
- * https://www.w3.org/TR/SVG/paths.html#PathDataGeneralInformation
26
- * @ignore
27
- *
28
- * @param {string} path
29
- * @returns {array}
30
- */
31
-
32
-
33
- function parse(path) {
34
- var data = [];
35
- var p = String(path).trim(); // A path data segment (if there is one) must begin with a "moveto" command
36
-
37
- if (p[0] !== "M" && p[0] !== "m") {
38
- return data;
39
- }
40
-
41
- p.replace(SEGMENT_PATTERN, function (_, command, args) {
42
- var type = command.toLowerCase();
43
- var theArgs = parseValues(args);
44
- var theCommand = command; // overloaded moveTo
45
-
46
- if (type === "m" && theArgs.length > 2) {
47
- data.push([theCommand].concat(theArgs.splice(0, 2)));
48
- type = "l";
49
- theCommand = theCommand === "m" ? "l" : "L";
50
- } // Ignore invalid commands
51
-
52
-
53
- if (theArgs.length < ARG_LENGTH[type]) {
54
- return "";
55
- }
56
-
57
- data.push([theCommand].concat(theArgs.splice(0, ARG_LENGTH[type]))); // The command letter can be eliminated on subsequent commands if the
58
- // same command is used multiple times in a row (e.g., you can drop the
59
- // second "L" in "M 100 200 L 200 100 L -100 -200" and use
60
- // "M 100 200 L 200 100 -100 -200" instead).
61
-
62
- while (theArgs.length >= ARG_LENGTH[type] && theArgs.length && ARG_LENGTH[type]) {
63
- data.push([theCommand].concat(theArgs.splice(0, ARG_LENGTH[type])));
64
- }
65
-
66
- return "";
67
- });
68
- return data;
69
- }
70
-
71
- var parsePath$2 = parse;
72
-
73
- function _classCallCheck(instance, Constructor) {
74
- if (!(instance instanceof Constructor)) {
75
- throw new TypeError("Cannot call a class as a function");
76
- }
77
- }
78
-
79
- function _defineProperties(target, props) {
80
- for (var i = 0; i < props.length; i++) {
81
- var descriptor = props[i];
82
- descriptor.enumerable = descriptor.enumerable || false;
83
- descriptor.configurable = true;
84
- if ("value" in descriptor) descriptor.writable = true;
85
- Object.defineProperty(target, descriptor.key, descriptor);
86
- }
87
- }
88
-
89
- function _createClass(Constructor, protoProps, staticProps) {
90
- if (protoProps) _defineProperties(Constructor.prototype, protoProps);
91
- if (staticProps) _defineProperties(Constructor, staticProps);
92
- Object.defineProperty(Constructor, "prototype", {
93
- writable: false
94
- });
95
- return Constructor;
96
- }
97
-
98
- function _toConsumableArray(arr) {
99
- return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
100
- }
101
-
102
- function _arrayWithoutHoles(arr) {
103
- if (Array.isArray(arr)) return _arrayLikeToArray(arr);
104
- }
105
-
106
- function _iterableToArray(iter) {
107
- if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
108
- }
109
-
110
- function _unsupportedIterableToArray(o, minLen) {
111
- if (!o) return;
112
- if (typeof o === "string") return _arrayLikeToArray(o, minLen);
113
- var n = Object.prototype.toString.call(o).slice(8, -1);
114
- if (n === "Object" && o.constructor) n = o.constructor.name;
115
- if (n === "Map" || n === "Set") return Array.from(o);
116
- if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
117
- }
118
-
119
- function _arrayLikeToArray(arr, len) {
120
- if (len == null || len > arr.length) len = arr.length;
121
-
122
- for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
123
-
124
- return arr2;
125
- }
126
-
127
- function _nonIterableSpread() {
128
- throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
129
- }
130
-
131
- var parsePath$1 = parsePath$2;
132
- /**
133
- * Work around for https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/8438884/
134
- * @ignore
135
- */
136
-
137
- function supportsSvgPathArgument(window) {
138
- var canvas = window.document.createElement("canvas");
139
- var g = canvas.getContext("2d");
140
- var p = new window.Path2D("M0 0 L1 1");
141
- g.strokeStyle = "red";
142
- g.lineWidth = 1;
143
- g.stroke(p);
144
- var imgData = g.getImageData(0, 0, 1, 1);
145
- return imgData.data[0] === 255; // Check if pixel is red
146
- }
147
-
148
- function rotatePoint(point, angle) {
149
- var nx = point.x * Math.cos(angle) - point.y * Math.sin(angle);
150
- var ny = point.y * Math.cos(angle) + point.x * Math.sin(angle);
151
- point.x = nx;
152
- point.y = ny;
153
- }
154
-
155
- function translatePoint(point, dx, dy) {
156
- point.x += dx;
157
- point.y += dy;
158
- }
159
-
160
- function scalePoint(point, s) {
161
- point.x *= s;
162
- point.y *= s;
163
- }
164
-
165
- function polyFillPath2D(window) {
166
- if (typeof window === "undefined" || !window.CanvasRenderingContext2D) {
167
- return;
168
- }
169
-
170
- if (window.Path2D && supportsSvgPathArgument(window)) {
171
- return;
172
- }
173
- /**
174
- * Crates a Path2D polyfill object
175
- * @constructor
176
- * @ignore
177
- * @param {String} path
178
- */
179
-
180
-
181
- var Path2D = /*#__PURE__*/function () {
182
- function Path2D(path) {
183
- _classCallCheck(this, Path2D);
184
-
185
- this.segments = [];
186
-
187
- if (path && path instanceof Path2D) {
188
- var _this$segments;
189
-
190
- (_this$segments = this.segments).push.apply(_this$segments, _toConsumableArray(path.segments));
191
- } else if (path) {
192
- this.segments = parsePath$1(path);
193
- }
194
- }
195
-
196
- _createClass(Path2D, [{
197
- key: "addPath",
198
- value: function addPath(path) {
199
- if (path && path instanceof Path2D) {
200
- var _this$segments2;
201
-
202
- (_this$segments2 = this.segments).push.apply(_this$segments2, _toConsumableArray(path.segments));
203
- }
204
- }
205
- }, {
206
- key: "moveTo",
207
- value: function moveTo(x, y) {
208
- this.segments.push(["M", x, y]);
209
- }
210
- }, {
211
- key: "lineTo",
212
- value: function lineTo(x, y) {
213
- this.segments.push(["L", x, y]);
214
- }
215
- }, {
216
- key: "arc",
217
- value: function arc(x, y, r, start, end, ccw) {
218
- this.segments.push(["AC", x, y, r, start, end, !!ccw]);
219
- }
220
- }, {
221
- key: "arcTo",
222
- value: function arcTo(x1, y1, x2, y2, r) {
223
- this.segments.push(["AT", x1, y1, x2, y2, r]);
224
- }
225
- }, {
226
- key: "ellipse",
227
- value: function ellipse(x, y, rx, ry, angle, start, end, ccw) {
228
- this.segments.push(["E", x, y, rx, ry, angle, start, end, !!ccw]);
229
- }
230
- }, {
231
- key: "closePath",
232
- value: function closePath() {
233
- this.segments.push(["Z"]);
234
- }
235
- }, {
236
- key: "bezierCurveTo",
237
- value: function bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y) {
238
- this.segments.push(["C", cp1x, cp1y, cp2x, cp2y, x, y]);
239
- }
240
- }, {
241
- key: "quadraticCurveTo",
242
- value: function quadraticCurveTo(cpx, cpy, x, y) {
243
- this.segments.push(["Q", cpx, cpy, x, y]);
244
- }
245
- }, {
246
- key: "rect",
247
- value: function rect(x, y, width, height) {
248
- this.segments.push(["R", x, y, width, height]);
249
- }
250
- }]);
251
-
252
- return Path2D;
253
- }();
254
-
255
- function buildPath(canvas, segments) {
256
- var endAngle;
257
- var startAngle;
258
- var largeArcFlag;
259
- var sweepFlag;
260
- var endPoint;
261
- var midPoint;
262
- var angle;
263
- var lambda;
264
- var t1;
265
- var t2;
266
- var x;
267
- var x1;
268
- var y;
269
- var y1;
270
- var r;
271
- var rx;
272
- var ry;
273
- var w;
274
- var h;
275
- var pathType;
276
- var centerPoint;
277
- var cpx;
278
- var cpy;
279
- var qcpx;
280
- var qcpy;
281
- var ccw;
282
- var startPoint = {
283
- x: 0,
284
- y: 0
285
- };
286
- var currentPoint = {
287
- x: 0,
288
- y: 0
289
- };
290
- canvas.beginPath();
291
-
292
- for (var i = 0; i < segments.length; ++i) {
293
- var s = segments[i];
294
- pathType = s[0]; // Reset control point if command is not cubic
295
-
296
- if (pathType !== "S" && pathType !== "s" && pathType !== "C" && pathType !== "c") {
297
- cpx = null;
298
- cpy = null;
299
- }
300
-
301
- if (pathType !== "T" && pathType !== "t" && pathType !== "Q" && pathType !== "q") {
302
- qcpx = null;
303
- qcpy = null;
304
- }
305
-
306
- switch (pathType) {
307
- case "m":
308
- case "M":
309
- if (pathType === "m") {
310
- x += s[1];
311
- y += s[2];
312
- } else {
313
- x = s[1];
314
- y = s[2];
315
- }
316
-
317
- if (pathType === "M" || !startPoint) {
318
- startPoint = {
319
- x: x,
320
- y: y
321
- };
322
- }
323
-
324
- canvas.moveTo(x, y);
325
- break;
326
-
327
- case "l":
328
- x += s[1];
329
- y += s[2];
330
- canvas.lineTo(x, y);
331
- break;
332
-
333
- case "L":
334
- x = s[1];
335
- y = s[2];
336
- canvas.lineTo(x, y);
337
- break;
338
-
339
- case "H":
340
- x = s[1];
341
- canvas.lineTo(x, y);
342
- break;
343
-
344
- case "h":
345
- x += s[1];
346
- canvas.lineTo(x, y);
347
- break;
348
-
349
- case "V":
350
- y = s[1];
351
- canvas.lineTo(x, y);
352
- break;
353
-
354
- case "v":
355
- y += s[1];
356
- canvas.lineTo(x, y);
357
- break;
358
-
359
- case "a":
360
- case "A":
361
- if (pathType === "a") {
362
- x += s[6];
363
- y += s[7];
364
- } else {
365
- x = s[6];
366
- y = s[7];
367
- }
368
-
369
- rx = s[1]; // rx
370
-
371
- ry = s[2]; // ry
372
-
373
- angle = s[3] * Math.PI / 180;
374
- largeArcFlag = !!s[4];
375
- sweepFlag = !!s[5];
376
- endPoint = {
377
- x: x,
378
- y: y
379
- }; // https://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes
380
-
381
- midPoint = {
382
- x: (currentPoint.x - endPoint.x) / 2,
383
- y: (currentPoint.y - endPoint.y) / 2
384
- };
385
- rotatePoint(midPoint, -angle); // radius correction
386
-
387
- lambda = midPoint.x * midPoint.x / (rx * rx) + midPoint.y * midPoint.y / (ry * ry);
388
-
389
- if (lambda > 1) {
390
- lambda = Math.sqrt(lambda);
391
- rx *= lambda;
392
- ry *= lambda;
393
- }
394
-
395
- centerPoint = {
396
- x: rx * midPoint.y / ry,
397
- y: -(ry * midPoint.x) / rx
398
- };
399
- t1 = rx * rx * ry * ry;
400
- t2 = rx * rx * midPoint.y * midPoint.y + ry * ry * midPoint.x * midPoint.x;
401
-
402
- if (sweepFlag !== largeArcFlag) {
403
- scalePoint(centerPoint, Math.sqrt((t1 - t2) / t2) || 0);
404
- } else {
405
- scalePoint(centerPoint, -Math.sqrt((t1 - t2) / t2) || 0);
406
- }
407
-
408
- startAngle = Math.atan2((midPoint.y - centerPoint.y) / ry, (midPoint.x - centerPoint.x) / rx);
409
- endAngle = Math.atan2(-(midPoint.y + centerPoint.y) / ry, -(midPoint.x + centerPoint.x) / rx);
410
- rotatePoint(centerPoint, angle);
411
- translatePoint(centerPoint, (endPoint.x + currentPoint.x) / 2, (endPoint.y + currentPoint.y) / 2);
412
- canvas.save();
413
- canvas.translate(centerPoint.x, centerPoint.y);
414
- canvas.rotate(angle);
415
- canvas.scale(rx, ry);
416
- canvas.arc(0, 0, 1, startAngle, endAngle, !sweepFlag);
417
- canvas.restore();
418
- break;
419
-
420
- case "C":
421
- cpx = s[3]; // Last control point
422
-
423
- cpy = s[4];
424
- x = s[5];
425
- y = s[6];
426
- canvas.bezierCurveTo(s[1], s[2], cpx, cpy, x, y);
427
- break;
428
-
429
- case "c":
430
- canvas.bezierCurveTo(s[1] + x, s[2] + y, s[3] + x, s[4] + y, s[5] + x, s[6] + y);
431
- cpx = s[3] + x; // Last control point
432
-
433
- cpy = s[4] + y;
434
- x += s[5];
435
- y += s[6];
436
- break;
437
-
438
- case "S":
439
- if (cpx === null || cpy === null) {
440
- cpx = x;
441
- cpy = y;
442
- }
443
-
444
- canvas.bezierCurveTo(2 * x - cpx, 2 * y - cpy, s[1], s[2], s[3], s[4]);
445
- cpx = s[1]; // last control point
446
-
447
- cpy = s[2];
448
- x = s[3];
449
- y = s[4];
450
- break;
451
-
452
- case "s":
453
- if (cpx === null || cpy === null) {
454
- cpx = x;
455
- cpy = y;
456
- }
457
-
458
- canvas.bezierCurveTo(2 * x - cpx, 2 * y - cpy, s[1] + x, s[2] + y, s[3] + x, s[4] + y);
459
- cpx = s[1] + x; // last control point
460
-
461
- cpy = s[2] + y;
462
- x += s[3];
463
- y += s[4];
464
- break;
465
-
466
- case "Q":
467
- qcpx = s[1]; // last control point
468
-
469
- qcpy = s[2];
470
- x = s[3];
471
- y = s[4];
472
- canvas.quadraticCurveTo(qcpx, qcpy, x, y);
473
- break;
474
-
475
- case "q":
476
- qcpx = s[1] + x; // last control point
477
-
478
- qcpy = s[2] + y;
479
- x += s[3];
480
- y += s[4];
481
- canvas.quadraticCurveTo(qcpx, qcpy, x, y);
482
- break;
483
-
484
- case "T":
485
- if (qcpx === null || qcpy === null) {
486
- qcpx = x;
487
- qcpy = y;
488
- }
489
-
490
- qcpx = 2 * x - qcpx; // last control point
491
-
492
- qcpy = 2 * y - qcpy;
493
- x = s[1];
494
- y = s[2];
495
- canvas.quadraticCurveTo(qcpx, qcpy, x, y);
496
- break;
497
-
498
- case "t":
499
- if (qcpx === null || qcpy === null) {
500
- qcpx = x;
501
- qcpy = y;
502
- }
503
-
504
- qcpx = 2 * x - qcpx; // last control point
505
-
506
- qcpy = 2 * y - qcpy;
507
- x += s[1];
508
- y += s[2];
509
- canvas.quadraticCurveTo(qcpx, qcpy, x, y);
510
- break;
511
-
512
- case "z":
513
- case "Z":
514
- x = startPoint.x;
515
- y = startPoint.y;
516
- startPoint = undefined;
517
- canvas.closePath();
518
- break;
519
-
520
- case "AC":
521
- // arc
522
- x = s[1];
523
- y = s[2];
524
- r = s[3];
525
- startAngle = s[4];
526
- endAngle = s[5];
527
- ccw = s[6];
528
- canvas.arc(x, y, r, startAngle, endAngle, ccw);
529
- break;
530
-
531
- case "AT":
532
- // arcTo
533
- x1 = s[1];
534
- y1 = s[2];
535
- x = s[3];
536
- y = s[4];
537
- r = s[5];
538
- canvas.arcTo(x1, y1, x, y, r);
539
- break;
540
-
541
- case "E":
542
- // ellipse
543
- x = s[1];
544
- y = s[2];
545
- rx = s[3];
546
- ry = s[4];
547
- angle = s[5];
548
- startAngle = s[6];
549
- endAngle = s[7];
550
- ccw = s[8];
551
- canvas.save();
552
- canvas.translate(x, y);
553
- canvas.rotate(angle);
554
- canvas.scale(rx, ry);
555
- canvas.arc(0, 0, 1, startAngle, endAngle, ccw);
556
- canvas.restore();
557
- break;
558
-
559
- case "R":
560
- // rect
561
- x = s[1];
562
- y = s[2];
563
- w = s[3];
564
- h = s[4];
565
- startPoint = {
566
- x: x,
567
- y: y
568
- };
569
- canvas.rect(x, y, w, h);
570
- break;
571
-
572
- }
573
-
574
- currentPoint.x = x;
575
- currentPoint.y = y;
576
- }
577
- }
578
-
579
- var cFill = window.CanvasRenderingContext2D.prototype.fill;
580
- var cStroke = window.CanvasRenderingContext2D.prototype.stroke;
581
-
582
- window.CanvasRenderingContext2D.prototype.fill = function fill() {
583
- for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
584
- args[_key] = arguments[_key];
585
- }
586
-
587
- var fillRule = "nonzero";
588
-
589
- if (args.length === 0 || args.length === 1 && typeof args[0] === "string") {
590
- cFill.apply(this, args);
591
- return;
592
- }
593
-
594
- if (arguments.length === 2) {
595
- fillRule = args[1];
596
- }
597
-
598
- var path = args[0];
599
- buildPath(this, path.segments);
600
- cFill.call(this, fillRule);
601
- };
602
-
603
- window.CanvasRenderingContext2D.prototype.stroke = function stroke(path) {
604
- if (!path) {
605
- cStroke.call(this);
606
- return;
607
- }
608
-
609
- buildPath(this, path.segments);
610
- cStroke.call(this);
611
- };
612
-
613
- var cIsPointInPath = window.CanvasRenderingContext2D.prototype.isPointInPath;
614
-
615
- window.CanvasRenderingContext2D.prototype.isPointInPath = function isPointInPath() {
616
- for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
617
- args[_key2] = arguments[_key2];
618
- }
619
-
620
- // let fillRule = 'nonzero';
621
- if (args[0].constructor.name === "Path2D") {
622
- // first argument is a Path2D object
623
- var x = args[1];
624
- var y = args[2];
625
- var fillRule = args[3] || "nonzero";
626
- var path = args[0];
627
- buildPath(this, path.segments);
628
- return cIsPointInPath.apply(this, [x, y, fillRule]);
629
- } else {
630
- return cIsPointInPath.apply(this, args);
631
- }
632
- };
633
-
634
- window.Path2D = Path2D;
635
- }
636
-
637
- var path2dPolyfill$1 = polyFillPath2D;
638
-
639
- var parsePath = parsePath$2;
640
- var path2dPolyfill = path2dPolyfill$1;
641
-
642
- if (typeof window !== "undefined") {
643
- path2dPolyfill(window);
644
- }
645
-
646
- var src = {
647
- path2dPolyfill: path2dPolyfill,
648
- parsePath: parsePath
649
- };
650
-
651
- export { src as default };
652
- //# sourceMappingURL=index.esm.js.map