@fleet-frontend/mower-maps 0.2.1 → 0.2.3

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.
Files changed (5) hide show
  1. package/dist/index.esm.js +48 -37
  2. package/dist/index.js +48 -37
  3. package/dist/render/MowerMapRenderer.d.ts.map +1 -1
  4. package/dist/render/svgEditMap/hooks/useCheckElement.d.ts.map +1 -1
  5. package/package.json +1 -1
package/dist/index.esm.js CHANGED
@@ -23387,23 +23387,26 @@ const useCheckElement = () => {
23387
23387
  return doodleTransformedPoints.some((point) => isPointInPolygon(point, currentBoundaryPoints));
23388
23388
  });
23389
23389
  // 4. 检查当前 obstacle 和 doodle 不能相交，且间隔要大于2m
23390
- // console.log('doodlesInBoundary--->', doodlesInBoundary);
23391
23390
  for (const doodle of doodlesInBoundary) {
23392
- const doodleTransformedPoints = transformSvgElements(doodle).flat();
23393
- // 检查相交
23394
- if (doPolygonsIntersect(currentObstaclePolygon, doodleTransformedPoints)) {
23395
- return {
23396
- result: true,
23397
- code: CheckObstaclePointErrorType.DOODLE_INTERSECT,
23398
- };
23399
- }
23400
- // 检查距离
23401
- const distance = polygonToPolygonDistance(currentObstaclePolygon, doodleTransformedPoints);
23402
- if (distance < minDistance) {
23403
- return {
23404
- result: true,
23405
- code: CheckObstaclePointErrorType.DOODLE_DISTANCE_TOO_CLOSE,
23406
- };
23391
+ // doodle 转换后的数据是二维数组，数组的每一项都是一个polygon，这里之所以不用flat()扁平处理
23392
+ // 因为多个polygon可能会有相交/相切的情况，单纯flat会导致无法处理flat后的不正常的矩形数据
23393
+ const doodleTransformedPoints = transformSvgElements(doodle);
23394
+ for (const points of doodleTransformedPoints) {
23395
+ // 检查相交
23396
+ if (doPolygonsIntersect(currentObstaclePolygon, points)) {
23397
+ return {
23398
+ result: true,
23399
+ code: CheckObstaclePointErrorType.DOODLE_INTERSECT,
23400
+ };
23401
+ }
23402
+ // 检查距离
23403
+ const distance = polygonToPolygonDistance(currentObstaclePolygon, points);
23404
+ if (distance < minDistance) {
23405
+ return {
23406
+ result: true,
23407
+ code: CheckObstaclePointErrorType.DOODLE_DISTANCE_TOO_CLOSE,
23408
+ };
23409
+ }
23407
23410
  }
23408
23411
  }
23409
23412
  return {
@@ -23478,7 +23481,7 @@ const groupCoordinatesByType = (coordinates, autoClose = true) => {
23478
23481
  }
23479
23482
  // 只有在需要自动闭合时才处理封闭边界
23480
23483
  if (autoClose) {
23481
- if (segments.length > 1 && segments[0].type === segments[segments.length - 1].type) {
23484
+ if (segments.length > 1) {
23482
23485
  const firstSegment = segments[0];
23483
23486
  const lastSegment = segments[segments.length - 1];
23484
23487
  // 将第一个点添加到最后一段，形成封闭
@@ -28845,7 +28848,9 @@ modelType, showStraddleBoundaryBorder = true, mapRef, mapJson, pathJson, realTim
28845
28848
  const [processStateIsMowing, setProcessStateIsMowing] = useState(false);
28846
28849
  const [currentMowingPartitionId, setCurrentMowingPartitionId] = useState('');
28847
28850
  const [mowPartitionData, setMowPartitionData] = useState(null);
28851
+ const mowPartitionDataRef = useRef(null);
28848
28852
  const isTaskDelayRef = useRef(false);
28853
+ const currentVehicleStateRef = useRef(undefined);
28849
28854
  // drag.x/y 现在存储的是 EPSG:3857 投影坐标的偏移量（米）
28850
28855
  const [drag, setDrag] = useState({
28851
28856
  x: 0,
@@ -29151,62 +29156,68 @@ modelType, showStraddleBoundaryBorder = true, mapRef, mapJson, pathJson, realTim
29151
29156
  if (!realTimeData || realTimeData.length === 0 || !Array.isArray(realTimeData)) {
29152
29157
  return;
29153
29158
  }
29154
- let curMowPartitionData = mowPartitionData;
29159
+ // let curMowPartitionData = mowPartitionData;
29155
29160
  // realtime中包含当前割草任务的数据，根据数据进行path路径和边界的高亮操作,
29156
29161
  const mowingPartition = realTimeData.find((item) => item.type === RealTimeDataType.PARTITION);
29157
29162
  if (mowingPartition) {
29158
29163
  setMowPartitionData(mowingPartition);
29159
- curMowPartitionData = mowingPartition;
29164
+ mowPartitionDataRef.current = mowingPartition;
29160
29165
  }
29161
29166
  // 获取当前的割草
29162
29167
  const vehicleStatusData = realTimeData?.find((item) => item?.type === RealTimeDataType.STATUS);
29163
29168
  if (vehicleStatusData) {
29164
29169
  // console.error('vehicleStatusData 000---->', vehicleStatusData?.taskDelay);
29165
29170
  // 如果上一次状态是true，当前变成了false，则认为不需要高亮分区
29166
- if (isTaskDelayRef.current === true && vehicleStatusData?.taskDelay === false) {
29167
- // 兜底收不到割草地块的实时数据，使用状态来兜底
29168
- setMowingPartitions(undefined);
29169
- setMowPartitionData({});
29170
- curMowPartitionData = {};
29171
- }
29171
+ // if(isTaskDelayRef.current === true && vehicleStatusData?.taskDelay === false) {
29172
+ // // 兜底收不到割草地块的实时数据，使用状态来兜底
29173
+ // setMowingPartitions(undefined);
29174
+ // setMowPartitionData({});
29175
+ // // curMowPartitionData = {};
29176
+ // mowPartitionDataRef.current = {};
29177
+ // // console.error('0.50.5--mowPartitionDataRef.current---->', mowPartitionDataRef.current);
29178
+ // }
29172
29179
  isTaskDelayRef.current = vehicleStatusData?.taskDelay !== undefined ? vehicleStatusData?.taskDelay : isTaskDelayRef.current;
29173
29180
  // console.error('isTaskDelayRef.current 111---->', isTaskDelayRef.current);
29174
29181
  }
29175
29182
  const positionData = realTimeData?.find((item) => item?.type === RealTimeDataType.LOCATION);
29176
29183
  // 如果当前是taskDelay的状态，或者状态为mowing或者standby，则指定的地块需要高亮，或者全局高亮
29177
29184
  if ((isTaskDelayRef.current || positionData?.vehicleState === RobotStatus.MOWING || positionData?.vehicleState === RobotStatus.STANDBY) &&
29178
- curMowPartitionData &&
29179
- !curMowPartitionData?.partitionIds) {
29185
+ mowPartitionDataRef.current &&
29186
+ !mowPartitionDataRef.current?.partitionIds) {
29180
29187
  // 设置全局高亮
29181
- if (curMowPartitionData &&
29182
- !curMowPartitionData?.partitionIds) {
29188
+ if (mowPartitionDataRef.current &&
29189
+ !mowPartitionDataRef.current?.partitionIds) {
29183
29190
  const allPartitionIds = generateBoundaryData(mapJson)
29184
29191
  ?.filter((item) => !item?.isIsolated)
29185
29192
  .map((item) => item?.id);
29186
29193
  setMowPartitionData({
29187
29194
  partitionIds: allPartitionIds,
29188
29195
  });
29189
- curMowPartitionData = {
29196
+ mowPartitionDataRef.current = {
29190
29197
  partitionIds: allPartitionIds,
29191
29198
  };
29192
29199
  }
29193
29200
  }
29194
- else if (!isTaskDelayRef.current && positionData?.vehicleState === RobotStatus.WORKING) {
29201
+ else if (!isTaskDelayRef.current && positionData?.vehicleState === RobotStatus.WORKING && (currentVehicleStateRef.current === RobotStatus.MOWING || currentVehicleStateRef.current === RobotStatus.STANDBY)) {
29202
+ // 非deskDelay的状态下
29203
+ // 1. 如果当前是working状态，且上一次是mowing或者standby状态，则取消高亮
29195
29204
  // 兜底收不到割草地块的实时数据，使用状态来兜底
29196
29205
  setMowingPartitions(undefined);
29197
29206
  setMowPartitionData({});
29198
- curMowPartitionData = {};
29207
+ mowPartitionDataRef.current = {};
29199
29208
  }
29209
+ // 更新当前车辆状态
29210
+ currentVehicleStateRef.current = positionData?.vehicleState !== undefined ? positionData?.vehicleState : currentVehicleStateRef.current;
29200
29211
  if (!mapJson || !svgMapRef.current)
29201
29212
  return;
29202
29213
  // 根据后端推送的实时数据，进行不同处理
29203
- if (curMowPartitionData) {
29204
- const isMowing = curMowPartitionData?.partitionIds && curMowPartitionData.partitionIds.length > 0;
29214
+ if (mowPartitionDataRef.current) {
29215
+ const isMowing = mowPartitionDataRef.current?.partitionIds && mowPartitionDataRef.current.partitionIds.length > 0;
29205
29216
  if (!isMowing) {
29206
29217
  setMowingPartitions(undefined);
29207
29218
  }
29208
29219
  else {
29209
- setMowingPartitions(curMowPartitionData?.partitionIds);
29220
+ setMowingPartitions(mowPartitionDataRef.current?.partitionIds);
29210
29221
  }
29211
29222
  }
29212
29223
  if (!pathJson)
@@ -29225,7 +29236,7 @@ modelType, showStraddleBoundaryBorder = true, mapRef, mapJson, pathJson, realTim
29225
29236
  setCurrentMowingPartitionId(currentMowingPartition);
29226
29237
  }
29227
29238
  if (pathData) {
29228
- svgMapRef.current?.updatePathData?.(pathData, curMowPartitionData);
29239
+ svgMapRef.current?.updatePathData?.(pathData, mowPartitionDataRef.current);
29229
29240
  }
29230
29241
  }
29231
29242
  else {
@@ -29239,7 +29250,7 @@ modelType, showStraddleBoundaryBorder = true, mapRef, mapJson, pathJson, realTim
29239
29250
  if (currentMowingPartition !== currentMowingPartitionId) {
29240
29251
  setCurrentMowingPartitionId(currentMowingPartition);
29241
29252
  }
29242
- svgMapRef.current?.updatePathData?.(pathData, curMowPartitionData);
29253
+ svgMapRef.current?.updatePathData?.(pathData, mowPartitionDataRef.current);
29243
29254
  }
29244
29255
  }, [realTimeData, mapJson, pathJson, sn]);
29245
29256
  useEffect(() => {
package/dist/index.js CHANGED
@@ -23407,23 +23407,26 @@ const useCheckElement = () => {
23407
23407
  return doodleTransformedPoints.some((point) => isPointInPolygon(point, currentBoundaryPoints));
23408
23408
  });
23409
23409
  // 4. 检查当前 obstacle 和 doodle 不能相交，且间隔要大于2m
23410
- // console.log('doodlesInBoundary--->', doodlesInBoundary);
23411
23410
  for (const doodle of doodlesInBoundary) {
23412
- const doodleTransformedPoints = transformSvgElements(doodle).flat();
23413
- // 检查相交
23414
- if (doPolygonsIntersect(currentObstaclePolygon, doodleTransformedPoints)) {
23415
- return {
23416
- result: true,
23417
- code: exports.CheckObstaclePointErrorType.DOODLE_INTERSECT,
23418
- };
23419
- }
23420
- // 检查距离
23421
- const distance = polygonToPolygonDistance(currentObstaclePolygon, doodleTransformedPoints);
23422
- if (distance < minDistance) {
23423
- return {
23424
- result: true,
23425
- code: exports.CheckObstaclePointErrorType.DOODLE_DISTANCE_TOO_CLOSE,
23426
- };
23411
+ // doodle 转换后的数据是二维数组，数组的每一项都是一个polygon，这里之所以不用flat()扁平处理
23412
+ // 因为多个polygon可能会有相交/相切的情况，单纯flat会导致无法处理flat后的不正常的矩形数据
23413
+ const doodleTransformedPoints = transformSvgElements(doodle);
23414
+ for (const points of doodleTransformedPoints) {
23415
+ // 检查相交
23416
+ if (doPolygonsIntersect(currentObstaclePolygon, points)) {
23417
+ return {
23418
+ result: true,
23419
+ code: exports.CheckObstaclePointErrorType.DOODLE_INTERSECT,
23420
+ };
23421
+ }
23422
+ // 检查距离
23423
+ const distance = polygonToPolygonDistance(currentObstaclePolygon, points);
23424
+ if (distance < minDistance) {
23425
+ return {
23426
+ result: true,
23427
+ code: exports.CheckObstaclePointErrorType.DOODLE_DISTANCE_TOO_CLOSE,
23428
+ };
23429
+ }
23427
23430
  }
23428
23431
  }
23429
23432
  return {
@@ -23498,7 +23501,7 @@ const groupCoordinatesByType = (coordinates, autoClose = true) => {
23498
23501
  }
23499
23502
  // 只有在需要自动闭合时才处理封闭边界
23500
23503
  if (autoClose) {
23501
- if (segments.length > 1 && segments[0].type === segments[segments.length - 1].type) {
23504
+ if (segments.length > 1) {
23502
23505
  const firstSegment = segments[0];
23503
23506
  const lastSegment = segments[segments.length - 1];
23504
23507
  // 将第一个点添加到最后一段，形成封闭
@@ -28865,7 +28868,9 @@ modelType, showStraddleBoundaryBorder = true, mapRef, mapJson, pathJson, realTim
28865
28868
  const [processStateIsMowing, setProcessStateIsMowing] = React.useState(false);
28866
28869
  const [currentMowingPartitionId, setCurrentMowingPartitionId] = React.useState('');
28867
28870
  const [mowPartitionData, setMowPartitionData] = React.useState(null);
28871
+ const mowPartitionDataRef = React.useRef(null);
28868
28872
  const isTaskDelayRef = React.useRef(false);
28873
+ const currentVehicleStateRef = React.useRef(undefined);
28869
28874
  // drag.x/y 现在存储的是 EPSG:3857 投影坐标的偏移量（米）
28870
28875
  const [drag, setDrag] = React.useState({
28871
28876
  x: 0,
@@ -29171,62 +29176,68 @@ modelType, showStraddleBoundaryBorder = true, mapRef, mapJson, pathJson, realTim
29171
29176
  if (!realTimeData || realTimeData.length === 0 || !Array.isArray(realTimeData)) {
29172
29177
  return;
29173
29178
  }
29174
- let curMowPartitionData = mowPartitionData;
29179
+ // let curMowPartitionData = mowPartitionData;
29175
29180
  // realtime中包含当前割草任务的数据，根据数据进行path路径和边界的高亮操作,
29176
29181
  const mowingPartition = realTimeData.find((item) => item.type === RealTimeDataType.PARTITION);
29177
29182
  if (mowingPartition) {
29178
29183
  setMowPartitionData(mowingPartition);
29179
- curMowPartitionData = mowingPartition;
29184
+ mowPartitionDataRef.current = mowingPartition;
29180
29185
  }
29181
29186
  // 获取当前的割草
29182
29187
  const vehicleStatusData = realTimeData?.find((item) => item?.type === RealTimeDataType.STATUS);
29183
29188
  if (vehicleStatusData) {
29184
29189
  // console.error('vehicleStatusData 000---->', vehicleStatusData?.taskDelay);
29185
29190
  // 如果上一次状态是true，当前变成了false，则认为不需要高亮分区
29186
- if (isTaskDelayRef.current === true && vehicleStatusData?.taskDelay === false) {
29187
- // 兜底收不到割草地块的实时数据，使用状态来兜底
29188
- setMowingPartitions(undefined);
29189
- setMowPartitionData({});
29190
- curMowPartitionData = {};
29191
- }
29191
+ // if(isTaskDelayRef.current === true && vehicleStatusData?.taskDelay === false) {
29192
+ // // 兜底收不到割草地块的实时数据，使用状态来兜底
29193
+ // setMowingPartitions(undefined);
29194
+ // setMowPartitionData({});
29195
+ // // curMowPartitionData = {};
29196
+ // mowPartitionDataRef.current = {};
29197
+ // // console.error('0.50.5--mowPartitionDataRef.current---->', mowPartitionDataRef.current);
29198
+ // }
29192
29199
  isTaskDelayRef.current = vehicleStatusData?.taskDelay !== undefined ? vehicleStatusData?.taskDelay : isTaskDelayRef.current;
29193
29200
  // console.error('isTaskDelayRef.current 111---->', isTaskDelayRef.current);
29194
29201
  }
29195
29202
  const positionData = realTimeData?.find((item) => item?.type === RealTimeDataType.LOCATION);
29196
29203
  // 如果当前是taskDelay的状态，或者状态为mowing或者standby，则指定的地块需要高亮，或者全局高亮
29197
29204
  if ((isTaskDelayRef.current || positionData?.vehicleState === RobotStatus.MOWING || positionData?.vehicleState === RobotStatus.STANDBY) &&
29198
- curMowPartitionData &&
29199
- !curMowPartitionData?.partitionIds) {
29205
+ mowPartitionDataRef.current &&
29206
+ !mowPartitionDataRef.current?.partitionIds) {
29200
29207
  // 设置全局高亮
29201
- if (curMowPartitionData &&
29202
- !curMowPartitionData?.partitionIds) {
29208
+ if (mowPartitionDataRef.current &&
29209
+ !mowPartitionDataRef.current?.partitionIds) {
29203
29210
  const allPartitionIds = generateBoundaryData(mapJson)
29204
29211
  ?.filter((item) => !item?.isIsolated)
29205
29212
  .map((item) => item?.id);
29206
29213
  setMowPartitionData({
29207
29214
  partitionIds: allPartitionIds,
29208
29215
  });
29209
- curMowPartitionData = {
29216
+ mowPartitionDataRef.current = {
29210
29217
  partitionIds: allPartitionIds,
29211
29218
  };
29212
29219
  }
29213
29220
  }
29214
- else if (!isTaskDelayRef.current && positionData?.vehicleState === RobotStatus.WORKING) {
29221
+ else if (!isTaskDelayRef.current && positionData?.vehicleState === RobotStatus.WORKING && (currentVehicleStateRef.current === RobotStatus.MOWING || currentVehicleStateRef.current === RobotStatus.STANDBY)) {
29222
+ // 非deskDelay的状态下
29223
+ // 1. 如果当前是working状态，且上一次是mowing或者standby状态，则取消高亮
29215
29224
  // 兜底收不到割草地块的实时数据，使用状态来兜底
29216
29225
  setMowingPartitions(undefined);
29217
29226
  setMowPartitionData({});
29218
- curMowPartitionData = {};
29227
+ mowPartitionDataRef.current = {};
29219
29228
  }
29229
+ // 更新当前车辆状态
29230
+ currentVehicleStateRef.current = positionData?.vehicleState !== undefined ? positionData?.vehicleState : currentVehicleStateRef.current;
29220
29231
  if (!mapJson || !svgMapRef.current)
29221
29232
  return;
29222
29233
  // 根据后端推送的实时数据，进行不同处理
29223
- if (curMowPartitionData) {
29224
- const isMowing = curMowPartitionData?.partitionIds && curMowPartitionData.partitionIds.length > 0;
29234
+ if (mowPartitionDataRef.current) {
29235
+ const isMowing = mowPartitionDataRef.current?.partitionIds && mowPartitionDataRef.current.partitionIds.length > 0;
29225
29236
  if (!isMowing) {
29226
29237
  setMowingPartitions(undefined);
29227
29238
  }
29228
29239
  else {
29229
- setMowingPartitions(curMowPartitionData?.partitionIds);
29240
+ setMowingPartitions(mowPartitionDataRef.current?.partitionIds);
29230
29241
  }
29231
29242
  }
29232
29243
  if (!pathJson)
@@ -29245,7 +29256,7 @@ modelType, showStraddleBoundaryBorder = true, mapRef, mapJson, pathJson, realTim
29245
29256
  setCurrentMowingPartitionId(currentMowingPartition);
29246
29257
  }
29247
29258
  if (pathData) {
29248
- svgMapRef.current?.updatePathData?.(pathData, curMowPartitionData);
29259
+ svgMapRef.current?.updatePathData?.(pathData, mowPartitionDataRef.current);
29249
29260
  }
29250
29261
  }
29251
29262
  else {
@@ -29259,7 +29270,7 @@ modelType, showStraddleBoundaryBorder = true, mapRef, mapJson, pathJson, realTim
29259
29270
  if (currentMowingPartition !== currentMowingPartitionId) {
29260
29271
  setCurrentMowingPartitionId(currentMowingPartition);
29261
29272
  }
29262
- svgMapRef.current?.updatePathData?.(pathData, curMowPartitionData);
29273
+ svgMapRef.current?.updatePathData?.(pathData, mowPartitionDataRef.current);
29263
29274
  }
29264
29275
  }, [realTimeData, mapJson, pathJson, sn]);
29265
29276
  React.useEffect(() => {
package/dist/render/MowerMapRenderer.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"MowerMapRenderer.d.ts","sourceRoot":"","sources":["../../src/render/MowerMapRenderer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAQN,MAAM,OAAO,CAAC;AAuBf,OAAO,EAGL,qBAAqB,EACrB,mBAAmB,EACpB,MAAM,mBAAmB,CAAC;AA0B3B,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,GAAG,CAAC;KACb;CACF;AA8FD,eAAO,MAAM,gBAAgB,mGAwuB5B,CAAC;AAIF,eAAe,gBAAgB,CAAC;AAChC,YAAY,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,CAAC"}
1
+ {"version":3,"file":"MowerMapRenderer.d.ts","sourceRoot":"","sources":["../../src/render/MowerMapRenderer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAQN,MAAM,OAAO,CAAC;AAuBf,OAAO,EAGL,qBAAqB,EACrB,mBAAmB,EACpB,MAAM,mBAAmB,CAAC;AA0B3B,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,GAAG,CAAC;KACb;CACF;AA8FD,eAAO,MAAM,gBAAgB,mGAgvB5B,CAAC;AAIF,eAAe,gBAAgB,CAAC;AAChC,YAAY,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,CAAC"}
package/dist/render/svgEditMap/hooks/useCheckElement.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"useCheckElement.d.ts","sourceRoot":"","sources":["../../../../src/render/svgEditMap/hooks/useCheckElement.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,oBAAoB,EAAE,2BAA2B,EAAE,MAAM,gBAAgB,CAAC;AAGnF,eAAO,MAAM,eAAe;uBAIU;QAClC,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,IAAI,CAAC,EAAE,oBAAoB,CAAC;KAC7B;8CA+He;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,gBACtB,MAAM,EAAE,EAAE,KACvB;QAAE,MAAM,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,2BAA2B,CAAA;KAAE;CAyH7D,CAAC"}
1
+ {"version":3,"file":"useCheckElement.d.ts","sourceRoot":"","sources":["../../../../src/render/svgEditMap/hooks/useCheckElement.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,oBAAoB,EAAE,2BAA2B,EAAE,MAAM,gBAAgB,CAAC;AAGnF,eAAO,MAAM,eAAe;uBAIU;QAClC,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,IAAI,CAAC,EAAE,oBAAoB,CAAC;KAC7B;8CA+He;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,gBACtB,MAAM,EAAE,EAAE,KACvB;QAAE,MAAM,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,2BAA2B,CAAA;KAAE;CA2H7D,CAAC"}
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@fleet-frontend/mower-maps",
3
- "version": "0.2.1",
3
+ "version": "0.2.3",
4
4
  "type": "module",
5
5
  "description": "a mower maps in google maps",
6
6
  "main": "dist/index.js",