terra-route 0.0.11 → 0.0.13

package/src/graph/methods/bounding-box.ts

@@ -1,85 +0,0 @@
-import { Feature, FeatureCollection, LineString, Position } from 'geojson'
-
-/**
- * Type representing a bounding box as [minLng, minLat, maxLng, maxLat]
- */
-export type BoundingBox = [number, number, number, number]
-
-/**
- * Filters a FeatureCollection of LineString features to only include LineStrings 
- * that are completely within the specified bounding box.
- * @param featureCollection - A GeoJSON FeatureCollection containing LineString features
- * @param boundingBox - A bounding box array in the format [minLng, minLat, maxLng, maxLat]
- * @returns A new FeatureCollection<LineString> containing only the LineStrings completely within the bounding box
- */
-export function getNetworkInBoundingBox(
-    featureCollection: FeatureCollection<LineString>,
-    boundingBox: BoundingBox
-): FeatureCollection<LineString> {
-    const [minLng, minLat, maxLng, maxLat] = boundingBox
-
-    // Validate bounding box
-    if (minLng >= maxLng || minLat >= maxLat) {
-        throw new Error('Invalid bounding box: min values must be less than max values')
-    }
-
-    const filteredFeatures: Feature<LineString>[] = []
-
-    for (const feature of featureCollection.features) {
-        if (isLineStringCompletelyWithinBounds(feature, minLng, minLat, maxLng, maxLat)) {
-            filteredFeatures.push(feature)
-        }
-    }
-
-    return {
-        type: 'FeatureCollection',
-        features: filteredFeatures
-    }
-}
-
-/**
- * Checks if a LineString feature is completely within the specified bounds.
- * @param lineStringFeature - A GeoJSON Feature<LineString>
- * @param minLng - Minimum longitude
- * @param minLat - Minimum latitude
- * @param maxLng - Maximum longitude
- * @param maxLat - Maximum latitude
- * @returns true if all coordinates of the LineString are within the bounds, false otherwise
- */
-function isLineStringCompletelyWithinBounds(
-    lineStringFeature: Feature<LineString>,
-    minLng: number,
-    minLat: number,
-    maxLng: number,
-    maxLat: number
-): boolean {
-    const coordinates = lineStringFeature.geometry.coordinates
-
-    for (const coordinate of coordinates) {
-        if (!isCoordinateWithinBounds(coordinate, minLng, minLat, maxLng, maxLat)) {
-            return false
-        }
-    }
-
-    return true
-}
-
-/**
- * Checks if a coordinate is within the specified bounds.
- * @param coordinate - A coordinate position [lng, lat]
- * @param minLng - Minimum longitude
- * @param minLat - Minimum latitude
- * @param maxLng - Maximum longitude
- * @param maxLat - Maximum latitude
- * @returns true if the coordinate is within the bounds, false otherwise
- */
-function isCoordinateWithinBounds(
-    coordinate: Position,
-    minLng: number,
-    minLat: number,
-    maxLng: number,
-    maxLat: number
-): boolean {
-    const [lng, lat] = coordinate
-    return lng >= minLng && lng <= maxLng && lat >= minLat && lat <= maxLat
-}

package/src/graph/methods/connected.spec.ts

