@rytass/wms-map-react-components 0.1.7 → 0.1.8
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/index.cjs.js +47 -25
- package/package.json +1 -1
- package/utils/api-data-transform.js +4 -7
- package/utils/map-data-transform.js +43 -18
package/index.cjs.js
CHANGED
|
@@ -282,11 +282,20 @@ const calculateStaggeredPosition = (index, baseX = 100, baseY = 100, viewportX,
|
|
|
282
282
|
{
|
|
283
283
|
// PathNode 轉換為 MapPolygonRange
|
|
284
284
|
const pathData = node.data;
|
|
285
|
+
const originSourcePointX = Math.min(...pathData.points.map((p)=>p.x));
|
|
286
|
+
const originSourcePointY = Math.min(...pathData.points.map((p)=>p.y));
|
|
287
|
+
const deltaX = node.position.x - originSourcePointX;
|
|
288
|
+
const deltaY = node.position.y - originSourcePointY;
|
|
289
|
+
// 將 node.position 偏移量加到每個 point 上,因為拖曳整個 node 時只更新 position 不更新 data.points
|
|
290
|
+
const absolutePoints = (pathData.points || []).map((p)=>({
|
|
291
|
+
x: p.x + deltaX,
|
|
292
|
+
y: p.y + deltaY
|
|
293
|
+
}));
|
|
285
294
|
const polygonRange = {
|
|
286
295
|
id: pathData.label || node.id,
|
|
287
296
|
type: MapRangeType.POLYGON,
|
|
288
297
|
color: pathData.color || '#0000FF',
|
|
289
|
-
points:
|
|
298
|
+
points: absolutePoints
|
|
290
299
|
};
|
|
291
300
|
ranges.push(polygonRange);
|
|
292
301
|
break;
|
|
@@ -375,27 +384,35 @@ const calculateStaggeredPosition = (index, baseX = 100, baseY = 100, viewportX,
|
|
|
375
384
|
case 'pathNode':
|
|
376
385
|
{
|
|
377
386
|
const pathData = node.data;
|
|
378
|
-
const
|
|
379
|
-
|
|
380
|
-
|
|
381
|
-
|
|
382
|
-
|
|
383
|
-
|
|
387
|
+
const originSourcePointX = Math.min(...pathData.points.map((p)=>p.x));
|
|
388
|
+
const originSourcePointY = Math.min(...pathData.points.map((p)=>p.y));
|
|
389
|
+
const deltaX = node.position.x - originSourcePointX;
|
|
390
|
+
const deltaY = node.position.y - originSourcePointY;
|
|
391
|
+
const absolutePoints = (pathData.points || []).map((p)=>({
|
|
392
|
+
x: p.x + deltaX,
|
|
393
|
+
y: p.y + deltaY
|
|
394
|
+
}));
|
|
384
395
|
const mapPolygonRange = {
|
|
385
396
|
id: pathData.label || node.id,
|
|
386
397
|
type: MapRangeType.POLYGON,
|
|
387
398
|
color: pathData.color || '#0000FF',
|
|
388
|
-
points:
|
|
399
|
+
points: absolutePoints
|
|
389
400
|
};
|
|
401
|
+
const absoluteBounds = absolutePoints.length > 0 ? {
|
|
402
|
+
minX: Math.min(...absolutePoints.map((p)=>p.x)),
|
|
403
|
+
minY: Math.min(...absolutePoints.map((p)=>p.y)),
|
|
404
|
+
maxX: Math.max(...absolutePoints.map((p)=>p.x)),
|
|
405
|
+
maxY: Math.max(...absolutePoints.map((p)=>p.y))
|
|
406
|
+
} : null;
|
|
390
407
|
const clickInfo = {
|
|
391
408
|
...baseInfo,
|
|
392
409
|
type: 'pathNode',
|
|
393
410
|
pathData: {
|
|
394
411
|
color: pathData.color || '#0000FF',
|
|
395
412
|
strokeWidth: pathData.strokeWidth || 2,
|
|
396
|
-
pointCount:
|
|
397
|
-
points:
|
|
398
|
-
bounds
|
|
413
|
+
pointCount: absolutePoints.length,
|
|
414
|
+
points: absolutePoints,
|
|
415
|
+
bounds: absoluteBounds
|
|
399
416
|
},
|
|
400
417
|
mapPolygonRange
|
|
401
418
|
};
|
|
@@ -479,25 +496,33 @@ const calculateStaggeredPosition = (index, baseX = 100, baseY = 100, viewportX,
|
|
|
479
496
|
case 'pathNode':
|
|
480
497
|
{
|
|
481
498
|
const pathData = node.data;
|
|
499
|
+
const originSourcePointX = Math.min(...pathData.points.map((p)=>p.x));
|
|
500
|
+
const originSourcePointY = Math.min(...pathData.points.map((p)=>p.y));
|
|
501
|
+
const deltaX = node.position.x - originSourcePointX;
|
|
502
|
+
const deltaY = node.position.y - originSourcePointY;
|
|
503
|
+
// 轉換格式(對應儲存時的格式)— 加上 node.position 偏移
|
|
504
|
+
const absoluteLogPoints = (pathData.points || []).map((p)=>({
|
|
505
|
+
x: p.x + deltaX,
|
|
506
|
+
y: p.y + deltaY
|
|
507
|
+
}));
|
|
482
508
|
console.log('🔗 路徑資訊:', {
|
|
483
509
|
color: pathData.color,
|
|
484
510
|
strokeWidth: pathData.strokeWidth,
|
|
485
511
|
pointCount: pathData.points?.length || 0,
|
|
486
512
|
points: pathData.points,
|
|
487
513
|
// 計算路徑邊界
|
|
488
|
-
bounds:
|
|
489
|
-
minX: Math.min(...
|
|
490
|
-
minY: Math.min(...
|
|
491
|
-
maxX: Math.max(...
|
|
492
|
-
maxY: Math.max(...
|
|
514
|
+
bounds: absoluteLogPoints?.length > 0 ? {
|
|
515
|
+
minX: Math.min(...absoluteLogPoints.map((p)=>p.x)),
|
|
516
|
+
minY: Math.min(...absoluteLogPoints.map((p)=>p.y)),
|
|
517
|
+
maxX: Math.max(...absoluteLogPoints.map((p)=>p.x)),
|
|
518
|
+
maxY: Math.max(...absoluteLogPoints.map((p)=>p.y))
|
|
493
519
|
} : null
|
|
494
520
|
});
|
|
495
|
-
// 轉換格式(對應儲存時的格式)
|
|
496
521
|
const polygonRange = {
|
|
497
522
|
id: node.id,
|
|
498
523
|
type: MapRangeType.POLYGON,
|
|
499
524
|
color: pathData.color || '#0000FF',
|
|
500
|
-
points:
|
|
525
|
+
points: absoluteLogPoints
|
|
501
526
|
};
|
|
502
527
|
console.log('💾 儲存格式 (MapPolygonRange):', polygonRange);
|
|
503
528
|
break;
|
|
@@ -4866,20 +4891,17 @@ const WMSMapModalContainer = ({ open, onClose, viewMode = ViewMode.EDIT, colorPa
|
|
|
4866
4891
|
};
|
|
4867
4892
|
} else if (range.type === MapRangeType.POLYGON) {
|
|
4868
4893
|
const polyRange = range;
|
|
4869
|
-
// 計算多邊形的中心點作為節點位置
|
|
4870
|
-
const centerX = polyRange.points.reduce((sum, point)=>sum + point.x, 0) / polyRange.points.length;
|
|
4871
|
-
const centerY = polyRange.points.reduce((sum, point)=>sum + point.y, 0) / polyRange.points.length;
|
|
4872
4894
|
// 將絕對座標轉換為相對於中心點的座標
|
|
4873
4895
|
const relativePoints = polyRange.points.map((point)=>({
|
|
4874
|
-
x: point.x
|
|
4875
|
-
y: point.y
|
|
4896
|
+
x: point.x,
|
|
4897
|
+
y: point.y
|
|
4876
4898
|
}));
|
|
4877
4899
|
return {
|
|
4878
4900
|
id: polyRange.id,
|
|
4879
4901
|
type: 'pathNode',
|
|
4880
4902
|
position: {
|
|
4881
|
-
x:
|
|
4882
|
-
y:
|
|
4903
|
+
x: Math.min(...polyRange.points.map((p)=>p.x)),
|
|
4904
|
+
y: Math.min(...polyRange.points.map((p)=>p.y))
|
|
4883
4905
|
},
|
|
4884
4906
|
data: {
|
|
4885
4907
|
points: relativePoints,
|
package/package.json
CHANGED
|
@@ -51,20 +51,17 @@ import { MapRangeType } from '../typings.js';
|
|
|
51
51
|
};
|
|
52
52
|
} else if (range.type === MapRangeType.POLYGON) {
|
|
53
53
|
const polyRange = range;
|
|
54
|
-
// 計算多邊形的中心點作為節點位置
|
|
55
|
-
const centerX = polyRange.points.reduce((sum, point)=>sum + point.x, 0) / polyRange.points.length;
|
|
56
|
-
const centerY = polyRange.points.reduce((sum, point)=>sum + point.y, 0) / polyRange.points.length;
|
|
57
54
|
// 將絕對座標轉換為相對於中心點的座標
|
|
58
55
|
const relativePoints = polyRange.points.map((point)=>({
|
|
59
|
-
x: point.x
|
|
60
|
-
y: point.y
|
|
56
|
+
x: point.x,
|
|
57
|
+
y: point.y
|
|
61
58
|
}));
|
|
62
59
|
return {
|
|
63
60
|
id: polyRange.id,
|
|
64
61
|
type: 'pathNode',
|
|
65
62
|
position: {
|
|
66
|
-
x:
|
|
67
|
-
y:
|
|
63
|
+
x: Math.min(...polyRange.points.map((p)=>p.x)),
|
|
64
|
+
y: Math.min(...polyRange.points.map((p)=>p.y))
|
|
68
65
|
},
|
|
69
66
|
data: {
|
|
70
67
|
points: relativePoints,
|
|
@@ -42,11 +42,20 @@ import { MapRangeType } from '../typings.js';
|
|
|
42
42
|
{
|
|
43
43
|
// PathNode 轉換為 MapPolygonRange
|
|
44
44
|
const pathData = node.data;
|
|
45
|
+
const originSourcePointX = Math.min(...pathData.points.map((p)=>p.x));
|
|
46
|
+
const originSourcePointY = Math.min(...pathData.points.map((p)=>p.y));
|
|
47
|
+
const deltaX = node.position.x - originSourcePointX;
|
|
48
|
+
const deltaY = node.position.y - originSourcePointY;
|
|
49
|
+
// 將 node.position 偏移量加到每個 point 上,因為拖曳整個 node 時只更新 position 不更新 data.points
|
|
50
|
+
const absolutePoints = (pathData.points || []).map((p)=>({
|
|
51
|
+
x: p.x + deltaX,
|
|
52
|
+
y: p.y + deltaY
|
|
53
|
+
}));
|
|
45
54
|
const polygonRange = {
|
|
46
55
|
id: pathData.label || node.id,
|
|
47
56
|
type: MapRangeType.POLYGON,
|
|
48
57
|
color: pathData.color || '#0000FF',
|
|
49
|
-
points:
|
|
58
|
+
points: absolutePoints
|
|
50
59
|
};
|
|
51
60
|
ranges.push(polygonRange);
|
|
52
61
|
break;
|
|
@@ -135,27 +144,35 @@ import { MapRangeType } from '../typings.js';
|
|
|
135
144
|
case 'pathNode':
|
|
136
145
|
{
|
|
137
146
|
const pathData = node.data;
|
|
138
|
-
const
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
147
|
+
const originSourcePointX = Math.min(...pathData.points.map((p)=>p.x));
|
|
148
|
+
const originSourcePointY = Math.min(...pathData.points.map((p)=>p.y));
|
|
149
|
+
const deltaX = node.position.x - originSourcePointX;
|
|
150
|
+
const deltaY = node.position.y - originSourcePointY;
|
|
151
|
+
const absolutePoints = (pathData.points || []).map((p)=>({
|
|
152
|
+
x: p.x + deltaX,
|
|
153
|
+
y: p.y + deltaY
|
|
154
|
+
}));
|
|
144
155
|
const mapPolygonRange = {
|
|
145
156
|
id: pathData.label || node.id,
|
|
146
157
|
type: MapRangeType.POLYGON,
|
|
147
158
|
color: pathData.color || '#0000FF',
|
|
148
|
-
points:
|
|
159
|
+
points: absolutePoints
|
|
149
160
|
};
|
|
161
|
+
const absoluteBounds = absolutePoints.length > 0 ? {
|
|
162
|
+
minX: Math.min(...absolutePoints.map((p)=>p.x)),
|
|
163
|
+
minY: Math.min(...absolutePoints.map((p)=>p.y)),
|
|
164
|
+
maxX: Math.max(...absolutePoints.map((p)=>p.x)),
|
|
165
|
+
maxY: Math.max(...absolutePoints.map((p)=>p.y))
|
|
166
|
+
} : null;
|
|
150
167
|
const clickInfo = {
|
|
151
168
|
...baseInfo,
|
|
152
169
|
type: 'pathNode',
|
|
153
170
|
pathData: {
|
|
154
171
|
color: pathData.color || '#0000FF',
|
|
155
172
|
strokeWidth: pathData.strokeWidth || 2,
|
|
156
|
-
pointCount:
|
|
157
|
-
points:
|
|
158
|
-
bounds
|
|
173
|
+
pointCount: absolutePoints.length,
|
|
174
|
+
points: absolutePoints,
|
|
175
|
+
bounds: absoluteBounds
|
|
159
176
|
},
|
|
160
177
|
mapPolygonRange
|
|
161
178
|
};
|
|
@@ -239,25 +256,33 @@ import { MapRangeType } from '../typings.js';
|
|
|
239
256
|
case 'pathNode':
|
|
240
257
|
{
|
|
241
258
|
const pathData = node.data;
|
|
259
|
+
const originSourcePointX = Math.min(...pathData.points.map((p)=>p.x));
|
|
260
|
+
const originSourcePointY = Math.min(...pathData.points.map((p)=>p.y));
|
|
261
|
+
const deltaX = node.position.x - originSourcePointX;
|
|
262
|
+
const deltaY = node.position.y - originSourcePointY;
|
|
263
|
+
// 轉換格式(對應儲存時的格式)— 加上 node.position 偏移
|
|
264
|
+
const absoluteLogPoints = (pathData.points || []).map((p)=>({
|
|
265
|
+
x: p.x + deltaX,
|
|
266
|
+
y: p.y + deltaY
|
|
267
|
+
}));
|
|
242
268
|
console.log('🔗 路徑資訊:', {
|
|
243
269
|
color: pathData.color,
|
|
244
270
|
strokeWidth: pathData.strokeWidth,
|
|
245
271
|
pointCount: pathData.points?.length || 0,
|
|
246
272
|
points: pathData.points,
|
|
247
273
|
// 計算路徑邊界
|
|
248
|
-
bounds:
|
|
249
|
-
minX: Math.min(...
|
|
250
|
-
minY: Math.min(...
|
|
251
|
-
maxX: Math.max(...
|
|
252
|
-
maxY: Math.max(...
|
|
274
|
+
bounds: absoluteLogPoints?.length > 0 ? {
|
|
275
|
+
minX: Math.min(...absoluteLogPoints.map((p)=>p.x)),
|
|
276
|
+
minY: Math.min(...absoluteLogPoints.map((p)=>p.y)),
|
|
277
|
+
maxX: Math.max(...absoluteLogPoints.map((p)=>p.x)),
|
|
278
|
+
maxY: Math.max(...absoluteLogPoints.map((p)=>p.y))
|
|
253
279
|
} : null
|
|
254
280
|
});
|
|
255
|
-
// 轉換格式(對應儲存時的格式)
|
|
256
281
|
const polygonRange = {
|
|
257
282
|
id: node.id,
|
|
258
283
|
type: MapRangeType.POLYGON,
|
|
259
284
|
color: pathData.color || '#0000FF',
|
|
260
|
-
points:
|
|
285
|
+
points: absoluteLogPoints
|
|
261
286
|
};
|
|
262
287
|
console.log('💾 儲存格式 (MapPolygonRange):', polygonRange);
|
|
263
288
|
break;
|