npm - @swissgeo/coordinates - Versions diffs - 1.0.0-beta.2 → 1.0.0 - Mend

@swissgeo/coordinates 1.0.0-beta.2 → 1.0.0

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 (39) hide show

package/README.md +118 -0
package/dist/index.cjs +7 -0
package/dist/index.d.ts +3 -14
package/dist/index.js +8012 -18103
package/dist/ol.cjs +1 -0
package/dist/ol.d.ts +10 -0
package/dist/ol.js +4467 -0
package/dist/registerProj4-BuUOcPpF.cjs +23 -0
package/dist/registerProj4-CwR_kPOz.js +10172 -0
package/eslint.config.mts +12 -0
package/index.html +14 -0
package/package.json +30 -29
package/setup-vitest.ts +8 -0
package/src/DevApp.vue +65 -0
package/src/__test__/coordinatesUtils.spec.ts +178 -0
package/src/__test__/extentUtils.spec.ts +92 -0
package/src/coordinatesUtils.ts +188 -0
package/src/dev.ts +6 -0
package/src/extentUtils.ts +196 -0
package/src/index.ts +29 -0
package/src/ol.ts +52 -0
package/src/proj/CoordinateSystem.ts +315 -0
package/src/proj/CoordinateSystemBounds.ts +170 -0
package/src/proj/CustomCoordinateSystem.ts +58 -0
package/src/proj/LV03CoordinateSystem.ts +23 -0
package/src/proj/LV95CoordinateSystem.ts +35 -0
package/src/proj/StandardCoordinateSystem.ts +22 -0
package/src/proj/SwissCoordinateSystem.ts +233 -0
package/src/proj/WGS84CoordinateSystem.ts +97 -0
package/src/proj/WebMercatorCoordinateSystem.ts +89 -0
package/src/proj/__test__/CoordinateSystem.spec.ts +63 -0
package/src/proj/__test__/CoordinateSystemBounds.spec.ts +252 -0
package/src/proj/__test__/SwissCoordinateSystem.spec.ts +136 -0
package/src/proj/index.ts +65 -0
package/src/proj/types.ts +22 -0
package/src/registerProj4.ts +38 -0
package/tsconfig.json +4 -0
package/vite.config.ts +46 -0
package/dist/index.umd.cjs +0 -29

package/eslint.config.mts ADDED Viewed

@@ -0,0 +1,12 @@
+import defaultConfig from '@swissgeo/config-eslint'
+export default [
+    ...defaultConfig,
+    {
+        languageOptions: {
+            parserOptions: {
+                tsconfigRootDir: import.meta.dirname,
+            },
+        },
+    },
+]

package/index.html ADDED Viewed

@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <title>Preview for @swissgeo/coordinates</title>
+    </head>
+    <body>
+        <div id="app"></div>
+        <script
+            type="module"
+            src="src/dev.ts"
+        ></script>
+    </body>
+</html>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@swissgeo/coordinates",
-  "version": "1.0.0-beta.2",
+  "version": "1.0.0",
   "description": "Projection definition and coordinates utils for SWISSGEO projects.",
   "license": "BSD-3-Clause",
   "type": "module",
@@ -9,42 +9,43 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
+    },
+    "./ol": {
+      "types": "./dist/ol.d.ts",
+      "import": "./dist/ol.js",
+      "require": "./dist/ol.cjs"
     }
   },
