@turf/directional-mean 7.0.0-alpha.1 → 7.0.0-alpha.110

package/README.md

@@ -56,26 +56,21 @@ Returns **[DirectionalMeanLine][6]** Directional Mean Line
 
 [6]: #directionalmeanline
 
-<!-- This file is automatically generated. Please don't edit it directly:
-if you find an error, edit the source file (likely index.js), and re-run
-./scripts/generate-readmes in the turf project. -->
+<!-- This file is automatically generated. Please don't edit it directly. If you find an error, edit the source file of the module in question (likely index.js or index.ts), and re-run "yarn docs" from the root of the turf project. -->
 
 ---
 
-This module is part of the [Turfjs project](http://turfjs.org/), an open source
-module collection dedicated to geographic algorithms. It is maintained in the
-[Turfjs/turf](https://github.com/Turfjs/turf) repository, where you can create
-PRs and issues.
+This module is part of the [Turfjs project](https://turfjs.org/), an open source module collection dedicated to geographic algorithms. It is maintained in the [Turfjs/turf](https://github.com/Turfjs/turf) repository, where you can create PRs and issues.
 
 ### Installation
 
-Install this module individually:
+Install this single module individually:
 
 ```sh
 $ npm install @turf/directional-mean
 ```
 
-Or install the Turf module that includes it as a function:
+Or install the all-encompassing @turf/turf module that includes all modules as functions:
 
 ```sh
 $ npm install @turf/turf

package/dist/cjs/index.cjs

@@ -0,0 +1,211 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// index.ts
+var _bearing = require('@turf/bearing');
+var _centroid = require('@turf/centroid');
+var _destination = require('@turf/destination');
+var _helpers = require('@turf/helpers');
+var _invariant = require('@turf/invariant');
+var _length = require('@turf/length');
+var _meta = require('@turf/meta');
+function directionalMean(lines, options = {}) {
+  var _a;
+  const isPlanar = !!options.planar;
+  const isSegment = (_a = options.segment) != null ? _a : false;
+  let sigmaSin = 0;
+  let sigmaCos = 0;
+  let countOfLines = 0;
+  let sumOfLen = 0;
+  const centroidList = [];
+  if (isSegment) {
+    _meta.segmentEach.call(void 0, lines, (currentSegment) => {
+      const [sin1, cos1] = getCosAndSin(
+        currentSegment.geometry.coordinates,
+        isPlanar
+      );
+      const lenOfLine = getLengthOfLineString(currentSegment, isPlanar);
+      if (isNaN(sin1) || isNaN(cos1)) {
+        return;
+      } else {
+        sigmaSin += sin1;
+        sigmaCos += cos1;
+        countOfLines += 1;
+        sumOfLen += lenOfLine;
+        centroidList.push(_centroid.centroid.call(void 0, currentSegment));
+      }
+    });
+  } else {
+    _meta.featureEach.call(void 0, lines, (currentFeature) => {
+      if (currentFeature.geometry.type !== "LineString") {
+        throw new Error("shold to support MultiLineString?");
+      }
+      const [sin1, cos1] = getCosAndSin(
+        currentFeature.geometry.coordinates,
+        isPlanar
+      );
+      const lenOfLine = getLengthOfLineString(currentFeature, isPlanar);
+      if (isNaN(sin1) || isNaN(cos1)) {
+        return;
+      } else {
+        sigmaSin += sin1;
+        sigmaCos += cos1;
+        countOfLines += 1;
+        sumOfLen += lenOfLine;
+        centroidList.push(_centroid.centroid.call(void 0, currentFeature));
+      }
+    });
+  }
+  const cartesianAngle = getAngleBySinAndCos(sigmaSin, sigmaCos);
+  const bearingAngle = bearingToCartesian(cartesianAngle);
+  const circularVariance = getCircularVariance(
+    sigmaSin,
+    sigmaCos,
+    countOfLines
+  );
+  const averageLength = sumOfLen / countOfLines;
+  const centroidOfLines = _centroid.centroid.call(void 0, _helpers.featureCollection.call(void 0, centroidList));
+  const [averageX, averageY] = _invariant.getCoord.call(void 0, centroidOfLines);
+  let meanLinestring;
+  if (isPlanar) {
+    meanLinestring = getMeanLineString(
+      [averageX, averageY],
+      cartesianAngle,
+      averageLength,
+      isPlanar
+    );
+  } else {
+    meanLinestring = getMeanLineString(
+      [averageX, averageY],
+      bearingAngle,
+      averageLength,
+      isPlanar
+    );
+  }
+  return _helpers.lineString.call(void 0, meanLinestring, {
+    averageLength,
+    averageX,
+    averageY,
+    bearingAngle,
+    cartesianAngle,
+    circularVariance,
+    countOfLines
+  });
+}
+__name(directionalMean, "directionalMean");
+function euclideanDistance(coords) {
+  const [x0, y0] = coords[0];
+  const [x1, y1] = coords[1];
+  const dx = x1 - x0;
+  const dy = y1 - y0;
+  return Math.sqrt(Math.pow(dx, 2) + Math.pow(dy, 2));
+}
+__name(euclideanDistance, "euclideanDistance");
+function getLengthOfLineString(line, isPlanar) {
+  if (isPlanar) {
+    return _meta.segmentReduce.call(void 0, 
+      line,
+      (previousValue, segment) => {
+        const coords = segment.geometry.coordinates;
+        return previousValue + euclideanDistance(coords);
+      },
+      0
+    );
+  } else {
+    return _length.length.call(void 0, line, {
+      units: "meters"
+    });
+  }
+}
+__name(getLengthOfLineString, "getLengthOfLineString");
+function bearingToCartesian(angle) {
+  let result = 90 - angle;
+  if (result > 180) {
+    result -= 360;
+  }
+  return result;
+}
+__name(bearingToCartesian, "bearingToCartesian");
+function getCosAndSin(coordinates, isPlanar) {
+  const beginPoint = coordinates[0];
+  const endPoint = coordinates[coordinates.length - 1];
+  if (isPlanar) {
+    const [x0, y0] = beginPoint;
+    const [x1, y1] = endPoint;
+    const dx = x1 - x0;
+    const dy = y1 - y0;
+    const h = Math.sqrt(Math.pow(dx, 2) + Math.pow(dy, 2));
+    if (h < 1e-9) {
+      return [NaN, NaN];
+    }
+    const sin1 = dy / h;
+    const cos1 = dx / h;
+    return [sin1, cos1];
+  } else {
+    const angle = bearingToCartesian(_bearing.bearing.call(void 0, beginPoint, endPoint));
+    const radian = angle * Math.PI / 180;
+    return [Math.sin(radian), Math.cos(radian)];
+  }
+}
+__name(getCosAndSin, "getCosAndSin");
+function getAngleBySinAndCos(sin1, cos1) {
+  let angle = 0;
+  if (Math.abs(cos1) < 1e-9) {
+    angle = 90;
+  } else {
+    angle = Math.atan2(sin1, cos1) * 180 / Math.PI;
+  }
+  if (sin1 >= 0) {
+    if (cos1 < 0) {
+      angle += 180;
+    }
+  } else {
+    if (cos1 < 0) {
+      angle -= 180;
+    }
+  }
+  return angle;
+}
+__name(getAngleBySinAndCos, "getAngleBySinAndCos");
+function getCircularVariance(sin1, cos1, len) {
+  if (len === 0) {
+    throw new Error("the size of the features set must be greater than 0");
+  }
+  return 1 - Math.sqrt(Math.pow(sin1, 2) + Math.pow(cos1, 2)) / len;
+}
+__name(getCircularVariance, "getCircularVariance");
+function getMeanLineString(centroidOfLine, angle, lenOfLine, isPlanar) {
+  if (isPlanar) {
+    const [averageX, averageY] = centroidOfLine;
+    let beginX;
+    let beginY;
+    let endX;
+    let endY;
+    const r = angle * Math.PI / 180;
+    const sin = Math.sin(r);
+    const cos = Math.cos(r);
+    beginX = averageX - lenOfLine / 2 * cos;
+    beginY = averageY - lenOfLine / 2 * sin;
+    endX = averageX + lenOfLine / 2 * cos;
+    endY = averageY + lenOfLine / 2 * sin;
+    return [
+      [beginX, beginY],
+      [endX, endY]
+    ];
+  } else {
+    const end = _destination.destination.call(void 0, _helpers.point.call(void 0, centroidOfLine), lenOfLine / 2, angle, {
+      units: "meters"
+    });
+    const begin = _destination.destination.call(void 0, _helpers.point.call(void 0, centroidOfLine), -lenOfLine / 2, angle, {
+      units: "meters"
+    });
+    return [_invariant.getCoord.call(void 0, begin), _invariant.getCoord.call(void 0, end)];
+  }
+}
+__name(getMeanLineString, "getMeanLineString");
+var turf_directional_mean_default = directionalMean;
+
+
+
+exports.default = turf_directional_mean_default; exports.directionalMean = directionalMean;
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../index.ts"],"names":[],"mappings":";;;;AACA,SAAS,eAAe;AACxB,SAAS,gBAAgB;AACzB,SAAS,mBAAmB;AAC5B,SAAS,mBAAmB,YAAY,aAAa;AACrD,SAAS,gBAAgB;AACzB,SAAS,cAAc;AACvB,SAAS,aAAa,aAAa,qBAAqB;AA8CxD,SAAS,gBACP,OACA,UAGI,CAAC,GACgB;AA3DvB;AA4DE,QAAM,WAAW,CAAC,CAAC,QAAQ;AAC3B,QAAM,aAAqB,aAAQ,YAAR,YAAmB;AAC9C,MAAI,WAAW;AACf,MAAI,WAAW;AACf,MAAI,eAAe;AACnB,MAAI,WAAW;AACf,QAAM,eAAsC,CAAC;AAE7C,MAAI,WAAW;AACb,gBAAY,OAAO,CAAC,mBAAwB;AAE1C,YAAM,CAAC,MAAM,IAAI,IAAsB;AAAA,QACrC,eAAe,SAAS;AAAA,QACxB;AAAA,MACF;AACA,YAAM,YAAY,sBAAsB,gBAAgB,QAAQ;AAChE,UAAI,MAAM,IAAI,KAAK,MAAM,IAAI,GAAG;AAC9B;AAAA,MACF,OAAO;AACL,oBAAY;AACZ,oBAAY;AACZ,wBAAgB;AAChB,oBAAY;AACZ,qBAAa,KAAK,SAAS,cAAc,CAAC;AAAA,MAC5C;AAAA,IACF,CAAC;AAAA,EAEH,OAAO;AAEL,gBAAY,OAAO,CAAC,mBAAwC;AAC1D,UAAI,eAAe,SAAS,SAAS,cAAc;AACjD,cAAM,IAAI,MAAM,mCAAmC;AAAA,MACrD;AACA,YAAM,CAAC,MAAM,IAAI,IAAsB;AAAA,QACrC,eAAe,SAAS;AAAA,QACxB;AAAA,MACF;AACA,YAAM,YAAY,sBAAsB,gBAAgB,QAAQ;AAChE,UAAI,MAAM,IAAI,KAAK,MAAM,IAAI,GAAG;AAC9B;AAAA,MACF,OAAO;AACL,oBAAY;AACZ,oBAAY;AACZ,wBAAgB;AAChB,oBAAY;AACZ,qBAAa,KAAK,SAAS,cAAc,CAAC;AAAA,MAC5C;AAAA,IACF,CAAC;AAAA,EACH;AAEA,QAAM,iBAAyB,oBAAoB,UAAU,QAAQ;AACrE,QAAM,eAAuB,mBAAmB,cAAc;AAC9D,QAAM,mBAAmB;AAAA,IACvB;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACA,QAAM,gBAAgB,WAAW;AACjC,QAAM,kBAAkB,SAAS,kBAAkB,YAAY,CAAC;AAChE,QAAM,CAAC,UAAU,QAAQ,IAAc,SAAS,eAAe;AAC/D,MAAI;AACJ,MAAI,UAAU;AACZ,qBAAiB;AAAA,MACf,CAAC,UAAU,QAAQ;AAAA,MACnB;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF,OAAO;AACL,qBAAiB;AAAA,MACf,CAAC,UAAU,QAAQ;AAAA,MACnB;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAEA,SAAO,WAAW,gBAAgB;AAAA,IAChC;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AACH;AA7FS;AAqGT,SAAS,kBAAkB,QAAoB;AAC7C,QAAM,CAAC,IAAI,EAAE,IAAc,OAAO,CAAC;AACnC,QAAM,CAAC,IAAI,EAAE,IAAc,OAAO,CAAC;AACnC,QAAM,KAAa,KAAK;AACxB,QAAM,KAAa,KAAK;AACxB,SAAO,KAAK,KAAK,KAAK,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,IAAI,CAAC,CAAC;AACpD;AANS;AAeT,SAAS,sBAAsB,MAA2B,UAAmB;AAC3E,MAAI,UAAU;AACZ,WAAO;AAAA,MACL;AAAA,MACA,CAAC,eAAwB,YAA0C;AACjE,cAAM,SAAS,QAAS,SAAS;AACjC,eAAO,gBAAiB,kBAAkB,MAAM;AAAA,MAClD;AAAA,MACA;AAAA,IACF;AAAA,EACF,OAAO;AACL,WAAO,OAAO,MAAM;AAAA,MAClB,OAAO;AAAA,IACT,CAAC;AAAA,EACH;AACF;AAfS;AAwBT,SAAS,mBAAmB,OAAuB;AACjD,MAAI,SAAS,KAAK;AAClB,MAAI,SAAS,KAAK;AAChB,cAAU;AAAA,EACZ;AACA,SAAO;AACT;AANS;AAcT,SAAS,aACP,aACA,UACkB;AAClB,QAAM,aAAuB,YAAY,CAAC;AAC1C,QAAM,WAAqB,YAAY,YAAY,SAAS,CAAC;AAC7D,MAAI,UAAU;AACZ,UAAM,CAAC,IAAI,EAAE,IAAc;AAC3B,UAAM,CAAC,IAAI,EAAE,IAAc;AAC3B,UAAM,KAAa,KAAK;AACxB,UAAM,KAAa,KAAK;AACxB,UAAM,IAAI,KAAK,KAAK,KAAK,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,IAAI,CAAC,CAAC;AACrD,QAAI,IAAI,MAAa;AACnB,aAAO,CAAC,KAAK,GAAG;AAAA,IAClB;AACA,UAAM,OAAO,KAAK;AAClB,UAAM,OAAO,KAAK;AAClB,WAAO,CAAC,MAAM,IAAI;AAAA,EACpB,OAAO;AACL,UAAM,QAAQ,mBAAmB,QAAQ,YAAY,QAAQ,CAAC;AAC9D,UAAM,SAAU,QAAQ,KAAK,KAAM;AACnC,WAAO,CAAC,KAAK,IAAI,MAAM,GAAG,KAAK,IAAI,MAAM,CAAC;AAAA,EAC5C;AACF;AAvBS;AAyBT,SAAS,oBAAoB,MAAc,MAAsB;AAC/D,MAAI,QAAQ;AACZ,MAAI,KAAK,IAAI,IAAI,IAAI,MAAa;AAChC,YAAQ;AAAA,EACV,OAAO;AACL,YAAS,KAAK,MAAM,MAAM,IAAI,IAAI,MAAO,KAAK;AAAA,EAChD;AACA,MAAI,QAAQ,GAAG;AACb,QAAI,OAAO,GAAG;AACZ,eAAS;AAAA,IACX;AAAA,EACF,OAAO;AACL,QAAI,OAAO,GAAG;AACZ,eAAS;AAAA,IACX;AAAA,EACF;AACA,SAAO;AACT;AAjBS;AAmBT,SAAS,oBAAoB,MAAc,MAAc,KAAa;AACpE,MAAI,QAAQ,GAAG;AACb,UAAM,IAAI,MAAM,qDAAqD;AAAA,EACvE;AACA,SAAO,IAAI,KAAK,KAAK,KAAK,IAAI,MAAM,CAAC,IAAI,KAAK,IAAI,MAAM,CAAC,CAAC,IAAI;AAChE;AALS;AAOT,SAAS,kBACP,gBACA,OACA,WACA,UACA;AACA,MAAI,UAAU;AACZ,UAAM,CAAC,UAAU,QAAQ,IAAc;AACvC,QAAI;AACJ,QAAI;AACJ,QAAI;AACJ,QAAI;AACJ,UAAM,IAAa,QAAQ,KAAK,KAAM;AACtC,UAAM,MAAc,KAAK,IAAI,CAAC;AAC9B,UAAM,MAAc,KAAK,IAAI,CAAC;AAC9B,aAAS,WAAY,YAAY,IAAK;AACtC,aAAS,WAAY,YAAY,IAAK;AACtC,WAAO,WAAY,YAAY,IAAK;AACpC,WAAO,WAAY,YAAY,IAAK;AACpC,WAAO;AAAA,MACL,CAAC,QAAQ,MAAM;AAAA,MACf,CAAC,MAAM,IAAI;AAAA,IACb;AAAA,EACF,OAAO;AACL,UAAM,MAAM,YAAY,MAAM,cAAc,GAAG,YAAY,GAAG,OAAO;AAAA,MACnE,OAAO;AAAA,IACT,CAAC;AACD,UAAM,QAAQ,YAAY,MAAM,cAAc,GAAG,CAAC,YAAY,GAAG,OAAO;AAAA,MACtE,OAAO;AAAA,IACT,CAAC;AACD,WAAO,CAAC,SAAS,KAAK,GAAG,SAAS,GAAG,CAAC;AAAA,EACxC;AACF;AAhCS;AAmCT,IAAO,gCAAQ","sourcesContent":["import { Feature, FeatureCollection, LineString, Point } from \"geojson\";\nimport { bearing } from \"@turf/bearing\";\nimport { centroid } from \"@turf/centroid\";\nimport { destination } from \"@turf/destination\";\nimport { featureCollection, lineString, point } from \"@turf/helpers\";\nimport { getCoord } from \"@turf/invariant\";\nimport { length } from \"@turf/length\";\nimport { featureEach, segmentEach, segmentReduce } from \"@turf/meta\";\n\ninterface DirectionalMeanLine extends Feature<LineString> {\n  properties: {\n    cartesianAngle: number;\n    bearingAngle: number;\n    circularVariance: number;\n    averageX: number;\n    averageY: number;\n    averageLength: number;\n    countOfLines: number;\n    [key: string]: any;\n  };\n}\n\n/**\n * @typedef {Object} DirectionalMeanLine\n * @property {number} cartesianAngle the mean angle of all lines. (measure from due earth counterclockwise).\n * @property {number} bearingAngle the mean angle of all lines. (bearing).\n * @property {number} circularVariance the extent to which features all point in the same direction.\n *  the value ranges 0-1, the bigger the value, the more variation in directions between lines.\n * @property {number} averageX the centroid of all lines.\n * @property {number} averageY the centroid of all line.\n * @property {number} averageLength the average length of line.\n * @property {number} countOfLines the count of features.\n */\n\n/**\n * This module calculate the average angle of a set of lines, measuring the trend of it.\n * It can be used in both project coordinate system and geography coordinate system.\n * It can handle segments of line or the whole line.\n * @name directionalMean\n * @param {FeatureCollection<LineString>} lines\n * @param {object} [options={}]\n * @param {boolean} [options.planar=true] whether the spatial reference system is projected or geographical.\n * @param {boolean} [options.segment=false] whether treat a LineString as a whole or a set of segments.\n * @returns {DirectionalMeanLine} Directional Mean Line\n * @example\n *\n * var lines = turf.lineStrings([\n *   [[110, 45], [120, 50]],\n *   [[100, 50], [115, 55]],\n * ])\n * var directionalMeanLine = turf.directionalMean(lines);\n * // => directionalMeanLine\n */\nfunction directionalMean(\n  lines: FeatureCollection<LineString>,\n  options: {\n    planar?: boolean;\n    segment?: boolean;\n  } = {}\n): DirectionalMeanLine {\n  const isPlanar = !!options.planar; // you can't use options.planar || true here.\n  const isSegment: boolean = options.segment ?? false;\n  let sigmaSin = 0;\n  let sigmaCos = 0;\n  let countOfLines = 0;\n  let sumOfLen = 0;\n  const centroidList: Array<Feature<Point>> = [];\n\n  if (isSegment) {\n    segmentEach(lines, (currentSegment: any) => {\n      // todo fix turf-meta's declaration file\n      const [sin1, cos1]: [number, number] = getCosAndSin(\n        currentSegment.geometry.coordinates,\n        isPlanar\n      );\n      const lenOfLine = getLengthOfLineString(currentSegment, isPlanar);\n      if (isNaN(sin1) || isNaN(cos1)) {\n        return;\n      } else {\n        sigmaSin += sin1;\n        sigmaCos += cos1;\n        countOfLines += 1;\n        sumOfLen += lenOfLine;\n        centroidList.push(centroid(currentSegment));\n      }\n    });\n    // planar and segment\n  } else {\n    // planar and non-segment\n    featureEach(lines, (currentFeature: Feature<LineString>) => {\n      if (currentFeature.geometry.type !== \"LineString\") {\n        throw new Error(\"shold to support MultiLineString?\");\n      }\n      const [sin1, cos1]: [number, number] = getCosAndSin(\n        currentFeature.geometry.coordinates,\n        isPlanar\n      );\n      const lenOfLine = getLengthOfLineString(currentFeature, isPlanar);\n      if (isNaN(sin1) || isNaN(cos1)) {\n        return;\n      } else {\n        sigmaSin += sin1;\n        sigmaCos += cos1;\n        countOfLines += 1;\n        sumOfLen += lenOfLine;\n        centroidList.push(centroid(currentFeature));\n      }\n    });\n  }\n\n  const cartesianAngle: number = getAngleBySinAndCos(sigmaSin, sigmaCos);\n  const bearingAngle: number = bearingToCartesian(cartesianAngle);\n  const circularVariance = getCircularVariance(\n    sigmaSin,\n    sigmaCos,\n    countOfLines\n  );\n  const averageLength = sumOfLen / countOfLines;\n  const centroidOfLines = centroid(featureCollection(centroidList));\n  const [averageX, averageY]: number[] = getCoord(centroidOfLines);\n  let meanLinestring;\n  if (isPlanar) {\n    meanLinestring = getMeanLineString(\n      [averageX, averageY],\n      cartesianAngle,\n      averageLength,\n      isPlanar\n    );\n  } else {\n    meanLinestring = getMeanLineString(\n      [averageX, averageY],\n      bearingAngle,\n      averageLength,\n      isPlanar\n    );\n  }\n\n  return lineString(meanLinestring, {\n    averageLength,\n    averageX,\n    averageY,\n    bearingAngle,\n    cartesianAngle,\n    circularVariance,\n    countOfLines,\n  });\n}\n\n/**\n * get euclidean distance between two points.\n * @private\n * @name euclideanDistance\n * @param coords\n */\nfunction euclideanDistance(coords: number[][]) {\n  const [x0, y0]: number[] = coords[0];\n  const [x1, y1]: number[] = coords[1];\n  const dx: number = x1 - x0;\n  const dy: number = y1 - y0;\n  return Math.sqrt(Math.pow(dx, 2) + Math.pow(dy, 2));\n}\n\n/**\n * get the length of a LineString, both in projected or geographical coordinate system.\n * @private\n * @name getLengthOfLineString\n * @param {Feature<LineString>} line\n * @param {boolean} isPlanar\n */\nfunction getLengthOfLineString(line: Feature<LineString>, isPlanar: boolean) {\n  if (isPlanar) {\n    return segmentReduce<number>(\n      line,\n      (previousValue?: number, segment?: Feature<LineString>): number => {\n        const coords = segment!.geometry.coordinates; // the signatrue of segmentReduce has problem ?\n        return previousValue! + euclideanDistance(coords);\n      },\n      0\n    );\n  } else {\n    return length(line, {\n      units: \"meters\",\n    });\n  }\n}\n\n/**\n * bearing to xy(from due earth counterclockwise 0-180)\n * convert between two forms\n * @private\n * @name bearingToCartesian\n * @param angle\n */\nfunction bearingToCartesian(angle: number): number {\n  let result = 90 - angle;\n  if (result > 180) {\n    result -= 360;\n  }\n  return result;\n}\n\n/**\n * @private\n * @name getCosAndSin\n * @param {Array<Array<number>>} coordinates\n * @returns {Array<number>} [cos, sin]\n */\nfunction getCosAndSin(\n  coordinates: number[][],\n  isPlanar: boolean\n): [number, number] {\n  const beginPoint: number[] = coordinates[0];\n  const endPoint: number[] = coordinates[coordinates.length - 1];\n  if (isPlanar) {\n    const [x0, y0]: number[] = beginPoint;\n    const [x1, y1]: number[] = endPoint;\n    const dx: number = x1 - x0;\n    const dy: number = y1 - y0;\n    const h = Math.sqrt(Math.pow(dx, 2) + Math.pow(dy, 2));\n    if (h < 0.000000001) {\n      return [NaN, NaN];\n    }\n    const sin1 = dy / h;\n    const cos1 = dx / h;\n    return [sin1, cos1];\n  } else {\n    const angle = bearingToCartesian(bearing(beginPoint, endPoint));\n    const radian = (angle * Math.PI) / 180;\n    return [Math.sin(radian), Math.cos(radian)];\n  }\n}\n\nfunction getAngleBySinAndCos(sin1: number, cos1: number): number {\n  let angle = 0;\n  if (Math.abs(cos1) < 0.000000001) {\n    angle = 90;\n  } else {\n    angle = (Math.atan2(sin1, cos1) * 180) / Math.PI;\n  }\n  if (sin1 >= 0) {\n    if (cos1 < 0) {\n      angle += 180;\n    }\n  } else {\n    if (cos1 < 0) {\n      angle -= 180;\n    }\n  }\n  return angle;\n}\n\nfunction getCircularVariance(sin1: number, cos1: number, len: number) {\n  if (len === 0) {\n    throw new Error(\"the size of the features set must be greater than 0\");\n  }\n  return 1 - Math.sqrt(Math.pow(sin1, 2) + Math.pow(cos1, 2)) / len;\n}\n\nfunction getMeanLineString(\n  centroidOfLine: number[],\n  angle: number,\n  lenOfLine: number,\n  isPlanar: boolean\n) {\n  if (isPlanar) {\n    const [averageX, averageY]: number[] = centroidOfLine;\n    let beginX: number;\n    let beginY: number;\n    let endX: number;\n    let endY: number;\n    const r: number = (angle * Math.PI) / 180;\n    const sin: number = Math.sin(r);\n    const cos: number = Math.cos(r);\n    beginX = averageX - (lenOfLine / 2) * cos;\n    beginY = averageY - (lenOfLine / 2) * sin;\n    endX = averageX + (lenOfLine / 2) * cos;\n    endY = averageY + (lenOfLine / 2) * sin;\n    return [\n      [beginX, beginY],\n      [endX, endY],\n    ];\n  } else {\n    const end = destination(point(centroidOfLine), lenOfLine / 2, angle, {\n      units: \"meters\",\n    });\n    const begin = destination(point(centroidOfLine), -lenOfLine / 2, angle, {\n      units: \"meters\",\n    });\n    return [getCoord(begin), getCoord(end)];\n  }\n}\n\nexport { directionalMean, DirectionalMeanLine };\nexport default directionalMean;\n"]}

package/dist/{js → cjs}/index.d.ts

@@ -1,5 +1,6 @@
-import { Feature, FeatureCollection, LineString } from "geojson";
-export interface DirectionalMeanLine extends Feature<LineString> {
+import { Feature, LineString, FeatureCollection } from 'geojson';
+
+interface DirectionalMeanLine extends Feature<LineString> {
     properties: {
         cartesianAngle: number;
         bearingAngle: number;
@@ -41,7 +42,9 @@ export interface DirectionalMeanLine extends Feature<LineString> {
  * var directionalMeanLine = turf.directionalMean(lines);
  * // => directionalMeanLine
  */
-export default function directionalMean(lines: FeatureCollection<LineString>, options?: {
+declare function directionalMean(lines: FeatureCollection<LineString>, options?: {
     planar?: boolean;
     segment?: boolean;
 }): DirectionalMeanLine;
+
+export { type DirectionalMeanLine, directionalMean as default, directionalMean };

package/dist/esm/index.d.mts

@@ -0,0 +1,50 @@
+import { Feature, LineString, FeatureCollection } from 'geojson';
+
+interface DirectionalMeanLine extends Feature<LineString> {
+    properties: {
+        cartesianAngle: number;
+        bearingAngle: number;
+        circularVariance: number;
+        averageX: number;
+        averageY: number;
+        averageLength: number;
+        countOfLines: number;
+        [key: string]: any;
+    };
+}
+/**
+ * @typedef {Object} DirectionalMeanLine
+ * @property {number} cartesianAngle the mean angle of all lines. (measure from due earth counterclockwise).
+ * @property {number} bearingAngle the mean angle of all lines. (bearing).
+ * @property {number} circularVariance the extent to which features all point in the same direction.
+ *  the value ranges 0-1, the bigger the value, the more variation in directions between lines.
+ * @property {number} averageX the centroid of all lines.
+ * @property {number} averageY the centroid of all line.
+ * @property {number} averageLength the average length of line.
+ * @property {number} countOfLines the count of features.
+ */
+/**
+ * This module calculate the average angle of a set of lines, measuring the trend of it.
+ * It can be used in both project coordinate system and geography coordinate system.
+ * It can handle segments of line or the whole line.
+ * @name directionalMean
+ * @param {FeatureCollection<LineString>} lines
+ * @param {object} [options={}]
+ * @param {boolean} [options.planar=true] whether the spatial reference system is projected or geographical.
+ * @param {boolean} [options.segment=false] whether treat a LineString as a whole or a set of segments.
+ * @returns {DirectionalMeanLine} Directional Mean Line
+ * @example
+ *
+ * var lines = turf.lineStrings([
+ *   [[110, 45], [120, 50]],
+ *   [[100, 50], [115, 55]],
+ * ])
+ * var directionalMeanLine = turf.directionalMean(lines);
+ * // => directionalMeanLine
+ */
+declare function directionalMean(lines: FeatureCollection<LineString>, options?: {
+    planar?: boolean;
+    segment?: boolean;
+}): DirectionalMeanLine;
+
+export { type DirectionalMeanLine, directionalMean as default, directionalMean };

package/dist/esm/index.mjs

@@ -0,0 +1,211 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// index.ts
+import { bearing } from "@turf/bearing";
+import { centroid } from "@turf/centroid";
+import { destination } from "@turf/destination";
+import { featureCollection, lineString, point } from "@turf/helpers";
+import { getCoord } from "@turf/invariant";
+import { length } from "@turf/length";
+import { featureEach, segmentEach, segmentReduce } from "@turf/meta";
+function directionalMean(lines, options = {}) {
+  var _a;
+  const isPlanar = !!options.planar;
+  const isSegment = (_a = options.segment) != null ? _a : false;
+  let sigmaSin = 0;
+  let sigmaCos = 0;
+  let countOfLines = 0;
+  let sumOfLen = 0;
+  const centroidList = [];
+  if (isSegment) {
+    segmentEach(lines, (currentSegment) => {
+      const [sin1, cos1] = getCosAndSin(
+        currentSegment.geometry.coordinates,
+        isPlanar
+      );
+      const lenOfLine = getLengthOfLineString(currentSegment, isPlanar);
+      if (isNaN(sin1) || isNaN(cos1)) {
+        return;
+      } else {
+        sigmaSin += sin1;
+        sigmaCos += cos1;
+        countOfLines += 1;
+        sumOfLen += lenOfLine;
+        centroidList.push(centroid(currentSegment));
+      }
+    });
+  } else {
+    featureEach(lines, (currentFeature) => {
+      if (currentFeature.geometry.type !== "LineString") {
+        throw new Error("shold to support MultiLineString?");
+      }
+      const [sin1, cos1] = getCosAndSin(
+        currentFeature.geometry.coordinates,
+        isPlanar
+      );
+      const lenOfLine = getLengthOfLineString(currentFeature, isPlanar);
+      if (isNaN(sin1) || isNaN(cos1)) {
+        return;
+      } else {
+        sigmaSin += sin1;
+        sigmaCos += cos1;
+        countOfLines += 1;
+        sumOfLen += lenOfLine;
+        centroidList.push(centroid(currentFeature));
+      }
+    });
+  }
+  const cartesianAngle = getAngleBySinAndCos(sigmaSin, sigmaCos);
+  const bearingAngle = bearingToCartesian(cartesianAngle);
+  const circularVariance = getCircularVariance(
+    sigmaSin,
+    sigmaCos,
+    countOfLines
+  );
+  const averageLength = sumOfLen / countOfLines;
+  const centroidOfLines = centroid(featureCollection(centroidList));
+  const [averageX, averageY] = getCoord(centroidOfLines);
+  let meanLinestring;
+  if (isPlanar) {
+    meanLinestring = getMeanLineString(
+      [averageX, averageY],
+      cartesianAngle,
+      averageLength,
+      isPlanar
+    );
+  } else {
+    meanLinestring = getMeanLineString(
+      [averageX, averageY],
+      bearingAngle,
+      averageLength,
+      isPlanar
+    );
+  }
+  return lineString(meanLinestring, {
+    averageLength,
+    averageX,
+    averageY,
+    bearingAngle,
+    cartesianAngle,
+    circularVariance,
+    countOfLines
+  });
+}
+__name(directionalMean, "directionalMean");
+function euclideanDistance(coords) {
+  const [x0, y0] = coords[0];
+  const [x1, y1] = coords[1];
+  const dx = x1 - x0;
+  const dy = y1 - y0;
+  return Math.sqrt(Math.pow(dx, 2) + Math.pow(dy, 2));
+}
+__name(euclideanDistance, "euclideanDistance");
+function getLengthOfLineString(line, isPlanar) {
+  if (isPlanar) {
+    return segmentReduce(
+      line,
+      (previousValue, segment) => {
+        const coords = segment.geometry.coordinates;
+        return previousValue + euclideanDistance(coords);
+      },
+      0
+    );
+  } else {
+    return length(line, {
+      units: "meters"
+    });
+  }
+}
+__name(getLengthOfLineString, "getLengthOfLineString");
+function bearingToCartesian(angle) {
+  let result = 90 - angle;
+  if (result > 180) {
+    result -= 360;
+  }
+  return result;
+}
+__name(bearingToCartesian, "bearingToCartesian");
+function getCosAndSin(coordinates, isPlanar) {
+  const beginPoint = coordinates[0];
+  const endPoint = coordinates[coordinates.length - 1];
+  if (isPlanar) {
+    const [x0, y0] = beginPoint;
+    const [x1, y1] = endPoint;
+    const dx = x1 - x0;
+    const dy = y1 - y0;
+    const h = Math.sqrt(Math.pow(dx, 2) + Math.pow(dy, 2));
+    if (h < 1e-9) {
+      return [NaN, NaN];
+    }
+    const sin1 = dy / h;
+    const cos1 = dx / h;
+    return [sin1, cos1];
+  } else {
+    const angle = bearingToCartesian(bearing(beginPoint, endPoint));
+    const radian = angle * Math.PI / 180;
+    return [Math.sin(radian), Math.cos(radian)];
+  }
+}
+__name(getCosAndSin, "getCosAndSin");
+function getAngleBySinAndCos(sin1, cos1) {
+  let angle = 0;
+  if (Math.abs(cos1) < 1e-9) {
+    angle = 90;
+  } else {
+    angle = Math.atan2(sin1, cos1) * 180 / Math.PI;
+  }
+  if (sin1 >= 0) {
+    if (cos1 < 0) {
+      angle += 180;
+    }
+  } else {
+    if (cos1 < 0) {
+      angle -= 180;
+    }
+  }
+  return angle;
+}
+__name(getAngleBySinAndCos, "getAngleBySinAndCos");
+function getCircularVariance(sin1, cos1, len) {
+  if (len === 0) {
+    throw new Error("the size of the features set must be greater than 0");
+  }
+  return 1 - Math.sqrt(Math.pow(sin1, 2) + Math.pow(cos1, 2)) / len;
+}
+__name(getCircularVariance, "getCircularVariance");
+function getMeanLineString(centroidOfLine, angle, lenOfLine, isPlanar) {
+  if (isPlanar) {
+    const [averageX, averageY] = centroidOfLine;
+    let beginX;
+    let beginY;
+    let endX;
+    let endY;
+    const r = angle * Math.PI / 180;
+    const sin = Math.sin(r);
+    const cos = Math.cos(r);
+    beginX = averageX - lenOfLine / 2 * cos;
+    beginY = averageY - lenOfLine / 2 * sin;
+    endX = averageX + lenOfLine / 2 * cos;
+    endY = averageY + lenOfLine / 2 * sin;
+    return [
+      [beginX, beginY],
+      [endX, endY]
+    ];
+  } else {
+    const end = destination(point(centroidOfLine), lenOfLine / 2, angle, {
+      units: "meters"
+    });
+    const begin = destination(point(centroidOfLine), -lenOfLine / 2, angle, {
+      units: "meters"
+    });
+    return [getCoord(begin), getCoord(end)];
+  }
+}
+__name(getMeanLineString, "getMeanLineString");
+var turf_directional_mean_default = directionalMean;
+export {
+  turf_directional_mean_default as default,
+  directionalMean
+};
+//# sourceMappingURL=index.mjs.map

package/dist/esm/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../index.ts"],"sourcesContent":["import { Feature, FeatureCollection, LineString, Point } from \"geojson\";\nimport { bearing } from \"@turf/bearing\";\nimport { centroid } from \"@turf/centroid\";\nimport { destination } from \"@turf/destination\";\nimport { featureCollection, lineString, point } from \"@turf/helpers\";\nimport { getCoord } from \"@turf/invariant\";\nimport { length } from \"@turf/length\";\nimport { featureEach, segmentEach, segmentReduce } from \"@turf/meta\";\n\ninterface DirectionalMeanLine extends Feature<LineString> {\n  properties: {\n    cartesianAngle: number;\n    bearingAngle: number;\n    circularVariance: number;\n    averageX: number;\n    averageY: number;\n    averageLength: number;\n    countOfLines: number;\n    [key: string]: any;\n  };\n}\n\n/**\n * @typedef {Object} DirectionalMeanLine\n * @property {number} cartesianAngle the mean angle of all lines. (measure from due earth counterclockwise).\n * @property {number} bearingAngle the mean angle of all lines. (bearing).\n * @property {number} circularVariance the extent to which features all point in the same direction.\n *  the value ranges 0-1, the bigger the value, the more variation in directions between lines.\n * @property {number} averageX the centroid of all lines.\n * @property {number} averageY the centroid of all line.\n * @property {number} averageLength the average length of line.\n * @property {number} countOfLines the count of features.\n */\n\n/**\n * This module calculate the average angle of a set of lines, measuring the trend of it.\n * It can be used in both project coordinate system and geography coordinate system.\n * It can handle segments of line or the whole line.\n * @name directionalMean\n * @param {FeatureCollection<LineString>} lines\n * @param {object} [options={}]\n * @param {boolean} [options.planar=true] whether the spatial reference system is projected or geographical.\n * @param {boolean} [options.segment=false] whether treat a LineString as a whole or a set of segments.\n * @returns {DirectionalMeanLine} Directional Mean Line\n * @example\n *\n * var lines = turf.lineStrings([\n *   [[110, 45], [120, 50]],\n *   [[100, 50], [115, 55]],\n * ])\n * var directionalMeanLine = turf.directionalMean(lines);\n * // => directionalMeanLine\n */\nfunction directionalMean(\n  lines: FeatureCollection<LineString>,\n  options: {\n    planar?: boolean;\n    segment?: boolean;\n  } = {}\n): DirectionalMeanLine {\n  const isPlanar = !!options.planar; // you can't use options.planar || true here.\n  const isSegment: boolean = options.segment ?? false;\n  let sigmaSin = 0;\n  let sigmaCos = 0;\n  let countOfLines = 0;\n  let sumOfLen = 0;\n  const centroidList: Array<Feature<Point>> = [];\n\n  if (isSegment) {\n    segmentEach(lines, (currentSegment: any) => {\n      // todo fix turf-meta's declaration file\n      const [sin1, cos1]: [number, number] = getCosAndSin(\n        currentSegment.geometry.coordinates,\n        isPlanar\n      );\n      const lenOfLine = getLengthOfLineString(currentSegment, isPlanar);\n      if (isNaN(sin1) || isNaN(cos1)) {\n        return;\n      } else {\n        sigmaSin += sin1;\n        sigmaCos += cos1;\n        countOfLines += 1;\n        sumOfLen += lenOfLine;\n        centroidList.push(centroid(currentSegment));\n      }\n    });\n    // planar and segment\n  } else {\n    // planar and non-segment\n    featureEach(lines, (currentFeature: Feature<LineString>) => {\n      if (currentFeature.geometry.type !== \"LineString\") {\n        throw new Error(\"shold to support MultiLineString?\");\n      }\n      const [sin1, cos1]: [number, number] = getCosAndSin(\n        currentFeature.geometry.coordinates,\n        isPlanar\n      );\n      const lenOfLine = getLengthOfLineString(currentFeature, isPlanar);\n      if (isNaN(sin1) || isNaN(cos1)) {\n        return;\n      } else {\n        sigmaSin += sin1;\n        sigmaCos += cos1;\n        countOfLines += 1;\n        sumOfLen += lenOfLine;\n        centroidList.push(centroid(currentFeature));\n      }\n    });\n  }\n\n  const cartesianAngle: number = getAngleBySinAndCos(sigmaSin, sigmaCos);\n  const bearingAngle: number = bearingToCartesian(cartesianAngle);\n  const circularVariance = getCircularVariance(\n    sigmaSin,\n    sigmaCos,\n    countOfLines\n  );\n  const averageLength = sumOfLen / countOfLines;\n  const centroidOfLines = centroid(featureCollection(centroidList));\n  const [averageX, averageY]: number[] = getCoord(centroidOfLines);\n  let meanLinestring;\n  if (isPlanar) {\n    meanLinestring = getMeanLineString(\n      [averageX, averageY],\n      cartesianAngle,\n      averageLength,\n      isPlanar\n    );\n  } else {\n    meanLinestring = getMeanLineString(\n      [averageX, averageY],\n      bearingAngle,\n      averageLength,\n      isPlanar\n    );\n  }\n\n  return lineString(meanLinestring, {\n    averageLength,\n    averageX,\n    averageY,\n    bearingAngle,\n    cartesianAngle,\n    circularVariance,\n    countOfLines,\n  });\n}\n\n/**\n * get euclidean distance between two points.\n * @private\n * @name euclideanDistance\n * @param coords\n */\nfunction euclideanDistance(coords: number[][]) {\n  const [x0, y0]: number[] = coords[0];\n  const [x1, y1]: number[] = coords[1];\n  const dx: number = x1 - x0;\n  const dy: number = y1 - y0;\n  return Math.sqrt(Math.pow(dx, 2) + Math.pow(dy, 2));\n}\n\n/**\n * get the length of a LineString, both in projected or geographical coordinate system.\n * @private\n * @name getLengthOfLineString\n * @param {Feature<LineString>} line\n * @param {boolean} isPlanar\n */\nfunction getLengthOfLineString(line: Feature<LineString>, isPlanar: boolean) {\n  if (isPlanar) {\n    return segmentReduce<number>(\n      line,\n      (previousValue?: number, segment?: Feature<LineString>): number => {\n        const coords = segment!.geometry.coordinates; // the signatrue of segmentReduce has problem ?\n        return previousValue! + euclideanDistance(coords);\n      },\n      0\n    );\n  } else {\n    return length(line, {\n      units: \"meters\",\n    });\n  }\n}\n\n/**\n * bearing to xy(from due earth counterclockwise 0-180)\n * convert between two forms\n * @private\n * @name bearingToCartesian\n * @param angle\n */\nfunction bearingToCartesian(angle: number): number {\n  let result = 90 - angle;\n  if (result > 180) {\n    result -= 360;\n  }\n  return result;\n}\n\n/**\n * @private\n * @name getCosAndSin\n * @param {Array<Array<number>>} coordinates\n * @returns {Array<number>} [cos, sin]\n */\nfunction getCosAndSin(\n  coordinates: number[][],\n  isPlanar: boolean\n): [number, number] {\n  const beginPoint: number[] = coordinates[0];\n  const endPoint: number[] = coordinates[coordinates.length - 1];\n  if (isPlanar) {\n    const [x0, y0]: number[] = beginPoint;\n    const [x1, y1]: number[] = endPoint;\n    const dx: number = x1 - x0;\n    const dy: number = y1 - y0;\n    const h = Math.sqrt(Math.pow(dx, 2) + Math.pow(dy, 2));\n    if (h < 0.000000001) {\n      return [NaN, NaN];\n    }\n    const sin1 = dy / h;\n    const cos1 = dx / h;\n    return [sin1, cos1];\n  } else {\n    const angle = bearingToCartesian(bearing(beginPoint, endPoint));\n    const radian = (angle * Math.PI) / 180;\n    return [Math.sin(radian), Math.cos(radian)];\n  }\n}\n\nfunction getAngleBySinAndCos(sin1: number, cos1: number): number {\n  let angle = 0;\n  if (Math.abs(cos1) < 0.000000001) {\n    angle = 90;\n  } else {\n    angle = (Math.atan2(sin1, cos1) * 180) / Math.PI;\n  }\n  if (sin1 >= 0) {\n    if (cos1 < 0) {\n      angle += 180;\n    }\n  } else {\n    if (cos1 < 0) {\n      angle -= 180;\n    }\n  }\n  return angle;\n}\n\nfunction getCircularVariance(sin1: number, cos1: number, len: number) {\n  if (len === 0) {\n    throw new Error(\"the size of the features set must be greater than 0\");\n  }\n  return 1 - Math.sqrt(Math.pow(sin1, 2) + Math.pow(cos1, 2)) / len;\n}\n\nfunction getMeanLineString(\n  centroidOfLine: number[],\n  angle: number,\n  lenOfLine: number,\n  isPlanar: boolean\n) {\n  if (isPlanar) {\n    const [averageX, averageY]: number[] = centroidOfLine;\n    let beginX: number;\n    let beginY: number;\n    let endX: number;\n    let endY: number;\n    const r: number = (angle * Math.PI) / 180;\n    const sin: number = Math.sin(r);\n    const cos: number = Math.cos(r);\n    beginX = averageX - (lenOfLine / 2) * cos;\n    beginY = averageY - (lenOfLine / 2) * sin;\n    endX = averageX + (lenOfLine / 2) * cos;\n    endY = averageY + (lenOfLine / 2) * sin;\n    return [\n      [beginX, beginY],\n      [endX, endY],\n    ];\n  } else {\n    const end = destination(point(centroidOfLine), lenOfLine / 2, angle, {\n      units: \"meters\",\n    });\n    const begin = destination(point(centroidOfLine), -lenOfLine / 2, angle, {\n      units: \"meters\",\n    });\n    return [getCoord(begin), getCoord(end)];\n  }\n}\n\nexport { directionalMean, DirectionalMeanLine };\nexport default directionalMean;\n"],"mappings":"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","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turf/directional-mean",
-  "version": "7.0.0-alpha.1",
+  "version": "7.0.0-alpha.110+1411d63a7",
   "description": "turf directional-mean module",
   "author": "Turf Authors",
   "contributors": [
@@ -23,50 +23,55 @@
     "turf",
     "directional-mean"
   ],
-  "main": "dist/js/index.js",
-  "module": "dist/es/index.js",
+  "type": "commonjs",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.mjs",
+  "types": "dist/cjs/index.d.ts",
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "types": "./dist/js/index.d.ts",
-      "import": "./dist/es/index.js",
-      "require": "./dist/js/index.js"
+      "import": {
+        "types": "./dist/esm/index.d.mts",
+        "default": "./dist/esm/index.mjs"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.cjs"
+      }
     }
   },
-  "types": "dist/js/index.d.ts",
   "sideEffects": false,
   "files": [
     "dist"
   ],
   "scripts": {
-    "bench": "tsx bench.js",
-    "build": "npm-run-all build:*",
-    "build:es": "tsc --outDir dist/es --module esnext --declaration false && echo '{\"type\":\"module\"}' > dist/es/package.json",
-    "build:js": "tsc",
-    "docs": "tsx ../../scripts/generate-readmes",
-    "test": "npm-run-all test:*",
-    "test:tape": "tsx test.js"
+    "bench": "tsx bench.ts",
+    "build": "tsup --config ../../tsup.config.ts",
+    "docs": "tsx ../../scripts/generate-readmes.ts",
+    "test": "npm-run-all --npm-path npm test:*",
+    "test:tape": "tsx test.ts"
   },
   "devDependencies": {
-    "@types/tape": "*",
-    "benchmark": "*",
-    "load-json-file": "*",
-    "npm-run-all": "*",
-    "tape": "*",
-    "tslint": "*",
-    "tsx": "*",
-    "typescript": "*",
-    "write-json-file": "*"
+    "@types/benchmark": "^2.1.5",
+    "@types/tape": "^4.2.32",
+    "benchmark": "^2.1.4",
+    "load-json-file": "^7.0.1",
+    "npm-run-all": "^4.1.5",
+    "tape": "^5.7.2",
+    "tsup": "^8.0.1",
+    "tsx": "^4.6.2",
+    "typescript": "^5.2.2",
+    "write-json-file": "^5.0.0"
   },
   "dependencies": {
-    "@turf/bearing": "^7.0.0-alpha.1",
-    "@turf/centroid": "^7.0.0-alpha.1",
-    "@turf/destination": "^7.0.0-alpha.1",
-    "@turf/helpers": "^7.0.0-alpha.1",
-    "@turf/invariant": "^7.0.0-alpha.1",
-    "@turf/length": "^7.0.0-alpha.1",
-    "@turf/meta": "^7.0.0-alpha.1",
-    "tslib": "^2.3.0"
+    "@turf/bearing": "^7.0.0-alpha.110+1411d63a7",
+    "@turf/centroid": "^7.0.0-alpha.110+1411d63a7",
+    "@turf/destination": "^7.0.0-alpha.110+1411d63a7",
+    "@turf/helpers": "^7.0.0-alpha.110+1411d63a7",
+    "@turf/invariant": "^7.0.0-alpha.110+1411d63a7",
+    "@turf/length": "^7.0.0-alpha.110+1411d63a7",
+    "@turf/meta": "^7.0.0-alpha.110+1411d63a7",
+    "tslib": "^2.6.2"
   },
-  "gitHead": "cf7a0c507b017ca066acffd0ce23bda5b393fb5a"
+  "gitHead": "1411d63a74c275c9216fe48e9d3cb2d48a359068"
 }

package/dist/es/index.js

@@ -1,236 +0,0 @@
-import bearing from "@turf/bearing";
-import centroid from "@turf/centroid";
-import destination from "@turf/destination";
-import { featureCollection, lineString, point } from "@turf/helpers";
-import { getCoord } from "@turf/invariant";
-import length from "@turf/length";
-import { featureEach, segmentEach, segmentReduce } from "@turf/meta";
-/**
- * @typedef {Object} DirectionalMeanLine
- * @property {number} cartesianAngle the mean angle of all lines. (measure from due earth counterclockwise).
- * @property {number} bearingAngle the mean angle of all lines. (bearing).
- * @property {number} circularVariance the extent to which features all point in the same direction.
- *  the value ranges 0-1, the bigger the value, the more variation in directions between lines.
- * @property {number} averageX the centroid of all lines.
- * @property {number} averageY the centroid of all line.
- * @property {number} averageLength the average length of line.
- * @property {number} countOfLines the count of features.
- */
-/**
- * This module calculate the average angle of a set of lines, measuring the trend of it.
- * It can be used in both project coordinate system and geography coordinate system.
- * It can handle segments of line or the whole line.
- * @name directionalMean
- * @param {FeatureCollection<LineString>} lines
- * @param {object} [options={}]
- * @param {boolean} [options.planar=true] whether the spatial reference system is projected or geographical.
- * @param {boolean} [options.segment=false] whether treat a LineString as a whole or a set of segments.
- * @returns {DirectionalMeanLine} Directional Mean Line
- * @example
- *
- * var lines = turf.lineStrings([
- *   [[110, 45], [120, 50]],
- *   [[100, 50], [115, 55]],
- * ])
- * var directionalMeanLine = turf.directionalMean(lines);
- * // => directionalMeanLine
- */
-export default function directionalMean(lines, options = {}) {
-    const isPlanar = !!options.planar; // you can't use options.planar || true here.
-    const isSegment = options.segment || false;
-    let sigmaSin = 0;
-    let sigmaCos = 0;
-    let countOfLines = 0;
-    let sumOfLen = 0;
-    const centroidList = [];
-    if (isSegment) {
-        segmentEach(lines, (currentSegment) => {
-            // todo fix turf-meta's declaration file
-            const [sin1, cos1] = getCosAndSin(currentSegment.geometry.coordinates, isPlanar);
-            const lenOfLine = getLengthOfLineString(currentSegment, isPlanar);
-            if (isNaN(sin1) || isNaN(cos1)) {
-                return;
-            }
-            else {
-                sigmaSin += sin1;
-                sigmaCos += cos1;
-                countOfLines += 1;
-                sumOfLen += lenOfLine;
-                centroidList.push(centroid(currentSegment));
-            }
-        });
-        // planar and segment
-    }
-    else {
-        // planar and non-segment
-        featureEach(lines, (currentFeature) => {
-            if (currentFeature.geometry.type !== "LineString") {
-                throw new Error("shold to support MultiLineString?");
-            }
-            const [sin1, cos1] = getCosAndSin(currentFeature.geometry.coordinates, isPlanar);
-            const lenOfLine = getLengthOfLineString(currentFeature, isPlanar);
-            if (isNaN(sin1) || isNaN(cos1)) {
-                return;
-            }
-            else {
-                sigmaSin += sin1;
-                sigmaCos += cos1;
-                countOfLines += 1;
-                sumOfLen += lenOfLine;
-                centroidList.push(centroid(currentFeature));
-            }
-        });
-    }
-    const cartesianAngle = getAngleBySinAndCos(sigmaSin, sigmaCos);
-    const bearingAngle = bearingToCartesian(cartesianAngle);
-    const circularVariance = getCircularVariance(sigmaSin, sigmaCos, countOfLines);
-    const averageLength = sumOfLen / countOfLines;
-    const centroidOfLines = centroid(featureCollection(centroidList));
-    const [averageX, averageY] = getCoord(centroidOfLines);
-    let meanLinestring;
-    if (isPlanar) {
-        meanLinestring = getMeanLineString([averageX, averageY], cartesianAngle, averageLength, isPlanar);
-    }
-    else {
-        meanLinestring = getMeanLineString([averageX, averageY], bearingAngle, averageLength, isPlanar);
-    }
-    return lineString(meanLinestring, {
-        averageLength,
-        averageX,
-        averageY,
-        bearingAngle,
-        cartesianAngle,
-        circularVariance,
-        countOfLines,
-    });
-}
-/**
- * get euclidean distance between two points.
- * @private
- * @name euclideanDistance
- * @param coords
- */
-function euclideanDistance(coords) {
-    const [x0, y0] = coords[0];
-    const [x1, y1] = coords[1];
-    const dx = x1 - x0;
-    const dy = y1 - y0;
-    return Math.sqrt(Math.pow(dx, 2) + Math.pow(dy, 2));
-}
-/**
- * get the length of a LineString, both in projected or geographical coordinate system.
- * @private
- * @name getLengthOfLineString
- * @param {Feature<LineString>} line
- * @param {boolean} isPlanar
- */
-function getLengthOfLineString(line, isPlanar) {
-    if (isPlanar) {
-        return segmentReduce(line, (previousValue, segment) => {
-            const coords = segment.geometry.coordinates; // the signatrue of segmentReduce has problem ?
-            return previousValue + euclideanDistance(coords);
-        }, 0);
-    }
-    else {
-        return length(line, {
-            units: "meters",
-        });
-    }
-}
-/**
- * bearing to xy(from due earth counterclockwise 0-180)
- * convert between two forms
- * @private
- * @name bearingToCartesian
- * @param angle
- */
-function bearingToCartesian(angle) {
-    let result = 90 - angle;
-    if (result > 180) {
-        result -= 360;
-    }
-    return result;
-}
-/**
- * @private
- * @name getCosAndSin
- * @param {Array<Array<number>>} coordinates
- * @returns {Array<number>} [cos, sin]
- */
-function getCosAndSin(coordinates, isPlanar) {
-    const beginPoint = coordinates[0];
-    const endPoint = coordinates[coordinates.length - 1];
-    if (isPlanar) {
-        const [x0, y0] = beginPoint;
-        const [x1, y1] = endPoint;
-        const dx = x1 - x0;
-        const dy = y1 - y0;
-        const h = Math.sqrt(Math.pow(dx, 2) + Math.pow(dy, 2));
-        if (h < 0.000000001) {
-            return [NaN, NaN];
-        }
-        const sin1 = dy / h;
-        const cos1 = dx / h;
-        return [sin1, cos1];
-    }
-    else {
-        const angle = bearingToCartesian(bearing(beginPoint, endPoint));
-        const radian = (angle * Math.PI) / 180;
-        return [Math.sin(radian), Math.cos(radian)];
-    }
-}
-function getAngleBySinAndCos(sin1, cos1) {
-    let angle = 0;
-    if (Math.abs(cos1) < 0.000000001) {
-        angle = 90;
-    }
-    else {
-        angle = (Math.atan2(sin1, cos1) * 180) / Math.PI;
-    }
-    if (sin1 >= 0) {
-        if (cos1 < 0) {
-            angle += 180;
-        }
-    }
-    else {
-        if (cos1 < 0) {
-            angle -= 180;
-        }
-    }
-    return angle;
-}
-function getCircularVariance(sin1, cos1, len) {
-    if (len === 0) {
-        throw new Error("the size of the features set must be greater than 0");
-    }
-    return 1 - Math.sqrt(Math.pow(sin1, 2) + Math.pow(cos1, 2)) / len;
-}
-function getMeanLineString(centroidOfLine, angle, lenOfLine, isPlanar) {
-    if (isPlanar) {
-        const [averageX, averageY] = centroidOfLine;
-        let beginX;
-        let beginY;
-        let endX;
-        let endY;
-        const r = (angle * Math.PI) / 180;
-        const sin = Math.sin(r);
-        const cos = Math.cos(r);
-        beginX = averageX - (lenOfLine / 2) * cos;
-        beginY = averageY - (lenOfLine / 2) * sin;
-        endX = averageX + (lenOfLine / 2) * cos;
-        endY = averageY + (lenOfLine / 2) * sin;
-        return [
-            [beginX, beginY],
-            [endX, endY],
-        ];
-    }
-    else {
-        const end = destination(point(centroidOfLine), lenOfLine / 2, angle, {
-            units: "meters",
-        });
-        const begin = destination(point(centroidOfLine), -lenOfLine / 2, angle, {
-            units: "meters",
-        });
-        return [getCoord(begin), getCoord(end)];
-    }
-}

package/dist/es/package.json

@@ -1 +0,0 @@
-{"type":"module"}

package/dist/js/index.js

@@ -1,240 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const bearing_1 = tslib_1.__importDefault(require("@turf/bearing"));
-const centroid_1 = tslib_1.__importDefault(require("@turf/centroid"));
-const destination_1 = tslib_1.__importDefault(require("@turf/destination"));
-const helpers_1 = require("@turf/helpers");
-const invariant_1 = require("@turf/invariant");
-const length_1 = tslib_1.__importDefault(require("@turf/length"));
-const meta_1 = require("@turf/meta");
-/**
- * @typedef {Object} DirectionalMeanLine
- * @property {number} cartesianAngle the mean angle of all lines. (measure from due earth counterclockwise).
- * @property {number} bearingAngle the mean angle of all lines. (bearing).
- * @property {number} circularVariance the extent to which features all point in the same direction.
- *  the value ranges 0-1, the bigger the value, the more variation in directions between lines.
- * @property {number} averageX the centroid of all lines.
- * @property {number} averageY the centroid of all line.
- * @property {number} averageLength the average length of line.
- * @property {number} countOfLines the count of features.
- */
-/**
- * This module calculate the average angle of a set of lines, measuring the trend of it.
- * It can be used in both project coordinate system and geography coordinate system.
- * It can handle segments of line or the whole line.
- * @name directionalMean
- * @param {FeatureCollection<LineString>} lines
- * @param {object} [options={}]
- * @param {boolean} [options.planar=true] whether the spatial reference system is projected or geographical.
- * @param {boolean} [options.segment=false] whether treat a LineString as a whole or a set of segments.
- * @returns {DirectionalMeanLine} Directional Mean Line
- * @example
- *
- * var lines = turf.lineStrings([
- *   [[110, 45], [120, 50]],
- *   [[100, 50], [115, 55]],
- * ])
- * var directionalMeanLine = turf.directionalMean(lines);
- * // => directionalMeanLine
- */
-function directionalMean(lines, options = {}) {
-    const isPlanar = !!options.planar; // you can't use options.planar || true here.
-    const isSegment = options.segment || false;
-    let sigmaSin = 0;
-    let sigmaCos = 0;
-    let countOfLines = 0;
-    let sumOfLen = 0;
-    const centroidList = [];
-    if (isSegment) {
-        meta_1.segmentEach(lines, (currentSegment) => {
-            // todo fix turf-meta's declaration file
-            const [sin1, cos1] = getCosAndSin(currentSegment.geometry.coordinates, isPlanar);
-            const lenOfLine = getLengthOfLineString(currentSegment, isPlanar);
-            if (isNaN(sin1) || isNaN(cos1)) {
-                return;
-            }
-            else {
-                sigmaSin += sin1;
-                sigmaCos += cos1;
-                countOfLines += 1;
-                sumOfLen += lenOfLine;
-                centroidList.push(centroid_1.default(currentSegment));
-            }
-        });
-        // planar and segment
-    }
-    else {
-        // planar and non-segment
-        meta_1.featureEach(lines, (currentFeature) => {
-            if (currentFeature.geometry.type !== "LineString") {
-                throw new Error("shold to support MultiLineString?");
-            }
-            const [sin1, cos1] = getCosAndSin(currentFeature.geometry.coordinates, isPlanar);
-            const lenOfLine = getLengthOfLineString(currentFeature, isPlanar);
-            if (isNaN(sin1) || isNaN(cos1)) {
-                return;
-            }
-            else {
-                sigmaSin += sin1;
-                sigmaCos += cos1;
-                countOfLines += 1;
-                sumOfLen += lenOfLine;
-                centroidList.push(centroid_1.default(currentFeature));
-            }
-        });
-    }
-    const cartesianAngle = getAngleBySinAndCos(sigmaSin, sigmaCos);
-    const bearingAngle = bearingToCartesian(cartesianAngle);
-    const circularVariance = getCircularVariance(sigmaSin, sigmaCos, countOfLines);
-    const averageLength = sumOfLen / countOfLines;
-    const centroidOfLines = centroid_1.default(helpers_1.featureCollection(centroidList));
-    const [averageX, averageY] = invariant_1.getCoord(centroidOfLines);
-    let meanLinestring;
-    if (isPlanar) {
-        meanLinestring = getMeanLineString([averageX, averageY], cartesianAngle, averageLength, isPlanar);
-    }
-    else {
-        meanLinestring = getMeanLineString([averageX, averageY], bearingAngle, averageLength, isPlanar);
-    }
-    return helpers_1.lineString(meanLinestring, {
-        averageLength,
-        averageX,
-        averageY,
-        bearingAngle,
-        cartesianAngle,
-        circularVariance,
-        countOfLines,
-    });
-}
-exports.default = directionalMean;
-/**
- * get euclidean distance between two points.
- * @private
- * @name euclideanDistance
- * @param coords
- */
-function euclideanDistance(coords) {
-    const [x0, y0] = coords[0];
-    const [x1, y1] = coords[1];
-    const dx = x1 - x0;
-    const dy = y1 - y0;
-    return Math.sqrt(Math.pow(dx, 2) + Math.pow(dy, 2));
-}
-/**
- * get the length of a LineString, both in projected or geographical coordinate system.
- * @private
- * @name getLengthOfLineString
- * @param {Feature<LineString>} line
- * @param {boolean} isPlanar
- */
-function getLengthOfLineString(line, isPlanar) {
-    if (isPlanar) {
-        return meta_1.segmentReduce(line, (previousValue, segment) => {
-            const coords = segment.geometry.coordinates; // the signatrue of segmentReduce has problem ?
-            return previousValue + euclideanDistance(coords);
-        }, 0);
-    }
-    else {
-        return length_1.default(line, {
-            units: "meters",
-        });
-    }
-}
-/**
- * bearing to xy(from due earth counterclockwise 0-180)
- * convert between two forms
- * @private
- * @name bearingToCartesian
- * @param angle
- */
-function bearingToCartesian(angle) {
-    let result = 90 - angle;
-    if (result > 180) {
-        result -= 360;
-    }
-    return result;
-}
-/**
- * @private
- * @name getCosAndSin
- * @param {Array<Array<number>>} coordinates
- * @returns {Array<number>} [cos, sin]
- */
-function getCosAndSin(coordinates, isPlanar) {
-    const beginPoint = coordinates[0];
-    const endPoint = coordinates[coordinates.length - 1];
-    if (isPlanar) {
-        const [x0, y0] = beginPoint;
-        const [x1, y1] = endPoint;
-        const dx = x1 - x0;
-        const dy = y1 - y0;
-        const h = Math.sqrt(Math.pow(dx, 2) + Math.pow(dy, 2));
-        if (h < 0.000000001) {
-            return [NaN, NaN];
-        }
-        const sin1 = dy / h;
-        const cos1 = dx / h;
-        return [sin1, cos1];
-    }
-    else {
-        const angle = bearingToCartesian(bearing_1.default(beginPoint, endPoint));
-        const radian = (angle * Math.PI) / 180;
-        return [Math.sin(radian), Math.cos(radian)];
-    }
-}
-function getAngleBySinAndCos(sin1, cos1) {
-    let angle = 0;
-    if (Math.abs(cos1) < 0.000000001) {
-        angle = 90;
-    }
-    else {
-        angle = (Math.atan2(sin1, cos1) * 180) / Math.PI;
-    }
-    if (sin1 >= 0) {
-        if (cos1 < 0) {
-            angle += 180;
-        }
-    }
-    else {
-        if (cos1 < 0) {
-            angle -= 180;
-        }
-    }
-    return angle;
-}
-function getCircularVariance(sin1, cos1, len) {
-    if (len === 0) {
-        throw new Error("the size of the features set must be greater than 0");
-    }
-    return 1 - Math.sqrt(Math.pow(sin1, 2) + Math.pow(cos1, 2)) / len;
-}
-function getMeanLineString(centroidOfLine, angle, lenOfLine, isPlanar) {
-    if (isPlanar) {
-        const [averageX, averageY] = centroidOfLine;
-        let beginX;
-        let beginY;
-        let endX;
-        let endY;
-        const r = (angle * Math.PI) / 180;
-        const sin = Math.sin(r);
-        const cos = Math.cos(r);
-        beginX = averageX - (lenOfLine / 2) * cos;
-        beginY = averageY - (lenOfLine / 2) * sin;
-        endX = averageX + (lenOfLine / 2) * cos;
-        endY = averageY + (lenOfLine / 2) * sin;
-        return [
-            [beginX, beginY],
-            [endX, endY],
-        ];
-    }
-    else {
-        const end = destination_1.default(helpers_1.point(centroidOfLine), lenOfLine / 2, angle, {
-            units: "meters",
-        });
-        const begin = destination_1.default(helpers_1.point(centroidOfLine), -lenOfLine / 2, angle, {
-            units: "meters",
-        });
-        return [invariant_1.getCoord(begin), invariant_1.getCoord(end)];
-    }
-}