@@ -1,219 +0,0 @@
-import { FeatureCollection, LineString } from 'geojson';
-import { graphGetConnectedComponentCount, graphGetConnectedComponents } from './connected';
-import { generateTreeFeatureCollection } from '../../test-utils/generate-network';
-import { createFeatureCollection, createLineStringFeature } from '../../test-utils/create';
-import { readFileSync, writeFileSync } from 'fs';
-import { unifyCloseCoordinates } from './unify';
-
-describe('countConnectedComponents', () => {
-    describe('for an empty feature collection', () => {
-        it('returns 0', () => {
-            const input: FeatureCollection<LineString> = createFeatureCollection([]);
-            const output = graphGetConnectedComponentCount(input);
-
-            expect(output).toBe(0);
-        });
-    });
-
-    describe('for feature collection with 1 linestring', () => {
-        it('returns 1', () => {
-            const input: FeatureCollection<LineString> = createFeatureCollection([
-                createLineStringFeature([[0, 0], [1, 1]])
-            ]);
-            const output = graphGetConnectedComponentCount(input);
-
-            expect(output).toBe(1);
-        });
-    });
-
-    describe('for feature collection with 2 linestring', () => {
-        it('returns 1 if connected', () => {
-            const input: FeatureCollection<LineString> = createFeatureCollection([
-                createLineStringFeature([[0, 0], [1, 1]]),
-                createLineStringFeature([[1, 1], [2, 2]]),
-
-            ]);
-            const output = graphGetConnectedComponentCount(input);
-
-            expect(output).toBe(1);
-        });
-
-        it('returns 2 if unconnected', () => {
-            const input: FeatureCollection<LineString> = createFeatureCollection([
-                createLineStringFeature([[0, 0], [1, 1]]),
-                createLineStringFeature([[10, 10], [11, 11]]),
-
-            ]);
-            const output = graphGetConnectedComponentCount(input);
-
-            expect(output).toBe(2);
-        });
-    });
-
-    describe('for feature collection with 3 linestring', () => {
-        it('returns 1 if connected', () => {
-            const input: FeatureCollection<LineString> = createFeatureCollection([
-                createLineStringFeature([[0, 0], [1, 1]]),
-                createLineStringFeature([[1, 1], [2, 2]]),
-                createLineStringFeature([[2, 2], [3, 3]]),
-
-            ]);
-            const output = graphGetConnectedComponentCount(input);
-
-            expect(output).toBe(1);
-        });
-
-        it('returns 3 if unconnected', () => {
-            const input: FeatureCollection<LineString> = createFeatureCollection([
-                createLineStringFeature([[0, 0], [1, 1]]),
-                createLineStringFeature([[10, 10], [11, 11]]),
-                createLineStringFeature([[20, 20], [21, 21]]),
-            ]);
-            const output = graphGetConnectedComponentCount(input);
-
-            expect(output).toBe(3);
-        });
-    });
-
-
-    describe('for feature collection with multiple linestring', () => {
-        it('returns 1 when all lines share the same coordinate', () => {
-            const input = createFeatureCollection([
-                createLineStringFeature([[0, 0], [1, 1]]),
-                createLineStringFeature([[1, 1], [2, 2]]),
-                createLineStringFeature([[1, 1], [3, 3]]),
-                createLineStringFeature([[4, 4], [1, 1]]),
-            ]);
-            const output = graphGetConnectedComponentCount(input);
-
-            expect(output).toBe(1);
-        });
-
-        it('returns 2 when two disconnected groups exist', () => {
-            const input = createFeatureCollection([
-                createLineStringFeature([[0, 0], [1, 1]]),
-                createLineStringFeature([[1, 1], [2, 2]]),
-                createLineStringFeature([[10, 10], [11, 11]]),
-                createLineStringFeature([[11, 11], [12, 12]]),
-            ]);
-            const output = graphGetConnectedComponentCount(input);
-
-            expect(output).toBe(2);
-        });
-
-
-        it('returns 1 for a loop of connected lines', () => {
-            const input = createFeatureCollection([
-                createLineStringFeature([[0, 0], [1, 0]]),
-                createLineStringFeature([[1, 0], [1, 1]]),
-                createLineStringFeature([[1, 1], [0, 1]]),
-                createLineStringFeature([[0, 1], [0, 0]]),
-            ]);
-            const output = graphGetConnectedComponentCount(input);
-
-            expect(output).toBe(1);
-        });
-    });
-
-    describe('for complex linestring network', () => {
-        it('returns 1 when tree is connected', () => {
-            const input = generateTreeFeatureCollection(3, 2)
-            const output = graphGetConnectedComponentCount(input)
-
-            expect(output).toBe(1);
-        });
-
-        it('returns 1 when it is connected correctly', () => {
-            const input = generateTreeFeatureCollection(3, 2)
-            const output = graphGetConnectedComponentCount(input)
-
-            expect(output).toBe(1);
-        });
-    })
-});
-
-describe('splitIntoConnectedComponents', () => {
-    it('returns empty array for empty feature collection', () => {
-        const input: FeatureCollection<LineString> = createFeatureCollection([]);
-        const output = graphGetConnectedComponents(input);
-
-        expect(output).toEqual([]);
-    });
-
-    it('returns single component for single linestring', () => {
-        const input: FeatureCollection<LineString> = createFeatureCollection([
-            createLineStringFeature([[0, 0], [1, 1]])
-        ]);
-        const output = graphGetConnectedComponents(input);
-
-        expect(output).toHaveLength(1);
-        expect(output[0].features).toHaveLength(1);
-    });
-
-    it('returns multiple components for disconnected linestrings', () => {
-        const input: FeatureCollection<LineString> = createFeatureCollection([
-            createLineStringFeature([[0, 0], [1, 1]]),
-            createLineStringFeature([[10, 10], [11, 11]])
-        ]);
-        const output = graphGetConnectedComponents(input);
-
-        expect(output).toHaveLength(2);
-        expect(output[0].features).toHaveLength(1);
-        expect(output[1].features).toHaveLength(1);
-    });
-
-    it('returns single component for connected linestrings', () => {
-        const input: FeatureCollection<LineString> = createFeatureCollection([
-            createLineStringFeature([[0, 0], [1, 1]]),
-            createLineStringFeature([[1, 1], [2, 2]])
-        ]);
-        const output = graphGetConnectedComponents(input);
-
-        expect(output).toHaveLength(1);
-        expect(output[0].features).toHaveLength(2);
-        expect(output[0].features[0].geometry.coordinates).toEqual([[0, 0], [1, 1]]);
-        expect(output[0].features[1].geometry.coordinates).toEqual([[1, 1], [2, 2]]);
-    });
-
-    it('returns multiple components for selection of connected linestrings', () => {
-        const input: FeatureCollection<LineString> = createFeatureCollection([
-            createLineStringFeature([[0, 0], [1, 1]]),
-            createLineStringFeature([[1, 1], [2, 2]]),
-            createLineStringFeature([[10, 10], [11, 11]]),
-            createLineStringFeature([[20, 20], [21, 21]])
-        ]);
-        const output = graphGetConnectedComponents(input);
-
-        expect(output).toHaveLength(3);
-        expect(output[0].features).toHaveLength(1);
-        expect(output[1].features).toHaveLength(1);
-        expect(output[2].features).toHaveLength(2);
-    });
-
-    it('returns single component for complex selection of linestrings', () => {
-        const network = JSON.parse(readFileSync('src/data/network.geojson', 'utf-8')) as FeatureCollection<LineString>;
-        const output = graphGetConnectedComponents(network);
-        expect(output).toHaveLength(1);
-        expect(output[0].features).toHaveLength(network.features.length);
-    });
-
-    it('returns multiple components for complex selection of linestrings', () => {
-        const network = JSON.parse(readFileSync('src/data/network-5-cc.geojson', 'utf-8')) as FeatureCollection<LineString>;
-        const output = graphGetConnectedComponents(network);
-        expect(output).toHaveLength(5);
-        expect(output[4].features > output[0].features).toBeTruthy();
-    });
-
-    it('ensures splitIntoConnectedComponents and countConnectedComponents are consistent', () => {
-        const network = JSON.parse(readFileSync('src/data/network.geojson', 'utf-8')) as FeatureCollection<LineString>;
-        const components = graphGetConnectedComponents(network);
-        const count = graphGetConnectedComponentCount(network);
-        expect(components.length).toBe(count);
-
-        const networkMultipleCC = JSON.parse(readFileSync('src/data/network-5-cc.geojson', 'utf-8')) as FeatureCollection<LineString>;
-        const componentsMultipleCC = graphGetConnectedComponents(networkMultipleCC);
-        const countMultipleCC = graphGetConnectedComponentCount(networkMultipleCC);
-        expect(componentsMultipleCC.length).toBe(countMultipleCC);
-    });
-
-})