-  "main": "./dist/index.umd.cjs",
-  "module": "./dist/index.js",
-  "files": [
-    "dist"
-  ],
   "dependencies": {
     "lodash": "^4.17.21",
-    "@swissgeo/log": "1.0.0-beta.2",
-    "@swissgeo/numbers": "1.0.0-beta.2"
+    "@swissgeo/log": "1.0.0",
+    "@swissgeo/numbers": "1.0.0"
   },
   "devDependencies": {
-    "@microsoft/api-extractor": "^7.55.0",
-    "@prettier/plugin-xml": "^3.4.2",
-    "@turf/turf": "^7.2.0",
+    "@microsoft/api-extractor": "^7.55.2",
+    "@turf/turf": "^7.3.1",
     "@types/chai": "^5.2.3",
     "@types/geojson": "^7946.0.16",
-    "@types/lodash": "^4.17.20",
-    "chai": "^6.2.1",
-    "eslint": "^9.39.1",
-    "prettier": "^3.6.2",
-    "prettier-plugin-jsdoc": "^1.5.0",
-    "prettier-plugin-packagejson": "^2.5.19",
-    "prettier-plugin-tailwindcss": "^0.7.1",
+    "@types/lodash": "^4.17.21",
+    "@vitejs/plugin-vue": "^6.0.3",
+    "chai": "^6.2.2",
+    "eslint": "^9.39.2",
     "typescript": "^5.9.3",
     "unplugin-dts": "1.0.0-beta.6",
-    "vite": "^7.2.2",
-    "vitest": "^4.0.8",
-    "@swissgeo/config-typescript": "1.0.0-beta.2",
-    "@swissgeo/config-eslint": "1.0.0-beta.2",
-    "@swissgeo/config-prettier": "1.0.0-beta.2"
+    "vite": "7.2.2",
+    "vite-plugin-vue-devtools": "^8.0.5",
+    "vite-tsconfig-paths": "^6.0.3",
+    "vitest": "^4.0.16",
+    "vue": "^3.5.26",
+    "vue-tsc": "^3.2.2",
+    "@swissgeo/config-typescript": "1.0.0",
+    "@swissgeo/config-eslint": "1.0.0"
   },
   "peerDependencies": {
-    "ol": "^10.7.0",
-    "proj4": "^2.20.0"
+    "proj4": "^2.20.2"
+  },
+  "optionalDependencies": {
+    "ol": "^10.7.0"
   },
   "scripts": {
     "build": "pnpm run type-check && pnpm run generate-types && vite build",
@@ -53,12 +54,12 @@
     "build:int": "pnpm run build --mode integration",
     "build:prod": "pnpm run build --mode production",
     "dev": "vite",
-    "generate-types": "tsc --declaration",
+    "generate-types": "vue-tsc --declaration",
     "lint": "eslint --fix",
     "lint:no-fix": "eslint",
     "preview": "vite preview",
-    "test:unit": "vitest --run --mode development --environment jsdom",
-    "test:unit:watch": "vitest --mode development --environment jsdom",
-    "type-check": "tsc -p tsconfig.json"
+    "test:unit": "vitest run",
+    "test:unit:watch": "vitest watch",
+    "type-check": "vue-tsc --build"
   }
 }

package/setup-vitest.ts ADDED Viewed

@@ -0,0 +1,8 @@
+import proj4 from 'proj4'
+import { beforeAll } from 'vitest'
+import registerProj4 from '@/registerProj4'
+beforeAll(() => {
+    registerProj4(proj4)
+})

package/src/DevApp.vue ADDED Viewed

@@ -0,0 +1,65 @@
+<script setup lang="ts">
+import OLTileLayer from 'ol/layer/Tile'
+import OLMap from 'ol/Map'
+import XYZ from 'ol/source/XYZ'
+import { onMounted } from 'vue'
+import { getLV95TileGrid, getLV95View, registerSwissGeoProjections as registerOL } from '@/ol'
+import { LV95 } from '@/proj'
+const pixelKarteFarbeURL = 'https://wmts.geo.admin.ch/1.0.0/ch.swisstopo.pixelkarte-farbe/default/current/2056/{z}/{x}/{y}.jpeg'
+function setupOpenLayers() {
+    registerOL()
+    const pixelKarteFarbe = new OLTileLayer({
+        source: new XYZ({
+            url: pixelKarteFarbeURL,
+            projection: LV95.epsg,
+            tileGrid: getLV95TileGrid()
+        })
+    })
+    new OLMap({
+        target: 'ol-map',
+        layers: [pixelKarteFarbe],
+        view: getLV95View()
+    })
+}
+onMounted(() => {
+    setupOpenLayers()
+})
+</script>
+<template>
+    <div class="dev-app">
+        <div class="map-container">
+            <h2>OpenLayers</h2>
+            <div
+                id="ol-map"
+                class="map-container-element"
+            ></div>
+        </div>
+    </div>
+</template>
+<style scoped lang="scss">
+.dev-app {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    display: grid;
+    grid-template-rows: 1fr 1fr;
+}
+.map-container {
+    display: flex;
+    flex-direction: column;
+    &-element {
+        flex-grow: 1;
+    }
+}
+</style>

