@wcardinal/wcardinal-ui 0.465.0 → 0.465.1

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.
@@ -1,5 +1,5 @@
1
1
  /*!
2
- Winter Cardinal UI v0.465.0
2
+ Winter Cardinal UI v0.465.1
3
3
  Copyright (C) 2019-2026 Toshiba Corporation
4
4
  SPDX-License-Identifier: Apache-2.0
5
5
 
@@ -32742,11 +32742,12 @@ var EShapeCircleTriangulatedImpl = /** @class */ (function () {
32742
32742
  var nny = nx * fy * s + ny * c;
32743
32743
  var sx = this.toSkeletonX(ppx, ppy, px, py, nx, ny);
32744
32744
  vertices[0] = 0;
32745
- vertices[1] = scale * sizeY;
32745
+ vertices[1] = sizeY;
32746
32746
  clippings[0] = -1;
32747
+ distances[0] = sx;
32747
32748
  lengths[0] = 0;
32748
32749
  uvs[0] = 0.5;
32749
- uvs[1] = 0.5 * (scale + 1);
32750
+ uvs[1] = 1;
32750
32751
  var iv = 1;
32751
32752
  var ii = 0;
32752
32753
  var length = 0;
@@ -32769,35 +32770,41 @@ var EShapeCircleTriangulatedImpl = /** @class */ (function () {
32769
32770
  var nlength = length + dl;
32770
32771
  var iv1 = iv++;
32771
32772
  var iv2 = iv1 << 1;
32772
- var snx = scale * nx;
32773
- var sny = scale * ny;
32774
- vertices[iv2 + 0] = snx;
32775
- vertices[iv2 + 1] = sny;
32776
- clippings[iv1] = -1;
32777
- lengths[iv1] = nlength;
32778
- uvs[iv2 + 0] = 0.5 * (snx / sizeX + 1);
32779
- uvs[iv2 + 1] = 0.5 * (sny / sizeY + 1);
32780
32773
  var niv1 = iv++;
32781
32774
  var niv2 = niv1 << 1;
32782
32775
  var ndistance = Math.abs(-dx * py - dy * (nsx - px)) * fl;
32776
+ maxDistance = Math.max(maxDistance, ndistance);
32777
+ vertices[iv2 + 0] = nx;
32778
+ vertices[iv2 + 1] = ny;
32779
+ clippings[iv1] = -1 - ndistance;
32780
+ distances[iv1] = nsx;
32781
+ lengths[iv1] = nlength;
32782
+ uvs[iv2 + 0] = 0.5 * (nx / sizeX + 1);
32783
+ uvs[iv2 + 1] = 0.5 * (ny / sizeY + 1);
32783
32784
  vertices[niv2 + 0] = nsx;
32784
32785
  vertices[niv2 + 1] = 0;
32785
32786
  clippings[niv1] = ndistance;
32786
- maxDistance = Math.max(maxDistance, ndistance);
32787
+ distances[niv1] = 0;
32787
32788
  lengths[niv1] = length + ((nsx - px) * dx - py * dy) * fl;
32788
32789
  uvs[niv2] = 0.5 * (nsx / sizeX + 1);
32789
32790
  uvs[niv2 + 1] = 0.5;
32790
32791
  indices[ii++] = current;
32791
32792
  indices[ii++] = iv1;
32792
32793
  indices[ii++] = niv1;
32793
- if (sx !== nsx) {
32794
+ distances[current] = sx;
32795
+ if (sx === nsx) {
32796
+ clippings[current] = -1 - ndistance;
32797
+ }
32798
+ else {
32799
+ var mdistance = Math.abs(-dx * py - dy * (sx - px)) * fl;
32800
+ maxDistance = Math.max(maxDistance, mdistance);
32801
+ clippings[current] = -1 - mdistance;
32794
32802
  var miv1 = iv++;
32795
32803
  var miv2 = miv1 << 1;
32796
- var mdistance = Math.abs(-dx * py - dy * (sx - px)) * fl;
32797
32804
  vertices[miv2] = sx;
32798
32805
  vertices[miv2 + 1] = 0;
32799
32806
  clippings[miv1] = mdistance;
32800
- maxDistance = Math.max(maxDistance, mdistance);
32807
+ distances[miv1] = 0;
32801
32808
  lengths[miv1] = length + ((sx - px) * dx - py * dy) * fl;
32802
32809
  uvs[miv2] = 0.5 * (sx / sizeX + 1);
32803
32810
  uvs[miv2 + 1] = 0.5;
@@ -32819,15 +32826,27 @@ var EShapeCircleTriangulatedImpl = /** @class */ (function () {
32819
32826
  if (0 < maxDistance) {
32820
32827
  fdistance = 1 / maxDistance;
32821
32828
  }
32829
+ var shift = (scale - 1) * maxDistance;
32822
32830
  for (var i = 0; i < iv; ++i) {
32823
- distances[i] = fdistance;
32824
32831
  var clipping = clippings[i];
32825
32832
  if (0 <= clipping) {
32826
32833
  clippings[i] = 1 - clipping * fdistance;
32827
32834
  }
32828
32835
  else {
32836
+ var distance = -1 - clipping;
32837
+ if (0 < distance) {
32838
+ var i2 = i << 1;
32839
+ var factor = shift / distance;
32840
+ var x = vertices[i2] + (vertices[i2] - distances[i]) * factor;
32841
+ var y = vertices[i2 + 1] * (1 + factor);
32842
+ vertices[i2] = x;
32843
+ vertices[i2 + 1] = y;
32844
+ uvs[i2] = 0.5 * (x / sizeX + 1);
32845
+ uvs[i2 + 1] = 0.5 * (y / sizeY + 1);
32846
+ }
32829
32847
  clippings[i] = scale;
32830
32848
  }
32849
+ distances[i] = fdistance;
32831
32850
  }
32832
32851
  // The skeleton points of adjacent vertices may coincide on a nearly circular ellipse.
32833
32852
  this.pad(iv, ii, nv, ni, fdistance);
@@ -32872,11 +32891,12 @@ var EShapeCircleTriangulatedImpl = /** @class */ (function () {
32872
32891
  var nny = s * nx * fy + c * ny;
32873
32892
  var sy = this.toSkeletonY(pppx, pppy, ppx, ppy, px, py);
32874
32893
  vertices[0] = 0;
32875
- vertices[1] = scale * sizeY;
32894
+ vertices[1] = sizeY;
32876
32895
  clippings[0] = -1;
32896
+ distances[0] = sy;
32877
32897
  lengths[0] = 0;
32878
32898
  uvs[0] = 0.5;
32879
- uvs[1] = 0.5 * (scale + 1);
32899
+ uvs[1] = 1;
32880
32900
  var iv = 1;
32881
32901
  var ii = 0;
32882
32902
  var length = 0;
@@ -32899,35 +32919,41 @@ var EShapeCircleTriangulatedImpl = /** @class */ (function () {
32899
32919
  var nlength = length + dl;
32900
32920
  var iv1 = iv++;
32901
32921
  var iv2 = iv1 << 1;
32902
- var snx = scale * nx;
32903
- var sny = scale * ny;
32904
- vertices[iv2 + 0] = snx;
32905
- vertices[iv2 + 1] = sny;
32906
- clippings[iv1] = -1;
32907
- lengths[iv1] = nlength;
32908
- uvs[iv2 + 0] = 0.5 * (snx / sizeX + 1);
32909
- uvs[iv2 + 1] = 0.5 * (sny / sizeY + 1);
32910
32922
  var niv1 = iv++;
32911
32923
  var niv2 = niv1 << 1;
32912
32924
  var ndistance = Math.abs(dx * (nsy - py) + dy * px) * fl;
32925
+ maxDistance = Math.max(maxDistance, ndistance);
32926
+ vertices[iv2 + 0] = nx;
32927
+ vertices[iv2 + 1] = ny;
32928
+ clippings[iv1] = -1 - ndistance;
32929
+ distances[iv1] = nsy;
32930
+ lengths[iv1] = nlength;
32931
+ uvs[iv2 + 0] = 0.5 * (nx / sizeX + 1);
32932
+ uvs[iv2 + 1] = 0.5 * (ny / sizeY + 1);
32913
32933
  vertices[niv2] = 0;
32914
32934
  vertices[niv2 + 1] = nsy;
32915
32935
  clippings[niv1] = ndistance;
32916
- maxDistance = Math.max(maxDistance, ndistance);
32936
+ distances[niv1] = 0;
32917
32937
  lengths[niv1] = length + (-px * dx + (nsy - py) * dy) * fl;
32918
32938
  uvs[niv2] = 0.5;
32919
32939
  uvs[niv2 + 1] = 0.5 * (nsy / sizeY + 1);
32920
32940
  indices[ii++] = current;
32921
32941
  indices[ii++] = iv1;
32922
32942
  indices[ii++] = niv1;
32923
- if (sy !== nsy) {
32943
+ distances[current] = sy;
32944
+ if (sy === nsy) {
32945
+ clippings[current] = -1 - ndistance;
32946
+ }
32947
+ else {
32948
+ var mdistance = Math.abs(dx * (sy - py) + dy * px) * fl;
32949
+ maxDistance = Math.max(maxDistance, mdistance);
32950
+ clippings[current] = -1 - mdistance;
32924
32951
  var miv1 = iv++;
32925
32952
  var miv2 = miv1 << 1;
32926
- var mdistance = Math.abs(dx * (sy - py) + dy * px) * fl;
32927
32953
  vertices[miv2] = 0;
32928
32954
  vertices[miv2 + 1] = sy;
32929
32955
  clippings[miv1] = mdistance;
32930
- maxDistance = Math.max(maxDistance, mdistance);
32956
+ distances[miv1] = 0;
32931
32957
  lengths[miv1] = length + (-px * dx + (sy - py) * dy) * fl;
32932
32958
  uvs[miv2] = 0.5;
32933
32959
  uvs[miv2 + 1] = 0.5 * (sy / sizeY + 1);
@@ -32949,15 +32975,27 @@ var EShapeCircleTriangulatedImpl = /** @class */ (function () {
32949
32975
  if (0 < maxDistance) {
32950
32976
  fdistance = 1 / maxDistance;
32951
32977
  }
32978
+ var shift = (scale - 1) * maxDistance;
32952
32979
  for (var i = 0; i < iv; ++i) {
32953
- distances[i] = fdistance;
32954
32980
  var clipping = clippings[i];
32955
32981
  if (0 <= clipping) {
32956
32982
  clippings[i] = 1 - clipping * fdistance;
32957
32983
  }
32958
32984
  else {
32985
+ var distance = -1 - clipping;
32986
+ if (0 < distance) {
32987
+ var i2 = i << 1;
32988
+ var factor = shift / distance;
32989
+ var x = vertices[i2] * (1 + factor);
32990
+ var y = vertices[i2 + 1] + (vertices[i2 + 1] - distances[i]) * factor;
32991
+ vertices[i2] = x;
32992
+ vertices[i2 + 1] = y;
32993
+ uvs[i2] = 0.5 * (x / sizeX + 1);
32994
+ uvs[i2 + 1] = 0.5 * (y / sizeY + 1);
32995
+ }
32959
32996
  clippings[i] = scale;
32960
32997
  }
32998
+ distances[i] = fdistance;
32961
32999
  }
32962
33000
  // The skeleton points of adjacent vertices may coincide on a nearly circular ellipse.
32963
33001
  this.pad(iv, ii, nv, ni, fdistance);
@@ -1,5 +1,5 @@
1
1
  /*!
2
- Winter Cardinal UI v0.465.0
2
+ Winter Cardinal UI v0.465.1
3
3
  Copyright (C) 2019-2026 Toshiba Corporation
4
4
  SPDX-License-Identifier: Apache-2.0
5
5
 
@@ -42515,11 +42515,12 @@
42515
42515
  var nny = nx * fy * s + ny * c;
42516
42516
  var sx = this.toSkeletonX(ppx, ppy, px, py, nx, ny);
42517
42517
  vertices[0] = 0;
42518
- vertices[1] = scale * sizeY;
42518
+ vertices[1] = sizeY;
42519
42519
  clippings[0] = -1;
42520
+ distances[0] = sx;
42520
42521
  lengths[0] = 0;
42521
42522
  uvs[0] = 0.5;
42522
- uvs[1] = 0.5 * (scale + 1);
42523
+ uvs[1] = 1;
42523
42524
  var iv = 1;
42524
42525
  var ii = 0;
42525
42526
  var length = 0;
@@ -42542,35 +42543,41 @@
42542
42543
  var nlength = length + dl;
42543
42544
  var iv1 = iv++;
42544
42545
  var iv2 = iv1 << 1;
42545
- var snx = scale * nx;
42546
- var sny = scale * ny;
42547
- vertices[iv2 + 0] = snx;
42548
- vertices[iv2 + 1] = sny;
42549
- clippings[iv1] = -1;
42550
- lengths[iv1] = nlength;
42551
- uvs[iv2 + 0] = 0.5 * (snx / sizeX + 1);
42552
- uvs[iv2 + 1] = 0.5 * (sny / sizeY + 1);
42553
42546
  var niv1 = iv++;
42554
42547
  var niv2 = niv1 << 1;
42555
42548
  var ndistance = Math.abs(-dx * py - dy * (nsx - px)) * fl;
42549
+ maxDistance = Math.max(maxDistance, ndistance);
42550
+ vertices[iv2 + 0] = nx;
42551
+ vertices[iv2 + 1] = ny;
42552
+ clippings[iv1] = -1 - ndistance;
42553
+ distances[iv1] = nsx;
42554
+ lengths[iv1] = nlength;
42555
+ uvs[iv2 + 0] = 0.5 * (nx / sizeX + 1);
42556
+ uvs[iv2 + 1] = 0.5 * (ny / sizeY + 1);
42556
42557
  vertices[niv2 + 0] = nsx;
42557
42558
  vertices[niv2 + 1] = 0;
42558
42559
  clippings[niv1] = ndistance;
42559
- maxDistance = Math.max(maxDistance, ndistance);
42560
+ distances[niv1] = 0;
42560
42561
  lengths[niv1] = length + ((nsx - px) * dx - py * dy) * fl;
42561
42562
  uvs[niv2] = 0.5 * (nsx / sizeX + 1);
42562
42563
  uvs[niv2 + 1] = 0.5;
42563
42564
  indices[ii++] = current;
42564
42565
  indices[ii++] = iv1;
42565
42566
  indices[ii++] = niv1;
42566
- if (sx !== nsx) {
42567
+ distances[current] = sx;
42568
+ if (sx === nsx) {
42569
+ clippings[current] = -1 - ndistance;
42570
+ }
42571
+ else {
42572
+ var mdistance = Math.abs(-dx * py - dy * (sx - px)) * fl;
42573
+ maxDistance = Math.max(maxDistance, mdistance);
42574
+ clippings[current] = -1 - mdistance;
42567
42575
  var miv1 = iv++;
42568
42576
  var miv2 = miv1 << 1;
42569
- var mdistance = Math.abs(-dx * py - dy * (sx - px)) * fl;
42570
42577
  vertices[miv2] = sx;
42571
42578
  vertices[miv2 + 1] = 0;
42572
42579
  clippings[miv1] = mdistance;
42573
- maxDistance = Math.max(maxDistance, mdistance);
42580
+ distances[miv1] = 0;
42574
42581
  lengths[miv1] = length + ((sx - px) * dx - py * dy) * fl;
42575
42582
  uvs[miv2] = 0.5 * (sx / sizeX + 1);
42576
42583
  uvs[miv2 + 1] = 0.5;
@@ -42592,15 +42599,27 @@
42592
42599
  if (0 < maxDistance) {
42593
42600
  fdistance = 1 / maxDistance;
42594
42601
  }
42602
+ var shift = (scale - 1) * maxDistance;
42595
42603
  for (var i = 0; i < iv; ++i) {
42596
- distances[i] = fdistance;
42597
42604
  var clipping = clippings[i];
42598
42605
  if (0 <= clipping) {
42599
42606
  clippings[i] = 1 - clipping * fdistance;
42600
42607
  }
42601
42608
  else {
42609
+ var distance = -1 - clipping;
42610
+ if (0 < distance) {
42611
+ var i2 = i << 1;
42612
+ var factor = shift / distance;
42613
+ var x = vertices[i2] + (vertices[i2] - distances[i]) * factor;
42614
+ var y = vertices[i2 + 1] * (1 + factor);
42615
+ vertices[i2] = x;
42616
+ vertices[i2 + 1] = y;
42617
+ uvs[i2] = 0.5 * (x / sizeX + 1);
42618
+ uvs[i2 + 1] = 0.5 * (y / sizeY + 1);
42619
+ }
42602
42620
  clippings[i] = scale;
42603
42621
  }
42622
+ distances[i] = fdistance;
42604
42623
  }
42605
42624
  // The skeleton points of adjacent vertices may coincide on a nearly circular ellipse.
42606
42625
  this.pad(iv, ii, nv, ni, fdistance);
@@ -42645,11 +42664,12 @@
42645
42664
  var nny = s * nx * fy + c * ny;
42646
42665
  var sy = this.toSkeletonY(pppx, pppy, ppx, ppy, px, py);
42647
42666
  vertices[0] = 0;
42648
- vertices[1] = scale * sizeY;
42667
+ vertices[1] = sizeY;
42649
42668
  clippings[0] = -1;
42669
+ distances[0] = sy;
42650
42670
  lengths[0] = 0;
42651
42671
  uvs[0] = 0.5;
42652
- uvs[1] = 0.5 * (scale + 1);
42672
+ uvs[1] = 1;
42653
42673
  var iv = 1;
42654
42674
  var ii = 0;
42655
42675
  var length = 0;
@@ -42672,35 +42692,41 @@
42672
42692
  var nlength = length + dl;
42673
42693
  var iv1 = iv++;
42674
42694
  var iv2 = iv1 << 1;
42675
- var snx = scale * nx;
42676
- var sny = scale * ny;
42677
- vertices[iv2 + 0] = snx;
42678
- vertices[iv2 + 1] = sny;
42679
- clippings[iv1] = -1;
42680
- lengths[iv1] = nlength;
42681
- uvs[iv2 + 0] = 0.5 * (snx / sizeX + 1);
42682
- uvs[iv2 + 1] = 0.5 * (sny / sizeY + 1);
42683
42695
  var niv1 = iv++;
42684
42696
  var niv2 = niv1 << 1;
42685
42697
  var ndistance = Math.abs(dx * (nsy - py) + dy * px) * fl;
42698
+ maxDistance = Math.max(maxDistance, ndistance);
42699
+ vertices[iv2 + 0] = nx;
42700
+ vertices[iv2 + 1] = ny;
42701
+ clippings[iv1] = -1 - ndistance;
42702
+ distances[iv1] = nsy;
42703
+ lengths[iv1] = nlength;
42704
+ uvs[iv2 + 0] = 0.5 * (nx / sizeX + 1);
42705
+ uvs[iv2 + 1] = 0.5 * (ny / sizeY + 1);
42686
42706
  vertices[niv2] = 0;
42687
42707
  vertices[niv2 + 1] = nsy;
42688
42708
  clippings[niv1] = ndistance;
42689
- maxDistance = Math.max(maxDistance, ndistance);
42709
+ distances[niv1] = 0;
42690
42710
  lengths[niv1] = length + (-px * dx + (nsy - py) * dy) * fl;
42691
42711
  uvs[niv2] = 0.5;
42692
42712
  uvs[niv2 + 1] = 0.5 * (nsy / sizeY + 1);
42693
42713
  indices[ii++] = current;
42694
42714
  indices[ii++] = iv1;
42695
42715
  indices[ii++] = niv1;
42696
- if (sy !== nsy) {
42716
+ distances[current] = sy;
42717
+ if (sy === nsy) {
42718
+ clippings[current] = -1 - ndistance;
42719
+ }
42720
+ else {
42721
+ var mdistance = Math.abs(dx * (sy - py) + dy * px) * fl;
42722
+ maxDistance = Math.max(maxDistance, mdistance);
42723
+ clippings[current] = -1 - mdistance;
42697
42724
  var miv1 = iv++;
42698
42725
  var miv2 = miv1 << 1;
42699
- var mdistance = Math.abs(dx * (sy - py) + dy * px) * fl;
42700
42726
  vertices[miv2] = 0;
42701
42727
  vertices[miv2 + 1] = sy;
42702
42728
  clippings[miv1] = mdistance;
42703
- maxDistance = Math.max(maxDistance, mdistance);
42729
+ distances[miv1] = 0;
42704
42730
  lengths[miv1] = length + (-px * dx + (sy - py) * dy) * fl;
42705
42731
  uvs[miv2] = 0.5;
42706
42732
  uvs[miv2 + 1] = 0.5 * (sy / sizeY + 1);
@@ -42722,15 +42748,27 @@
42722
42748
  if (0 < maxDistance) {
42723
42749
  fdistance = 1 / maxDistance;
42724
42750
  }
42751
+ var shift = (scale - 1) * maxDistance;
42725
42752
  for (var i = 0; i < iv; ++i) {
42726
- distances[i] = fdistance;
42727
42753
  var clipping = clippings[i];
42728
42754
  if (0 <= clipping) {
42729
42755
  clippings[i] = 1 - clipping * fdistance;
42730
42756
  }
42731
42757
  else {
42758
+ var distance = -1 - clipping;
42759
+ if (0 < distance) {
42760
+ var i2 = i << 1;
42761
+ var factor = shift / distance;
42762
+ var x = vertices[i2] * (1 + factor);
42763
+ var y = vertices[i2 + 1] + (vertices[i2 + 1] - distances[i]) * factor;
42764
+ vertices[i2] = x;
42765
+ vertices[i2 + 1] = y;
42766
+ uvs[i2] = 0.5 * (x / sizeX + 1);
42767
+ uvs[i2 + 1] = 0.5 * (y / sizeY + 1);
42768
+ }
42732
42769
  clippings[i] = scale;
42733
42770
  }
42771
+ distances[i] = fdistance;
42734
42772
  }
42735
42773
  // The skeleton points of adjacent vertices may coincide on a nearly circular ellipse.
42736
42774
  this.pad(iv, ii, nv, ni, fdistance);