package/src/graph/methods/connected.ts

@@ -1,168 +0,0 @@
-import { Feature, FeatureCollection, LineString, Position } from 'geojson'
-
-/**
- * Counts the number of connected components in a graph represented by LineString features in a GeoJSON FeatureCollection.
- * Each LineString is treated as an edge in the graph, and connected components are determined by shared coordinates.
- * @param featureCollection - A GeoJSON FeatureCollection containing LineString features
- * @returns The number of connected components in the graph represented by the LineStrings
- */
-export function graphGetConnectedComponentCount(
-    featureCollection: FeatureCollection<LineString>
-): number {
-    const features = featureCollection.features
-    const numberOfFeatures = features.length
-
-    // Map coordinates to feature indices
-    const coordinateToFeatureIndices = new Map<string, number[]>()
-
-    for (let index = 0; index < numberOfFeatures; index++) {
-        const coordinates = features[index].geometry.coordinates
-
-        for (const coordinate of coordinates) {
-            const key = coordinateKey(coordinate)
-
-            if (!coordinateToFeatureIndices.has(key)) {
-                coordinateToFeatureIndices.set(key, [])
-            }
-
-            coordinateToFeatureIndices.get(key)!.push(index)
-        }
-    }
-
-    // Build adjacency list for the graph
-    const adjacencyList: number[][] = Array.from({ length: numberOfFeatures }, () => [])
-
-    for (const indices of coordinateToFeatureIndices.values()) {
-        for (let i = 0; i < indices.length; i++) {
-            for (let j = i + 1; j < indices.length; j++) {
-                const a = indices[i]
-                const b = indices[j]
-                adjacencyList[a].push(b)
-                adjacencyList[b].push(a)
-            }
-        }
-    }
-
-    const visited = new Array<boolean>(numberOfFeatures).fill(false)
-    let connectedComponents = 0
-
-    for (let index = 0; index < numberOfFeatures; index++) {
-        if (!visited[index]) {
-            dfs(index, adjacencyList, visited)
-            connectedComponents++
-        }
-    }
-
-    return connectedComponents
-}
-
-/**
- * Depth-first search to mark all reachable nodes from the given index.
- * @param index - The current node index to start DFS from.
- * @param adjacencyList - The adjacency list representing the graph.
- * @param visited - An array to keep track of visited nodes.
- */
-function dfs(index: number, adjacencyList: number[][], visited: boolean[]): void {
-    visited[index] = true
-
-    for (const neighbor of adjacencyList[index]) {
-        if (!visited[neighbor]) {
-            dfs(neighbor, adjacencyList, visited)
-        }
-    }
-}
-
-function coordinateKey(position: Position): string {
-    return `${position[0]},${position[1]}`
-}
-
-export function graphGetConnectedComponents(
-    featureCollection: FeatureCollection<LineString>
-): FeatureCollection<LineString>[] {
-    const features = featureCollection.features
-    const graph: Map<number, Set<number>> = new Map()
-    const coordinateMap: Map<string, Set<number>> = new Map()
-
-    function coordinateKey(coordinate: Position): string {
-        return `${coordinate[0]},${coordinate[1]}`
-    }
-
-    // Build coordinate map: coordinate string -> Set of feature indices
-    for (let index = 0; index < features.length; index++) {
-        const coordinates = features[index].geometry.coordinates
-
-        for (const coordinate of coordinates) {
-            const key = coordinateKey(coordinate)
-
-            if (!coordinateMap.has(key)) {
-                coordinateMap.set(key, new Set())
-            }
-
-            coordinateMap.get(key)!.add(index)
-        }
-    }
-
-    // Build adjacency list for graph
-    for (let index = 0; index < features.length; index++) {
-        graph.set(index, new Set())
-
-        const coordinates = features[index].geometry.coordinates
-        for (const coordinate of coordinates) {
-            const key = coordinateKey(coordinate)
-            const neighbors = coordinateMap.get(key)
-
-            if (neighbors) {
-                for (const neighborIndex of neighbors) {
-                    if (neighborIndex !== index) {
-                        graph.get(index)!.add(neighborIndex)
-                    }
-                }
-            }
-        }
-    }
-
-    // DFS to find connected components
-    const visited = new Set<number>()
-    const components: FeatureCollection<LineString>[] = []
-
-    function dfs(startIndex: number, currentComponent: Feature<LineString>[]): void {
-        const stack: number[] = [startIndex]
-
-        while (stack.length > 0) {
-            const currentIndex = stack.pop()!
-
-            if (visited.has(currentIndex)) {
-                continue
-            }
-
-            visited.add(currentIndex)
-            currentComponent.push(features[currentIndex])
-
-            const neighbors = graph.get(currentIndex)
-            if (neighbors) {
-                for (const neighbor of neighbors) {
-                    if (!visited.has(neighbor)) {
-                        stack.push(neighbor)
-                    }
-                }
-            }
-        }
-    }
-
-    for (let index = 0; index < features.length; index++) {
-        if (!visited.has(index)) {
-            const component: Feature<LineString>[] = []
-            dfs(index, component)
-            components.push({
-                type: 'FeatureCollection',
-                features: component
-            })
-        }
-    }
-
-
-    // Sort components by the number of features in ascending order
-    components.sort((a, b) => a.features.length - b.features.length)
-
-    return components
-}