package/src/__test__/coordinatesUtils.spec.ts ADDED Viewed

@@ -0,0 +1,178 @@
+import { describe, expect, it } from 'vitest'
+import type { Single3DCoordinate, SingleCoordinate } from '@/coordinatesUtils'
+import type { CoordinateSystem } from '@/proj'
+import coordinatesUtils from '@/coordinatesUtils'
+import { LV95, WEBMERCATOR, WGS84 } from '@/proj'
+describe('Unit test for coordinatesUtils', () => {
+    describe('toRoundedString', () => {
+        it('rounds without decimal if 0 is given as digits', () => {
+            expect(coordinatesUtils.toRoundedString([1.49, 2.49], 0)).to.eq(
+                '1, 2',
+                'it should floor any number lower than .5'
+            )
+            expect(coordinatesUtils.toRoundedString([1.5, 2.5], 0)).to.eq(
+                '2, 3',
+                'it should raise any number greater or equal to .5'
+            )
+        })
+        it('rounds with decimal if a number is given as digits', () => {
+            expect(coordinatesUtils.toRoundedString([1.44, 2.44], 1)).to.eq('1.4, 2.4')
+            expect(coordinatesUtils.toRoundedString([1.45, 2.45], 1)).to.eq('1.5, 2.5')
+        })
+        it('correctly enforcers digits when asked for', () => {
+            expect(coordinatesUtils.toRoundedString([1.44, 2.44], 5, false, true)).to.eq(
+                '1.44000, 2.44000'
+            )
+            expect(coordinatesUtils.toRoundedString([1, 2], 3, false, true)).to.eq('1.000, 2.000')
+            expect(coordinatesUtils.toRoundedString([1234.5678, 1234.5678], 6, true, true)).to.eq(
+                "1'234.567800, 1'234.567800"
+            )
+        })
+    })
+    describe('wrapXCoordinates()', () => {
+        it('can wrap a single coordinate', () => {
+            function testLowerWrap(projection: CoordinateSystem): void {
+                const bounds = projection.bounds
+                expect(bounds).to.be.an('Object')
+                expect(
+                    coordinatesUtils.wrapXCoordinates(
+                        [bounds!.lowerX - 1, bounds!.center[1]],
+                        projection
+                    )
+                ).to.deep.equal([bounds!.upperX - 1, bounds!.center[1]])
+            }
+            testLowerWrap(WGS84)
+            testLowerWrap(WEBMERCATOR)
+            function testUpperWrap(projection: CoordinateSystem) {
+                const bounds = projection.bounds
+                expect(bounds).to.be.an('Object')
+                expect(
+                    coordinatesUtils.wrapXCoordinates(
+                        [bounds!.upperX + 1, bounds!.center[1]],
+                        projection
+                    )
+                ).to.deep.equal([bounds!.lowerX + 1, bounds!.center[1]])
+            }
+            testUpperWrap(WGS84)
+            testUpperWrap(WEBMERCATOR)
+        })
+        it('do not wrap if projection is not global (world-wide)', () => {
+            const justOffBoundCoordinate: SingleCoordinate = [
+                LV95.bounds.lowerX - 1,
+                LV95.bounds.center[1],
+            ]
+            expect(coordinatesUtils.wrapXCoordinates(justOffBoundCoordinate, LV95)).to.deep.equal(
+                justOffBoundCoordinate
+            )
+        })
+        it('can wrap every coordinates of an array of coordinates', () => {
+            function testMultipleWrap(projection: CoordinateSystem) {
+                const bounds = projection.bounds
+                expect(bounds).to.be.an('Object')
+                const lowOutOfBoundCoordinate: SingleCoordinate = [
+                    bounds!.lowerX - 1,
+                    bounds!.center[1],
+                ]
+                const inBoundCoordinate: SingleCoordinate = [bounds!.lowerX, bounds!.center[1]]
+                const inBoundCoordinate2: SingleCoordinate = [bounds!.center[0], bounds!.center[1]]
+                const inBoundCoordinate3: SingleCoordinate = [bounds!.upperX, bounds!.center[1]]
+                const upOutOfBoundCoordinate: SingleCoordinate = [
+                    bounds!.upperX + 1,
+                    bounds!.center[1],
+                ]
+                const original = [
+                    lowOutOfBoundCoordinate,
+                    inBoundCoordinate,
+                    inBoundCoordinate2,
+                    inBoundCoordinate3,
+                    upOutOfBoundCoordinate,
+                ]
+                const result = coordinatesUtils.wrapXCoordinates(original, projection)
+                expect(result).to.be.an('Array').lengthOf(original.length)
+                const [first, second, third, fourth, fifth] = result
+                expect(first).to.deep.equal([bounds!.upperX - 1, lowOutOfBoundCoordinate[1]])
+                expect(second).to.deep.equal(inBoundCoordinate, 'wrong lowerX handling')
+                expect(third).to.deep.equal(inBoundCoordinate2, 'wrong center handling')
+                expect(fourth).to.deep.equal(inBoundCoordinate3, 'wrong upperX handling')
+                expect(fifth).to.deep.equal([bounds!.lowerX + 1, upOutOfBoundCoordinate[1]])
+            }
+            testMultipleWrap(WGS84)
+            testMultipleWrap(WEBMERCATOR)
+        })
+    })
+    describe('unwrapGeometryCoordinates(coordinates)', () => {
+        it('returns the input if nothing is required', () => {
+            expect(coordinatesUtils.unwrapGeometryCoordinates([])).to.be.an('Array').lengthOf(0)
+            const alreadyUnwrappedCoordinates: SingleCoordinate[] = [
+                [1, 2],
+                [3, 4],
+                [5, 6],
+            ]
+            expect(coordinatesUtils.unwrapGeometryCoordinates(alreadyUnwrappedCoordinates)).to.eql(
+                alreadyUnwrappedCoordinates
+            )
+        })
+        it('unwraps when required', () => {
+            const expectedOutcome: SingleCoordinate[] = [
+                [1, 2],
+                [3, 4],
+                [5, 6],
+            ]
+            const wrappedCoordinates = [expectedOutcome]
+            expect(coordinatesUtils.unwrapGeometryCoordinates(wrappedCoordinates)).to.eql(
+                expectedOutcome
+            )
+        })
+        it('can deal with multiple wrapping array around coordinates', () => {
+            const expectedOutcome: SingleCoordinate[] = [
+                [1, 2],
+                [3, 4],
+                [5, 6],
+            ]
+            const wrappedCoordinates = [[expectedOutcome]]
+            expect(coordinatesUtils.unwrapGeometryCoordinates(wrappedCoordinates)).to.eql(
+                expectedOutcome
+            )
+        })
+    })
+    describe('removeZValues', () => {
+        it('returns the input if an empty array is given', () => {
+            expect(coordinatesUtils.removeZValues([])).to.eql([])
+        })
+        it('returns coordinate untouched if they have no Z values', () => {
+            const coordinates: SingleCoordinate[] = [
+                [1, 2],
+                [3, 4],
+                [5, 6],
+            ]
+            expect(coordinatesUtils.removeZValues(coordinates)).to.eql(coordinates)
+        })
+        it('removes Z values when needed', () => {
+            const coordinateWithoutZValues: SingleCoordinate[] = [
+                [1, 2],
+                [3, 4],
+                [5, 6],
+            ]
+            expect(
+                coordinatesUtils.removeZValues(
+                    coordinateWithoutZValues.map(
+                        (coordinate): Single3DCoordinate => [
+                            coordinate[0],
+                            coordinate[1],
+                            Math.floor(1 + 10 * Math.random()),
+                        ]
+                    )
+                )
+            ).to.eql(coordinateWithoutZValues)
+            // testing with only one coordinate
+            expect(coordinatesUtils.removeZValues([[1, 2, 3]])).to.eql([[1, 2]])
+        })
+    })
+})

