@wcardinal/wcardinal-ui 0.341.0 → 0.343.0

package/dist/wcardinal-ui.js

@@ -1,5 +1,5 @@
 /*
- Winter Cardinal UI v0.341.0
+ Winter Cardinal UI v0.343.0
  Copyright (C) 2019 Toshiba Corporation
  SPDX-License-Identifier: Apache-2.0
 
@@ -52,6 +52,7 @@
         CONNECTOR_LINE: 22,
         CONNECTOR_ELBOW: 23,
         SEMICIRCLE: 24,
+        EMBEDDED_ACCEPTOR_EDGE: 25,
         EXTENSION: 1000
     };
 
@@ -4470,6 +4471,7 @@
     var PRIMITIVE = ID | COORDINATE | SHAPE | TEXT$2 | TEXTURE | DATA | ACTION | CURSOR$1 | LAYER | CHILDREN$1;
     var GROUP = PRIMITIVE | UNGROUPING;
     var EMBEDDED = ID | COORDINATE | REPLACING | GROUPING | TEXT$2 | DATA | ACTION | LAYER | DATA_MAPPING;
+    var EMBEDDED_ACCEPTOR_EDGE = ID | COORDINATE | REPLACING | FILL$1 | STROKE$1 | TEXT$2 | TEXTURE | DATA | ACTION | CURSOR$1 | LAYER;
     var CONNECTOR = ID | REPLACING | FILL$1 | STROKE$1 | LINE | LINE_TAIL | LINE_HEAD | TEXT$2 | TEXTURE | DATA | ACTION | CURSOR$1 | LAYER | CHILDREN$1;
     var ALL = PRIMITIVE | STROKE_SIDE | BORDER_RADIUS | DATA_MAPPING | UNGROUPING;
     var EShapeCapability = {
@@ -4580,6 +4582,7 @@
         PRIMITIVE: PRIMITIVE,
         GROUP: GROUP,
         EMBEDDED: EMBEDDED,
+        EMBEDDED_ACCEPTOR_EDGE: EMBEDDED_ACCEPTOR_EDGE,
         CONNECTOR: CONNECTOR,
         ALL: ALL
     };
@@ -16725,6 +16728,115 @@
         EDITOR: 2
     };
 
+    /*
+     * Copyright (C) 2019 Toshiba Corporation
+     * SPDX-License-Identifier: Apache-2.0
+     */
+    var EShapeAcceptorEdgeSide = {
+        NONE: 0,
+        TOP: 1,
+        RIGHT: 2,
+        BOTTOM: 4,
+        LEFT: 8,
+        ALL: 15
+    };
+
+    /*
+     * Copyright (C) 2019 Toshiba Corporation
+     * SPDX-License-Identifier: Apache-2.0
+     */
+    var EShapeAcceptorEdgeType = {
+        TAIL: 1,
+        HEAD: 2,
+        ALL: 3
+    };
+
+    /*
+     * Copyright (C) 2019 Toshiba Corporation
+     * SPDX-License-Identifier: Apache-2.0
+     */
+    var EShapeCircle = /** @class */ (function (_super) {
+        __extends(EShapeCircle, _super);
+        function EShapeCircle(type) {
+            if (type === void 0) { type = EShapeType.CIRCLE; }
+            return _super.call(this, type) || this;
+        }
+        EShapeCircle.prototype.clone = function () {
+            return new EShapeCircle(this.type).copy(this);
+        };
+        EShapeCircle.prototype.containsAbs = function (x, y, ax, ay, sw, ss, sa) {
+            if (_super.prototype.containsAbsBBox.call(this, x, y, ax, ay)) {
+                return hitTestCircle(this, x, y, ax, ay, sw, ss);
+            }
+            return false;
+        };
+        return EShapeCircle;
+    }(EShapePrimitive));
+
+    var EShapeEmbeddedAcceptorEdge = /** @class */ (function (_super) {
+        __extends(EShapeEmbeddedAcceptorEdge, _super);
+        function EShapeEmbeddedAcceptorEdge(type) {
+            if (type === void 0) { type = EShapeType.EMBEDDED_ACCEPTOR_EDGE; }
+            var _this = _super.call(this, type) || this;
+            _this._subtype = EShapeAcceptorEdgeType.HEAD;
+            _this._side = EShapeAcceptorEdgeSide.ALL;
+            _this._vvisible = true;
+            return _this;
+        }
+        Object.defineProperty(EShapeEmbeddedAcceptorEdge.prototype, "subtype", {
+            get: function () {
+                return this._subtype;
+            },
+            set: function (subtype) {
+                this._subtype = subtype;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(EShapeEmbeddedAcceptorEdge.prototype, "side", {
+            get: function () {
+                return this._side;
+            },
+            set: function (side) {
+                this._side = side;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(EShapeEmbeddedAcceptorEdge.prototype, "vvisible", {
+            /**
+             * True if visible in the viewer mode.
+             */
+            get: function () {
+                return this._vvisible;
+            },
+            set: function (vvisible) {
+                this._vvisible = vvisible;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        EShapeEmbeddedAcceptorEdge.prototype.clone = function () {
+            return new EShapeEmbeddedAcceptorEdge(this.type).copy(this);
+        };
+        EShapeEmbeddedAcceptorEdge.prototype.copy = function (source, part) {
+            if (part === void 0) { part = EShapeCopyPart.ALL; }
+            _super.prototype.copy.call(this, source, part);
+            if (source instanceof EShapeEmbeddedAcceptorEdge) {
+                this._subtype = source.subtype;
+                this._side = source.side;
+                this._vvisible = source.vvisible;
+            }
+            return this;
+        };
+        EShapeEmbeddedAcceptorEdge.prototype.serialize = function (manager) {
+            var result = _super.prototype.serialize.call(this, manager);
+            result[15] = this._subtype + (this._side << 2) + (this._vvisible ? 1 << 6 : 0);
+            return result;
+        };
+        return EShapeEmbeddedAcceptorEdge;
+    }(EShapeCircle));
+
     /*
      * Copyright (C) 2019 Toshiba Corporation
      * SPDX-License-Identifier: Apache-2.0
@@ -17582,6 +17694,71 @@
             enumerable: false,
             configurable: true
         });
+        Object.defineProperty(EShapeEmbedded.prototype, "edges", {
+            get: function () {
+                var _a;
+                return ((_a = this._edges) !== null && _a !== void 0 ? _a : (this._edges = this.newEdges()));
+            },
+            enumerable: false,
+            configurable: true
+        });
+        EShapeEmbedded.prototype.newEdges = function () {
+            var result = new Map();
+            var layers = this.children;
+            if (layers != null) {
+                var s = this.size;
+                var sx = s.x;
+                var sy = s.y;
+                var sxh = sx * 0.5;
+                var syh = sy * 0.5;
+                for (var i = 0, imax = layers.length; i < imax; ++i) {
+                    var layer = layers[i];
+                    var lp = layer.transform.position;
+                    var lpx = lp.x + sxh;
+                    var lpy = lp.y + syh;
+                    var children = layer.children;
+                    for (var j = 0, jmax = children.length; j < jmax; ++j) {
+                        var child = children[j];
+                        if (child instanceof EShapeEmbeddedAcceptorEdge) {
+                            child.transform.updateLocalTransform();
+                            var clt = child.transform.localTransform;
+                            result.set(child.id, {
+                                type: child.subtype,
+                                x: this.toEedgePosition(lpx, clt.tx, sxh, sx),
+                                y: this.toEedgePosition(lpy, clt.ty, syh, sy),
+                                normal: this.toEedgeNormal(clt.c, clt.d),
+                                size: {
+                                    x: 0,
+                                    y: 0
+                                },
+                                side: child.side
+                            });
+                        }
+                    }
+                }
+            }
+            return result;
+        };
+        EShapeEmbedded.prototype.toEedgePosition = function (lp, cp, sh, s) {
+            if (0.00001 < Math.abs(s)) {
+                return (lp + cp - sh) / s;
+            }
+            return 0;
+        };
+        EShapeEmbedded.prototype.toEedgeNormal = function (x, y) {
+            var d = x * x + y * y;
+            if (0.00001 < d) {
+                var f = 1 / d;
+                return {
+                    x: x * f,
+                    y: y * f
+                };
+            }
+            return {
+                x: 0,
+                y: 1
+            };
+        };
         EShapeEmbedded.prototype.isGroupSizeFittable = function () {
             return false;
         };
@@ -17727,29 +17904,6 @@
         return EShapeEmbeddedDatum;
     }());
 
-    /*
-     * Copyright (C) 2019 Toshiba Corporation
-     * SPDX-License-Identifier: Apache-2.0
-     */
-    var EShapeAcceptorEdgeType = {
-        TAIL: 1,
-        HEAD: 2,
-        ALL: 3
-    };
-
-    /*
-     * Copyright (C) 2019 Toshiba Corporation
-     * SPDX-License-Identifier: Apache-2.0
-     */
-    var EShapeAcceptorEdgeSide = {
-        NONE: 0,
-        TOP: 1,
-        RIGHT: 2,
-        BOTTOM: 4,
-        LEFT: 8,
-        ALL: 15
-    };
-
     /*
      * Copyright (C) 2019 Toshiba Corporation
      * SPDX-License-Identifier: Apache-2.0
@@ -17847,6 +18001,39 @@
         return EShapeAcceptorImpl;
     }());
 
+    var EShapeEmbeddedAcceptor = /** @class */ (function (_super) {
+        __extends(EShapeEmbeddedAcceptor, _super);
+        function EShapeEmbeddedAcceptor() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        EShapeEmbeddedAcceptor.prototype.get = function (shape, id) {
+            var edges = this.getEdges(shape);
+            if (edges != null) {
+                var edge = edges.get(id);
+                if (edge != null) {
+                    return edge;
+                }
+            }
+            return _super.prototype.get.call(this, shape, id);
+        };
+        EShapeEmbeddedAcceptor.prototype.each = function (shape, iteratee) {
+            var edges = this.getEdges(shape);
+            if (edges != null) {
+                edges.forEach(function (edge, id) {
+                    iteratee(edge, id);
+                });
+            }
+            return _super.prototype.each.call(this, shape, iteratee);
+        };
+        EShapeEmbeddedAcceptor.prototype.getEdges = function (shape) {
+            if (shape instanceof EShapeEmbedded) {
+                return shape.edges;
+            }
+            return null;
+        };
+        return EShapeEmbeddedAcceptor;
+    }(EShapeAcceptorImpl));
+
     /*
      * Copyright (C) 2019 Toshiba Corporation
      * SPDX-License-Identifier: Apache-2.0
@@ -17855,27 +18042,59 @@
         function EShapeAcceptors() {
         }
         EShapeAcceptors.set = function (type, acceptor) {
-            var typeToAcceptor = this._typeToAcceptor;
-            if (typeToAcceptor == null) {
-                typeToAcceptor = new Map();
-                this._typeToAcceptor = typeToAcceptor;
+            var acceptors = this._acceptors;
+            if (acceptors == null) {
+                acceptors = new Map();
+                this._acceptors = acceptors;
             }
-            typeToAcceptor.set(type, acceptor);
+            acceptors.set(type, acceptor);
         };
         EShapeAcceptors.get = function (type) {
             var _a;
-            return ((_a = this._typeToAcceptor) === null || _a === void 0 ? void 0 : _a.get(type)) || this.getDefault();
-        };
-        EShapeAcceptors.getDefault = function () {
-            var result = this._default;
-            if (result == null) {
-                result = this.newDefault();
-                this._default = result;
+            var acceptors = this._acceptors;
+            if (acceptors != null) {
+                var acceptor = acceptors.get(type);
+                if (acceptor != null) {
+                    return acceptor;
+                }
+            }
+            var defaults = ((_a = this._defaults) !== null && _a !== void 0 ? _a : (this._defaults = new Map()));
+            switch (type) {
+                case EShapeType.EMBEDDED:
+                    var embedded = defaults.get(type);
+                    if (embedded == null) {
+                        embedded = this.newDefaultEmbedded();
+                        defaults.set(type, embedded);
+                    }
+                    return embedded;
+                case EShapeType.EMBEDDED_ACCEPTOR_EDGE:
+                    var edge = defaults.get(type);
+                    if (edge == null) {
+                        edge = this.newDefaultEmbeddedAcceptorEdge();
+                        defaults.set(type, edge);
+                    }
+                    return edge;
+                default:
+                    var other = defaults.get(null);
+                    if (other == null) {
+                        other = this.newDefaultOther();
+                        defaults.set(null, other);
+                    }
+                    return other;
             }
-            return result;
         };
-        EShapeAcceptors.newDefault = function () {
+        EShapeAcceptors.newDefaultEmbedded = function () {
+            return this.initDefault(new EShapeEmbeddedAcceptor());
+        };
+        EShapeAcceptors.newDefaultEmbeddedAcceptorEdge = function () {
             var result = new EShapeAcceptorImpl();
+            result.add("CENTER", EShapeAcceptorEdgeType.ALL, 0, 0, 0, 0);
+            return result;
+        };
+        EShapeAcceptors.newDefaultOther = function () {
+            return this.initDefault(new EShapeAcceptorImpl());
+        };
+        EShapeAcceptors.initDefault = function (result) {
             var s = 1 / Math.sqrt(2);
             result.add("TOP", EShapeAcceptorEdgeType.ALL, 0, -0.5, 0, -1);
             result.add("LEFT", EShapeAcceptorEdgeType.ALL, -0.5, 0, -1, 0);
@@ -36425,28 +36644,6 @@
         return null;
     };
 
-    /*
-     * Copyright (C) 2019 Toshiba Corporation
-     * SPDX-License-Identifier: Apache-2.0
-     */
-    var EShapeCircle = /** @class */ (function (_super) {
-        __extends(EShapeCircle, _super);
-        function EShapeCircle(type) {
-            if (type === void 0) { type = EShapeType.CIRCLE; }
-            return _super.call(this, type) || this;
-        }
-        EShapeCircle.prototype.clone = function () {
-            return new EShapeCircle(this.type).copy(this);
-        };
-        EShapeCircle.prototype.containsAbs = function (x, y, ax, ay, sw, ss, sa) {
-            if (_super.prototype.containsAbsBBox.call(this, x, y, ax, ay)) {
-                return hitTestCircle(this, x, y, ax, ay, sw, ss);
-            }
-            return false;
-        };
-        return EShapeCircle;
-    }(EShapePrimitive));
-
     /*
      * Copyright (C) 2019 Toshiba Corporation
      * SPDX-License-Identifier: Apache-2.0
@@ -38712,15 +38909,53 @@
         return null;
     };
 
+    /*
+     * Copyright (C) 2019 Toshiba Corporation
+     * SPDX-License-Identifier: Apache-2.0
+     */
+    var toSubtype = function (target) {
+        var result = EShapeAcceptorEdgeType.ALL & target;
+        if (result !== 0) {
+            return result;
+        }
+        return EShapeAcceptorEdgeType.HEAD;
+    };
+    var toSide = function (target) {
+        return (EShapeAcceptorEdgeSide.ALL & (target << 2));
+    };
+    var toVvisible = function (target) {
+        return 0 < (0x1 & (target << 6));
+    };
+    var deserializeEmbeddedAcceptorEdge = function (item, manager, shape) {
+        shape !== null && shape !== void 0 ? shape : (shape = new EShapeEmbeddedAcceptorEdge());
+        var item15 = item[15];
+        shape.subtype = toSubtype(item15);
+        shape.side = toSide(item15);
+        shape.vvisible = toVvisible(item15);
+        var result = deserializeBase(item, manager, shape);
+        if (shape.vvisible === false) {
+            if (manager.mode === EShapeResourceManagerDeserializationMode.VIEWER) {
+                shape.visible = false;
+            }
+        }
+        return result;
+    };
+
     /*
      * Copyright (C) 2019 Toshiba Corporation
      * SPDX-License-Identifier: Apache-2.0
      */
     var loadShapeEmbedded = function () {
+        // Embedded
         EShapeUploadeds[EShapeType.EMBEDDED] = createGroupUploaded;
         EShapeDeserializers[EShapeType.EMBEDDED] = deserializeEmbedded;
         EShapeCapabilities.set(EShapeType.EMBEDDED, EShapeCapability.EMBEDDED);
+        // Embedded layer
         EShapeUploadeds[EShapeType.EMBEDDED_LAYER] = createRectanglePivotedUploaded;
+        // Embedded acceptor edge
+        EShapeUploadeds[EShapeType.EMBEDDED_ACCEPTOR_EDGE] = createCircleUploaded;
+        EShapeDeserializers[EShapeType.EMBEDDED_ACCEPTOR_EDGE] = deserializeEmbeddedAcceptorEdge;
+        EShapeCapabilities.set(EShapeType.EMBEDDED_ACCEPTOR_EDGE, EShapeCapability.EMBEDDED_ACCEPTOR_EDGE);
     };
 
     /*
@@ -75807,8 +76042,9 @@
         deserializeConnectorElbow: deserializeConnectorElbow,
         deserializeConnectorLine: deserializeConnectorLine,
         onDeserializedConnectorLine: onDeserializedConnectorLine,
-        deserializeEmbedded: deserializeEmbedded,
+        deserializeEmbeddedAcceptorEdge: deserializeEmbeddedAcceptorEdge,
         deserializeEmbeddedLayer: deserializeEmbeddedLayer,
+        deserializeEmbedded: deserializeEmbedded,
         deserializeGradient: deserializeGradient,
         deserializeGroupShadowed: deserializeGroupShadowed,
         deserializeGroup: deserializeGroup,
@@ -75842,6 +76078,7 @@
         EShapeConnectorElbowPointsFiller: EShapeConnectorElbowPointsFiller,
         EShapeConnectorElbow: EShapeConnectorElbow,
         EShapeConnectorLine: EShapeConnectorLine,
+        EShapeEmbeddedAcceptorEdge: EShapeEmbeddedAcceptorEdge,
         EShapeEmbeddedDatum: EShapeEmbeddedDatum,
         EShapeEmbeddedLayerContainer: EShapeEmbeddedLayerContainer,
         EShapeEmbeddedLayer: EShapeEmbeddedLayer,