package/src/graph/methods/duplicates.spec.ts

@@ -1,161 +0,0 @@
-import { FeatureCollection, LineString } from 'geojson';
-import { createFeatureCollection } from '../../test-utils/create';
-import { removeDuplicateAndSubsectionLines } from './duplicates';
-import { readFileSync } from 'fs';
-import { graphGetNodeAndEdgeCount } from './nodes';
-
-describe('removeDuplicateAndSubsectionLines', () => {
-    describe('for an empty feature collection', () => {
-        it('returns 0', () => {
-            const input: FeatureCollection<LineString> = createFeatureCollection([]);
-            const output = removeDuplicateAndSubsectionLines(input);
-
-            expect(output).toEqual(createFeatureCollection([]));
-        });
-    });
-
-    describe('for feature collection with 1 linestring', () => {
-        it('returns 1', () => {
-            const input: FeatureCollection<LineString> = createFeatureCollection([
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1]] }, properties: {} }
-            ]);
-            const output = removeDuplicateAndSubsectionLines(input);
-
-            expect(output.features.length).toBe(1);
-            expect(output.features[0].geometry.coordinates).toEqual([[0, 0], [1, 1]]);
-        });
-    });
-
-    describe('for feature collection with 2 linestrings', () => {
-        it('handles duplicates', () => {
-            const input: FeatureCollection<LineString> = createFeatureCollection([
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1]] }, properties: {} },
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1]] }, properties: {} }
-            ]);
-            const output = removeDuplicateAndSubsectionLines(input);
-
-            expect(output.features.length).toBe(1);
-            expect(output.features[0].geometry.coordinates).toEqual([[0, 0], [1, 1]]);
-        });
-
-        it('returns one linestring if one is a subsection of the other', () => {
-            const input: FeatureCollection<LineString> = createFeatureCollection([
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1]] }, properties: {} },
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1], [2, 2]] }, properties: {} }
-            ]);
-            const output = removeDuplicateAndSubsectionLines(input);
-
-            expect(output.features.length).toBe(1);
-            expect(output.features[0].geometry.coordinates).toEqual([[0, 0], [1, 1], [2, 2]]);
-        });
-
-        it('returns both if they are not subsections or duplicates', () => {
-            const input: FeatureCollection<LineString> = createFeatureCollection([
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1]] }, properties: {} },
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[2, 2], [3, 3]] }, properties: {} }
-            ]);
-            const output = removeDuplicateAndSubsectionLines(input);
-
-            expect(output.features.length).toBe(2);
-        });
-
-        it('returns one linestring if one is a inverse duplicate of the other', () => {
-            const input: FeatureCollection<LineString> = createFeatureCollection([
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1]] }, properties: {} },
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[1, 1], [0, 0]] }, properties: {} }
-            ]);
-            const output = removeDuplicateAndSubsectionLines(input);
-            expect(output.features.length).toBe(1);
-            expect(output.features[0].geometry.coordinates).toEqual([[0, 0], [1, 1]]);
-        });
-    });
-
-    describe('for feature collection with 3 linestrings', () => {
-        it('returns 1 linestring if all are duplicates', () => {
-            const input: FeatureCollection<LineString> = createFeatureCollection([
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1]] }, properties: {} },
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1]] }, properties: {} },
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1]] }, properties: {} }
-            ]);
-            const output = removeDuplicateAndSubsectionLines(input);
-            expect(output.features.length).toBe(1);
-            expect(output.features[0].geometry.coordinates).toEqual([[0, 0], [1, 1]]);
-        });
-
-        it('returns 2 linestrings if one is a subsection of another', () => {
-            const input: FeatureCollection<LineString> = createFeatureCollection([
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1]] }, properties: {} },
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1], [2, 2]] }, properties: {} },
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[3, 3], [4, 4]] }, properties: {} }
-            ]);
-            const output = removeDuplicateAndSubsectionLines(input);
-            expect(output.features.length).toBe(2);
-            expect(output.features[0].geometry.coordinates).toEqual([[0, 0], [1, 1], [2, 2]]);
-            expect(output.features[1].geometry.coordinates).toEqual([[3, 3], [4, 4]]);
-        });
-
-        it('returns all if none are subsections or duplicates', () => {
-            const input: FeatureCollection<LineString> = createFeatureCollection([
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1]] }, properties: {} },
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[2, 2], [3, 3]] }, properties: {} },
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[4, 4], [5, 5]] }, properties: {} }
-            ]);
-            const output = removeDuplicateAndSubsectionLines(input);
-            expect(output.features.length).toBe(3);
-            expect(output.features[0].geometry.coordinates).toEqual([[0, 0], [1, 1]]);
-            expect(output.features[1].geometry.coordinates).toEqual([[2, 2], [3, 3]]);
-            expect(output.features[2].geometry.coordinates).toEqual([[4, 4], [5, 5]]);
-        });
-
-        it('returns 1 linestring if one is a subsection of another and the third is a duplicate', () => {
-            const input: FeatureCollection<LineString> = createFeatureCollection([
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1]] }, properties: {} },
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1], [2, 2]] }, properties: {} },
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1]] }, properties: {} }
-            ]);
-            const output = removeDuplicateAndSubsectionLines(input);
-            expect(output.features.length).toBe(1);
-            expect(output.features[0].geometry.coordinates).toEqual([[0, 0], [1, 1], [2, 2]]);
-        });
-
-        it('returns 1 linestring if one is a subsection of another and the third is an inverse duplicate', () => {
-            const input: FeatureCollection<LineString> = createFeatureCollection([
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1]] }, properties: {} },
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1], [2, 2]] }, properties: {} },
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[1, 1], [0, 0]] }, properties: {} }
-            ]);
-            const output = removeDuplicateAndSubsectionLines(input);
-            expect(output.features.length).toBe(1);
-            expect(output.features[0].geometry.coordinates).toEqual([[0, 0], [1, 1], [2, 2]]);
-        });
-    });
-
-    describe('for feature collection with multiple linestrings', () => {
-        it('handles multiple duplicates and subsections', () => {
-            const input: FeatureCollection<LineString> = createFeatureCollection([
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1]] }, properties: {} },
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1], [2, 2]] }, properties: {} },
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[3, 3], [4, 4]] }, properties: {} },
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[3, 3], [4, 4], [5, 5]] }, properties: {} }
-            ]);
-            const output = removeDuplicateAndSubsectionLines(input);
-
-            expect(output.features.length).toBe(2);
-            expect(output.features[0].geometry.coordinates).toEqual([[0, 0], [1, 1], [2, 2]]);
-            expect(output.features[1].geometry.coordinates).toEqual([[3, 3], [4, 4], [5, 5]]);
-        });
-
-        it('ensures it does not effect the network in a complex scenario', () => {
-            const network = JSON.parse(readFileSync('src/data/network.geojson', 'utf-8')) as FeatureCollection<LineString>;
-
-            expect(network.features.length).toBe(811);
-
-            const after = removeDuplicateAndSubsectionLines(network);
-
-            // There are no duplicates or subsections in the network
-            expect(after.features.length).toBe(811);
-
-            expect(graphGetNodeAndEdgeCount(removeDuplicateAndSubsectionLines(after))).toEqual(graphGetNodeAndEdgeCount(network))
-        });
-    })
-});