package/src/__test__/extentUtils.spec.ts ADDED Viewed

@@ -0,0 +1,92 @@
+import { describe, expect, it } from 'vitest'
+import type { SingleCoordinate } from '@/coordinatesUtils'
+import type { FlatExtent } from '@/extentUtils'
+import coordinatesUtils from '@/coordinatesUtils'
+import { getExtentIntersectionWithCurrentProjection, getExtentCenter } from '@/extentUtils'
+import { LV95, WGS84 } from '@/proj'
+describe('Test extent utils', () => {
+    describe('reproject and cut extent within projection bounds', () => {
+        function expectExtentIs(
+            toBeTested: FlatExtent,
+            expected: FlatExtent,
+            acceptableDelta = 0.5
+        ) {
+            expect(toBeTested).to.be.an('Array').lengthOf(4)
+            expected.forEach((value, index) => {
+                expect(toBeTested[index]).to.be.approximately(value, acceptableDelta)
+            })
+        }
+        it('reproject extent of a single coordinate inside the bounds of the projection', () => {
+            const singleCoordinate: SingleCoordinate = [8.2, 47.5]
+            const singleCoordinateInLV95 = coordinatesUtils.reprojectAndRound(
+                WGS84,
+                LV95,
+                singleCoordinate
+            )
+            const extent = [singleCoordinate, singleCoordinate].flat() as FlatExtent
+            const result = getExtentIntersectionWithCurrentProjection(extent, WGS84, LV95)
+            expect(result).to.be.an('Array').lengthOf(4)
+            expectExtentIs(result!, [...singleCoordinateInLV95, ...singleCoordinateInLV95])
+        })
+        it('returns undefined if a single coordinate outside of bounds is given', () => {
+            const singleCoordinateOutOfLV95Bounds = [8.2, 40]
+            const extent = [
+                singleCoordinateOutOfLV95Bounds,
+                singleCoordinateOutOfLV95Bounds,
+            ].flat() as FlatExtent
+            expect(getExtentIntersectionWithCurrentProjection(extent, WGS84, LV95)).to.be.undefined
+        })
+        it('returns undefined if the extent given is completely outside of the projection bounds', () => {
+            const extent: FlatExtent = [-25.0, -20.0, -5.0, -45.0]
+            expect(getExtentIntersectionWithCurrentProjection(extent, WGS84, LV95)).to.be.undefined
+        })
+        it('reproject and cut an extent that is greater than LV95 extent on all sides', () => {
+            const result = getExtentIntersectionWithCurrentProjection(
+                [-2.4, 35, 21.3, 51.7],
+                WGS84,
+                LV95
+            )
+            expect(result).to.be.an('Array').lengthOf(4)
+            expectExtentIs(result!, [...LV95.bounds.bottomLeft, ...LV95.bounds.topRight])
+        })
+        it('reproject and cut an extent that is partially bigger than LV95 bounds', () => {
+            const result = getExtentIntersectionWithCurrentProjection(
+                // extent of file linked to PB-1221
+                [-122.08, -33.85, 151.21, 51.5],
+                WGS84,
+                LV95
+            )
+            expect(result).to.be.an('Array').lengthOf(4)
+            expectExtentIs(result!, [...LV95.bounds.bottomLeft, ...LV95.bounds.topRight])
+        })
+        it('only gives back the portion of an extent that is within LV95 bounds', () => {
+            const singleCoordinateInsideLV95: SingleCoordinate = [7.54, 48.12]
+            const singleCoordinateInLV95 = coordinatesUtils.reprojectAndRound(
+                WGS84,
+                LV95,
+                singleCoordinateInsideLV95
+            )
+            const overlappingExtent: FlatExtent = [0, 0, ...singleCoordinateInsideLV95]
+            const result = getExtentIntersectionWithCurrentProjection(
+                overlappingExtent,
+                WGS84,
+                LV95
+            )
+            expect(result).to.be.an('Array').lengthOf(4)
+            expectExtentIs(result!, [...LV95.bounds.bottomLeft, ...singleCoordinateInLV95])
+        })
+    })
+    describe('getExtentCenter', () => {
+        it('calculates the center of an extent', () => {
+            const extent: FlatExtent = [0, 0, 30, 70]
+            const center = getExtentCenter(extent)
+            expect(center).to.be.an('Array').lengthOf(2)
+            expect(center[0]).to.be.closeTo(15, 0.0001)
+            expect(center[1]).to.be.closeTo(35, 0.0001)
+        })
+    })
+})

