@cpp.js/package-geos 1.0.0 → 2.0.0-beta.1

package/cppjs.config.js

@@ -1,14 +1,14 @@
+import geosWasm from '@cpp.js/package-geos-wasm/cppjs.config.js';
+import geosAndroid from '@cpp.js/package-geos-android/cppjs.config.js';
+import geosIos from '@cpp.js/package-geos-ios/cppjs.config.js';
+
 export default {
-    general: {
-        name: 'geos',
-    },
-    export: {
-        type: 'cmake',
-        libName: ['geos', 'geos_c'],
-    },
-    paths: {
-        config: import.meta.url,
-        base: '../..',
-        output: 'dist',
-    },
+  dependencies: [
+    geosWasm,
+    geosAndroid,
+    geosIos,
+  ],
+  paths: {
+    config: import.meta.url
+  }
 };

package/package.json

@@ -1,15 +1,12 @@
 {
   "name": "@cpp.js/package-geos",
-  "version": "1.0.0",
-  "nativeVersion": "3.13.0",
+  "version": "2.0.0-beta.1",
+  "nativeVersion": "3.14.1",
   "description": "This package provides the precompiled GEOS library, built using Cpp.js, for seamless integration into JavaScript, WebAssembly, and React Native projects. It supports advanced geometry operations, including spatial analysis and topological calculations, delivering high performance and cross-platform compatibility. Perfect for web, server-side, and mobile geospatial applications.",
   "homepage": "https://github.com/bugra9/cpp.js/tree/main/packages/cppjs-package-geos#readme",
   "repository": "https://github.com/bugra9/cpp.js.git",
-  "license": "LGPL-2.1-or-later",
   "type": "module",
-  "devDependencies": {
-    "cpp.js": "^1.0.0"
-  },
+  "license": "LGPL-2.1-or-later",
   "keywords": [
     "geos",
     "libgeos",
@@ -17,11 +14,10 @@
     "webassembly",
     "react-native"
   ],
-  "scripts": {
-    "build": "cppjs build",
-    "build:wasm": "cppjs build -p WebAssembly",
-    "build:android": "cppjs build -p Android",
-    "build:ios": "cppjs build -p iOS",
-    "clear": "rm -rf .cppjs dist *.xcframework"
+  "devDependencies": {
+    "@cpp.js/package-geos-android": "^2.0.0-beta.1",
+    "cpp.js": "^2.0.0-beta.1",
+    "@cpp.js/package-geos-ios": "^2.0.0-beta.1",
+    "@cpp.js/package-geos-wasm": "^2.0.0-beta.1"
   }
 }

package/dist/prebuilt/Android-arm64-v8a/bin/geos-config

@@ -1,79 +0,0 @@
-#!/bin/sh
-
-prefix=/tmp/cppjs/live/packages/cppjs-package-geos/.cppjs/build/Source-Release/prebuilt/Android-arm64-v8a
-exec_prefix=${prefix}
-includedir=${prefix}/include
-libdir=${exec_prefix}/lib
-
-usage()
-{
-  cat <<EOF
-Usage: geos-config [OPTIONS]
-Options:
-     [--prefix]
-     [--version]
-     [--libs]
-     [--clibs]
-     [--cclibs]
-     [--static-clibs]
-     [--static-cclibs]
-     [--cflags]
-     [--ldflags]
-     [--includes]
-     [--jtsport]
-EOF
-  exit $1
-}
-
-if test $# -eq 0; then
-  usage 1 1>&2
-fi
-
-while test $# -gt 0; do
-  case "$1" in
-    -*=*) optarg=`echo "$1" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
-    *) optarg= ;;
-  esac
-  case $1 in
-    --prefix)
-      echo ${prefix}
-      ;;
-    --version)
-      echo 3.13.0
-      ;;
-    --libs)
-      # TODO: make an alias for --clibs
-      # see http://trac.osgeo.org/geos/ticket/497
-      echo -L${libdir} -lgeos
-      ;;
-    --clibs)
-      echo -L${libdir} -lgeos_c
-      ;;
-    --cclibs)
-      echo -L${libdir} -lgeos
-      ;;
-    --static-clibs)
-      echo -L${libdir} -lgeos_c -lgeos -lstdc++ -lm
-      ;;
-    --static-cclibs)
-      echo -L${libdir} -lgeos -lstdc++ -lm
-      ;;
-    --cflags)
-      echo -I${includedir}
-      ;;
-    --ldflags)
-      echo -L${libdir}
-      ;;
-    --includes)
-      echo ${includedir}
-      ;;
-    --jtsport)
-      echo 1.18.0
-      ;;
-    *)
-      usage 1 1>&2
-      ;;
-  esac
-  shift
-done
-

package/dist/prebuilt/Android-arm64-v8a/include/geos/algorithm/Angle.h

@@ -1,247 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2009-2011  Sandro Santilli <strk@kbt.io>
- *
- * This is free software; you can redistribute and/or modify it under
- * the terms of the GNU Lesser General Public Licence as published
- * by the Free Software Foundation.
- * See the COPYING file for more information.
- *
- **********************************************************************
- *
- * Last port: algorithm/Angle.java r378 (JTS-1.12)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-#include <geos/algorithm/Orientation.h> // for constants
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class Coordinate;
-}
-}
-
-namespace geos {
-namespace algorithm { // geos::algorithm
-
-/// Utility functions for working with angles.
-//
-/// Unless otherwise noted, methods in this class express angles in radians.
-///
-class GEOS_DLL Angle {
-public:
-
-    static constexpr double PI_TIMES_2 = 2.0 * MATH_PI;
-    static constexpr double PI_OVER_2 = MATH_PI / 2.0;
-    static constexpr double PI_OVER_4 = MATH_PI / 4.0;
-
-    /// Constant representing counterclockwise orientation
-    static const int COUNTERCLOCKWISE = Orientation::COUNTERCLOCKWISE;
-
-    /// Constant representing clockwise orientation
-    static const int CLOCKWISE = Orientation::CLOCKWISE;
-
-    /// Constant representing no orientation
-    static const int NONE = Orientation::COLLINEAR;
-
-    /// Converts from radians to degrees.
-    ///
-    /// @param radians an angle in radians
-    /// @return the angle in degrees
-    ///
-    static double toDegrees(double radians);
-
-    /// Converts from degrees to radians.
-    ///
-    /// @param angleDegrees an angle in degrees
-    /// @return the angle in radians
-    ///
-    static double toRadians(double angleDegrees);
-
-    /// \brief
-    /// Returns the angle of the vector from p0 to p1,
-    /// relative to the positive X-axis.
-    ///
-    /// The angle is normalized to be in the range [ -Pi, Pi ].
-    ///
-    /// @return the normalized angle (in radians) that p0-p1 makes
-    ///         with the positive x-axis.
-    ///
-    static double angle(const geom::CoordinateXY& p0,
-                        const geom::CoordinateXY& p1);
-
-    /// \brief
-    /// Returns the angle that the vector from (0,0) to p,
-    /// relative to the positive X-axis.
-    //
-    /// The angle is normalized to be in the range ( -Pi, Pi ].
-    ///
-    /// @return the normalized angle (in radians) that p makes
-    ///          with the positive x-axis.
-    ///
-    static double angle(const geom::CoordinateXY& p);
-
-    /// Tests whether the angle between p0-p1-p2 is acute.
-    ///
-    /// An angle is acute if it is less than 90 degrees.
-    ///
-    /// Note: this implementation is not precise (deterministic) for
-    ///       angles very close to 90 degrees.
-    ///
-    /// @param p0 an endpoint of the angle
-    /// @param p1 the base of the angle
-    /// @param p2 the other endpoint of the angle
-    ///
-    static bool isAcute(const geom::CoordinateXY& p0,
-                        const geom::CoordinateXY& p1,
-                        const geom::CoordinateXY& p2);
-
-    /// Tests whether the angle between p0-p1-p2 is obtuse.
-    ///
-    /// An angle is obtuse if it is greater than 90 degrees.
-    ///
-    /// Note: this implementation is not precise (deterministic) for
-    ///       angles very close to 90 degrees.
-    ///
-    /// @param p0 an endpoint of the angle
-    /// @param p1 the base of the angle
-    /// @param p2 the other endpoint of the angle
-    ///
-    static bool isObtuse(const geom::CoordinateXY& p0,
-                         const geom::CoordinateXY& p1,
-                         const geom::CoordinateXY& p2);
-
-    /// Returns the unoriented smallest angle between two vectors.
-    ///
-    /// The computed angle will be in the range [0, Pi).
-    ///
-    /// @param tip1 the tip of one vector
-    /// @param tail the tail of each vector
-    /// @param tip2 the tip of the other vector
-    /// @return the angle between tail-tip1 and tail-tip2
-    ///
-    static double angleBetween(const geom::CoordinateXY& tip1,
-                               const geom::CoordinateXY& tail,
-                               const geom::CoordinateXY& tip2);
-
-    /// Returns the oriented smallest angle between two vectors.
-    ///
-    /// The computed angle will be in the range (-Pi, Pi].
-    /// A positive result corresponds to a counterclockwise rotation
-    /// from v1 to v2;
-    /// a negative result corresponds to a clockwise rotation.
-    ///
-    /// @param tip1 the tip of v1
-    /// @param tail the tail of each vector
-    /// @param tip2 the tip of v2
-    /// @return the angle between v1 and v2, relative to v1
-    ///
-    static double angleBetweenOriented(const geom::CoordinateXY& tip1,
-                                       const geom::CoordinateXY& tail,
-                                       const geom::CoordinateXY& tip2);
-
-    /// Computes the interior angle between two segments of a ring.
-    ///
-    /// The ring is assumed to be oriented in a clockwise direction.
-    /// The computed angle will be in the range [0, 2Pi]
-    ///
-    /// @param p0
-    ///          a point of the ring
-    /// @param p1
-    ///          the next point of the ring
-    /// @param p2
-    ///          the next point of the ring
-    /// @return the interior angle based at <code>p1</code>
-    ///
-    static double interiorAngle(const geom::CoordinateXY& p0,
-                                const geom::CoordinateXY& p1,
-                                const geom::CoordinateXY& p2);
-
-    /// \brief
-    /// Returns whether an angle must turn clockwise or counterclockwise
-    /// to overlap another angle.
-    ///
-    /// @param ang1 an angle (in radians)
-    /// @param ang2 an angle (in radians)
-    /// @return whether a1 must turn CLOCKWISE, COUNTERCLOCKWISE or
-    ///         NONE to overlap a2.
-    ///
-    static int getTurn(double ang1, double ang2);
-
-    /// \brief
-    /// Computes the normalized value of an angle, which is the
-    /// equivalent angle in the range ( -Pi, Pi ].
-    ///
-    /// @param angle the angle to normalize
-    /// @return an equivalent angle in the range (-Pi, Pi]
-    ///
-    static double normalize(double angle);
-
-    /// \brief
-    /// Computes the normalized positive value of an angle,
-    /// which is the equivalent angle in the range [ 0, 2*Pi ).
-    ///
-    /// E.g.:
-    /// - normalizePositive(0.0) = 0.0
-    /// - normalizePositive(-PI) = PI
-    /// - normalizePositive(-2PI) = 0.0
-    /// - normalizePositive(-3PI) = PI
-    /// - normalizePositive(-4PI) = 0
-    /// - normalizePositive(PI) = PI
-    /// - normalizePositive(2PI) = 0.0
-    /// - normalizePositive(3PI) = PI
-    /// - normalizePositive(4PI) = 0.0
-    ///
-    /// @param angle the angle to normalize, in radians
-    /// @return an equivalent positive angle
-    ///
-    static double normalizePositive(double angle);
-
-
-    /// Computes the unoriented smallest difference between two angles.
-    ///
-    /// The angles are assumed to be normalized to the range [-Pi, Pi].
-    /// The result will be in the range [0, Pi].
-    ///
-    /// @param ang1 the angle of one vector (in [-Pi, Pi] )
-    /// @param ang2 the angle of the other vector (in range [-Pi, Pi] )
-    /// @return the angle (in radians) between the two vectors
-    ///         (in range [0, Pi] )
-    ///
-    static double diff(double ang1, double ang2);
-
-    /// \brief
-    /// Computes both sin and cos of an angle, snapping near-zero values
-    /// to zero.
-    ///
-    /// The angle does not need to be normalized. Unlike std::sin
-    /// and std::cos, this method will snap near-zero values to zero
-    /// for (e.g.) sin(pi) and cos(pi/2).
-    ///
-    /// @param ang the input angle (in radians)
-    /// @param rSin the result of sin(ang)
-    /// @param rCos the result of cos(ang)
-    ///
-    static inline void sinCosSnap(const double ang, double& rSin, double& rCos) {
-        // calculate both; may be optimized with FSINCOS instruction
-        rSin = std::sin(ang);
-        rCos = std::cos(ang);
-        // snap near-zero values
-        if (std::fabs(rSin) < 5e-16) rSin = 0.0;
-        if (std::fabs(rCos) < 5e-16) rCos = 0.0;
-    }
-
-};
-
-
-} // namespace geos::algorithm
-} // namespace geos
-
-

package/dist/prebuilt/Android-arm64-v8a/include/geos/algorithm/Area.h

@@ -1,82 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2018 Paul Ramsey <pramsey@cleverlephant.ca>
- *
- * This is free software; you can redistribute and/or modify it under
- * the terms of the GNU Lesser General Public Licence as published
- * by the Free Software Foundation.
- * See the COPYING file for more information.
- *
- **********************************************************************
- *
- * Last port: algorithm/Area.java @ 2017-09-04
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-#include <geos/geom/Coordinate.h>
-#include <geos/geom/CoordinateSequence.h>
-
-namespace geos {
-
-namespace geom {
-class Curve;
-}
-
-namespace algorithm { // geos::algorithm
-
-
-class GEOS_DLL Area {
-public:
-
-    static double ofClosedCurve(const geom::Curve& ring);
-
-    /**
-    * Computes the area for a ring.
-    *
-    * @param ring the coordinates forming the ring
-    * @return the area of the ring
-    */
-    static double ofRing(const std::vector<geom::Coordinate>& ring);
-
-    /**
-    * Computes the area for a ring.
-    *
-    * @param ring the coordinates forming the ring
-    * @return the area of the ring
-    */
-    static double ofRing(const geom::CoordinateSequence* ring);
-
-    /**
-    * Computes the signed area for a ring. The signed area is positive if the
-    * ring is oriented CW, negative if the ring is oriented CCW, and zero if the
-    * ring is degenerate or flat.
-    *
-    * @param ring
-    *          the coordinates forming the ring
-    * @return the signed area of the ring
-    */
-    static double ofRingSigned(const std::vector<geom::Coordinate>& ring);
-
-    /**
-    * Computes the signed area for a ring. The signed area is positive if the
-    * ring is oriented CW, negative if the ring is oriented CCW, and zero if the
-    * ring is degenerate or flat.
-    *
-    * @param ring
-    *          the coordinates forming the ring
-    * @return the signed area of the ring
-    */
-    static double ofRingSigned(const geom::CoordinateSequence* ring);
-
-};
-
-
-} // namespace geos::algorithm
-} // namespace geos
-

package/dist/prebuilt/Android-arm64-v8a/include/geos/algorithm/BoundaryNodeRule.h

@@ -1,146 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2009      Sandro Santilli <strk@kbt.io>
- *
- * This is free software; you can redistribute and/or modify it under
- * the terms of the GNU Lesser General Public Licence as published
- * by the Free Software Foundation.
- * See the COPYING file for more information.
- *
- **********************************************************************
- *
- * Last port: algorithm/BoundaryNodeRule.java rev 1.4 (JTS-1.10)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <string>
-
-#include <geos/export.h>
-
-// Forward declarations
-// ...
-
-namespace geos {
-namespace algorithm { // geos::algorithm
-
-
-/** \brief
- * An interface for rules which determine whether node points which are
- * in boundaries of lineal geometry components
- * are in the boundary of the parent geometry collection.
- *
- * The SFS specifies a single kind of boundary node rule,
- * the `Mod2BoundaryNodeRule` rule.
- * However, other kinds of Boundary Node Rules are appropriate
- * in specific situations (for instance, linear network topology
- * usually follows the `EndPointBoundaryNodeRule`.)
- * Some JTS operations allow the BoundaryNodeRule to be specified,
- * and respect this rule when computing the results of the operation.
- *
- * @author Martin Davis
- * @version 1.7
- *
- * @see operation::relate::RelateOp
- * @see operation::valid::IsSimpleOp
- * @see algorithm::PointLocator
- */
-class GEOS_DLL BoundaryNodeRule {
-
-public:
-
-    // virtual classes should always have a virtual destructor..
-    virtual
-    ~BoundaryNodeRule() {}
-
-    virtual std::string toString() const = 0;
-
-    /** \brief
-     * Tests whether a point that lies in `boundaryCount`
-     * geometry component boundaries is considered to form part of
-     * the boundary of the parent geometry.
-     *
-     * @param boundaryCount the number of component boundaries that
-     *                      this point occurs in
-     * @return `true` if points in this number of boundaries lie in
-     *         the parent boundary
-     */
-    virtual bool isInBoundary(int boundaryCount) const = 0;
-
-    /** \brief
-     * The Mod-2 Boundary Node Rule (which is the rule specified
-     * in the OGC SFS).
-     *
-     * A BoundaryNodeRule specifies that points are in the boundary of
-     * a lineal geometry iff the point lies on the boundary of an odd number
-     * of components. Under this rule LinearRings and closed LineStrings have
-     * an empty boundary.
-     *
-     * This is the rule specified by the OGC SFS, and is the default
-     * rule used in JTS.
-     */
-    //static const BoundaryNodeRule& MOD2_BOUNDARY_RULE;
-    static const BoundaryNodeRule& getBoundaryRuleMod2();
-
-    /** \brief
-     * The Endpoint Boundary Node Rule.
-     *
-     * A BoundaryNodeRule which specifies that any points which are endpoints
-     * of lineal components are in the boundary of the parent geometry. This
-     * corresponds to the "intuitive" topological definition of boundary. Under
-     * this rule LinearRings have a non-empty boundary (the common endpoint
-     * of the underlying LineString).
-     *
-     * This rule is useful when dealing with linear networks. For example,
-     * it can be used to check whether linear networks are correctly noded.
-     * The usual network topology constraint is that linear segments may
-     * touch only at endpoints. In the case of a segment touching a closed
-     * segment (ring) at one point, the Mod2 rule cannot distinguish between
-     * the permitted case of touching at the node point and the invalid case
-     * of touching at some other interior (non-node) point. The EndPoint rule
-     * does distinguish between these cases, so is more appropriate for use.
-     */
-    //static const BoundaryNodeRule& ENDPOINT_BOUNDARY_RULE;
-    static const BoundaryNodeRule& getBoundaryEndPoint();
-
-    /** \brief
-     * The MultiValent Endpoint Boundary Node Rule.
-     *
-     * A BoundaryNodeRule which determines that only endpoints with valency
-     * greater than 1 are on the boundary. This corresponds to the boundary
-     * of a MultiLineString being all the "attached" endpoints, but not
-     * the "unattached" ones.
-     */
-    //static const BoundaryNodeRule& MULTIVALENT_ENDPOINT_BOUNDARY_RULE;
-    static const BoundaryNodeRule& getBoundaryMultivalentEndPoint();
-
-    /** \brief
-     * The Monovalent Endpoint Boundary Node Rule.
-     *
-     * A BoundaryNodeRule which determines that only endpoints with valency of
-     * exactly 1 are on the boundary. This corresponds to the boundary of
-     * a MultiLineString being all the "unattached" endpoints.
-     */
-    //static const BoundaryNodeRule& MONOVALENT_ENDPOINT_BOUNDARY_RULE;
-    static const BoundaryNodeRule& getBoundaryMonovalentEndPoint();
-
-    /** \brief
-     * The Boundary Node Rule specified by the OGC Simple Features
-     * Specification, which is the same as the Mod-2 rule.
-     *
-     * A BoundaryNodeRule which determines that only endpoints with valency
-     * greater than 1 are on the boundary. This corresponds to the boundary
-     * of a MultiLineString being all the "attached" endpoints, but not the
-     * "unattached" ones.
-     */
-    //static const BoundaryNodeRule& OGC_SFS_BOUNDARY_RULE;
-    static const BoundaryNodeRule& getBoundaryOGCSFS();
-};
-
-} // namespace geos::algorithm
-} // namespace geos
-