package/src/coordinatesUtils.ts ADDED Viewed

@@ -0,0 +1,188 @@
+import { formatThousand, isNumber, round } from '@swissgeo/numbers'
+import proj4 from 'proj4'
+import type CoordinateSystem from '@/proj/CoordinateSystem'
+import { allCoordinateSystems, WGS84 } from '@/proj'
+export type SingleCoordinate = [number, number]
+export type Single3DCoordinate = [number, number, number]
+function isValidCoordinate(input: unknown): boolean {
+    if (!Array.isArray(input) || input.length === 0) {
+        return false
+    }
+    return typeof input[0] === 'number' && typeof input[1] === 'number'
+}
+/**
+ * Returns rounded coordinate with thousands separator and comma.
+ *
+ * @param coordinate The raw coordinate as array.
+ * @param digits Decimal digits to round to.
+ * @param [withThousandsSeparator=true] If thousands should be separated with a single quote
+ *   character. Default is `true`
+ * @param [enforceDigit=false] If set to true, we want to have that many figures after the period.
+ *   Otherwise, we don't care. Default is `false`
+ * @returns Formatted coordinate.
+ * @see https://stackoverflow.com/a/2901298/4840446
+ */
+function toRoundedString(
+    coordinate: SingleCoordinate,
+    digits: number,
+    withThousandsSeparator: boolean = true,
+    enforceDigit: boolean = false
+): string | undefined {
+    if (
+        !Array.isArray(coordinate) ||
+        coordinate.length !== 2 ||
+        !coordinate.every(isNumber) ||
+        coordinate.some(
+            (value) => value === Number.POSITIVE_INFINITY || value === Number.NEGATIVE_INFINITY
+        )
+    ) {
+        return
+    }
+    return coordinate
+        .map((value) => {
+            const roundedValue: number = round(value, digits)
+            let stringValue: string
+            if (enforceDigit) {
+                stringValue = roundedValue.toFixed(digits)
+            } else {
+                stringValue = roundedValue.toString()
+            }
+            if (withThousandsSeparator) {
+                return formatThousand(stringValue)
+            }
+            return stringValue
+        })
+        .join(', ')
+}
+/**
+ * Wraps the provided coordinates in the world extents (i.e. the coordinate range that if equivalent
+ * to the wgs84 [-180, 180])
+ *
+ * @param coordinates The coordinates (or array of coordinates) to wrap
+ * @param projection Projection of the coordinates
+ * @returns Coordinates wrapped on the X axis
+ */
+function wrapXCoordinates<T extends SingleCoordinate | SingleCoordinate[]>(
+    coordinates: T,
+    projection: CoordinateSystem
+): T {
+    if (projection.usesMercatorPyramid && projection.bounds && Array.isArray(coordinates)) {
+        if (coordinates.length === 2 && coordinates.every(isNumber)) {
+            const [x, y] = coordinates as SingleCoordinate
+            if (x >= projection.bounds.lowerX && x <= projection.bounds.upperX) {
+                return coordinates
+            }
+            const boundsWidth = projection.bounds.upperX - projection.bounds.lowerX
+            const worldsAway = Math.floor((x - projection.bounds.lowerX) / boundsWidth)
+            const offset = worldsAway * boundsWidth
+            return [x - offset, y] as T
+        } else if (coordinates.every(Array.isArray)) {
+            return (coordinates as SingleCoordinate[]).map((coordinate) =>
+                wrapXCoordinates(coordinate, projection)
+            ) as T
+        }
+    }
+    return coordinates
+}
+/**
+ * Returns the coordinates unwrapped if they were placed into an extra array. This can happen when
+ * dealing with GeoJSON coordinate, where some geometry types require coordinate in a format such as
+ * [ [ [x,y], [x,y] ], [...feature2...] ]
+ *
+ * Most of our backends only deal with the first feature of such array, this function will unwrap
+ * it, or return the array as is if it is not required
+ */
+function unwrapGeometryCoordinates(
+    geometryCoordinates?: SingleCoordinate[] | SingleCoordinate[][] | SingleCoordinate[][][]
+): SingleCoordinate[] {
+    if (!geometryCoordinates) {
+        return []
+    }
+    if (geometryCoordinates.every((value) => isValidCoordinate(value))) {
+        return geometryCoordinates as SingleCoordinate[]
+    } else {
+        return unwrapGeometryCoordinates(
+            (geometryCoordinates as SingleCoordinate[][] | SingleCoordinate[][][])[0]
+        )
+    }
+}
+/**
+ * Remove any Z value from a set of coordinates
+ *
+ * @param coordinates
+ */
+function removeZValues(coordinates: SingleCoordinate[] | Single3DCoordinate[]): SingleCoordinate[] {
+    if (Array.isArray(coordinates)) {
+        if (coordinates.every((coordinate) => coordinate.length === 2)) {
+            return coordinates
+        } else if (coordinates.some((coordinate) => coordinate.length > 2)) {
+            return coordinates.map((coordinate) => [coordinate[0], coordinate[1]])
+        }
+    }
+    throw new Error('Invalid coordinates received, cannot remove Z values')
+}
+function reprojectAndRound<T extends SingleCoordinate | SingleCoordinate[]>(
+    from: CoordinateSystem,
+    into: CoordinateSystem,
+    coordinates: T
+): T {
+    if (!from || !into) {
+        throw new Error('Invalid arguments, must receive two CRS')
+    }
+    if (!isValidCoordinate(coordinates)) {
+        throw new Error(
+            'Invalid coordinates received, must be an array of number or an array of coordinates'
+        )
+    }
+    const depthOne = coordinates[0]
+    if (Array.isArray(depthOne)) {
+        return (coordinates as SingleCoordinate[]).map((coordinate) =>
+            reprojectAndRound(from, into, coordinate)
+        ) as T
+    }
+    return proj4(from.epsg, into.epsg, coordinates as SingleCoordinate).map((value) =>
+        into.roundCoordinateValue(value)
+    ) as T
+}
+function parseCRS(crs?: string): CoordinateSystem | undefined {
+    const epsgNumber = crs?.split(':').pop()
+    if (!epsgNumber) {
+        return
+    }
+    if (epsgNumber === 'WGS84') {
+        return WGS84
+    }
+    return allCoordinateSystems.find((system) => system.epsg === `EPSG:${epsgNumber}`)
+}
+export interface SwissGeoCoordinatesUtils {
+    toRoundedString: typeof toRoundedString
+    wrapXCoordinates: typeof wrapXCoordinates
+    unwrapGeometryCoordinates: typeof unwrapGeometryCoordinates
+    removeZValues: typeof removeZValues
+    reprojectAndRound: typeof reprojectAndRound
+    parseCRS: typeof parseCRS
+}
+const coordinatesUtils: SwissGeoCoordinatesUtils = {
+    toRoundedString,
+    wrapXCoordinates,
+    unwrapGeometryCoordinates,
+    removeZValues,
+    reprojectAndRound,
+    parseCRS,
+}
+export { coordinatesUtils }
+export default coordinatesUtils

package/src/dev.ts ADDED Viewed

@@ -0,0 +1,6 @@
+import { createApp } from 'vue'
+import DevApp from '@/DevApp.vue'
+const devApp = createApp(DevApp)
+devApp.mount('#app')