@tmlmobilidade/utils 20251103.1255.55 → 20251202.1821.43

package/dist/src/files/files.js

@@ -1,152 +0,0 @@
-/* * */
-import { mimeTypes } from '@tmlmobilidade/lib';
-import JSZip from 'jszip';
-import papaparse from 'papaparse';
-import { fetchZipFromUrl, isBrowser, normalizeFileContent, readZipFromFile } from './utils.js';
-/* * */
-export class Files {
-    //
-    /**
-     * Blob to JS File
-     */
-    static blobToFile(blob, fileName) {
-        return new File([blob], fileName);
-    }
-    static getFileExtension(fileName) {
-        const extension = fileName.split('.').pop();
-        if (!extension) {
-            throw new Error('File has no extension');
-        }
-        const mimeType = mimeTypes[extension];
-        if (!mimeType) {
-            throw new Error(`Unsupported file extension: ${extension}`);
-        }
-        return extension;
-    }
-    /**
-     * Gets the file extension from a MIME type.
-     * @param mimeType The MIME type to get the file extension for.
-     * @returns The file extension, or an empty string if not found.
-     */
-    static getFileExtensionFromMimeType(mimeType) {
-        if (!mimeType)
-            return '';
-        const extension = Object.keys(mimeTypes).find(key => mimeTypes[key] === mimeType);
-        if (!extension)
-            return '';
-        return extension;
-    }
-    static getMimeTypeFromFileExtension(fileName) {
-        const extension = Files.getFileExtension(fileName);
-        return mimeTypes[extension];
-    }
-    /**
-     * Parses a CSV string into an array of objects using PapaParse.
-     * @param csvString - The CSV string to parse
-     * @param options - Parse configuration options
-     * @param options.header - Whether to interpret first row as field names. Defaults to true.
-     * @param options.skipEmptyLines - Whether to skip empty lines in the CSV. Defaults to true.
-     * @param options.rest - Additional PapaParse configuration options
-     * @returns Promise resolving to array of parsed objects
-     * @throws Error if parsing fails with details of parsing errors
-     */
-    static async parseCsv(csvString, { header = true, skipEmptyLines = true, ...options }) {
-        const parse = papaparse.parse(csvString, { header, skipEmptyLines, ...options });
-        if (parse.errors.length > 0) {
-            throw new Error(`Failed to parse CSV: ${parse.errors.map(error => `${error.message} [${error.code}]`).join(', ')}`);
-        }
-        return parse.data;
-    }
-    /**
-     * Reads and extracts a single file from a ZIP archive.
-     * @param zipFilePath - The ZIP file to read from, can be a File object (browser), string path (Node.js), or URL
-     * @param fileName - The name of the file to extract from the ZIP
-     * @param encoding - The encoding to use when reading the file. See JSZip documentation for supported formats.
-     * @returns A Promise resolving to the file contents in the specified encoding
-     * @throws Error if the file is not found in the ZIP
-     */
-    static async readFileFromZip(zipFilePath, fileName, encoding) {
-        const zip = await Files.unzip(zipFilePath);
-        const file = zip.file(fileName);
-        if (!file) {
-            throw new Error(`File ${fileName} not found in ZIP`);
-        }
-        return await file.async(encoding);
-    }
-    /**
-     * Unzips a ZIP file from a File (browser), string path (Node.js), or URL.
-     * @param zipFilePath The path, URL, or File object representing the ZIP file to extract.
-     * @returns A Promise that resolves to a JSZip instance representing the unzipped contents.
-     */
-    static async unzip(zipFilePath) {
-        try {
-            let data = null;
-            if (isBrowser && zipFilePath instanceof File) {
-                data = await zipFilePath.arrayBuffer();
-            }
-            if (typeof zipFilePath === 'string' || zipFilePath instanceof URL) {
-                const pathOrUrl = zipFilePath.toString();
-                if (isBrowser || pathOrUrl.startsWith('http')) {
-                    data = await fetchZipFromUrl(pathOrUrl);
-                }
-                else {
-                    data = await readZipFromFile(pathOrUrl);
-                }
-            }
-            if (!data || data.byteLength === 0) {
-                throw new Error('ZIP file is empty');
-            }
-            const zip = await JSZip.loadAsync(data);
-            if (Object.keys(zip.files).length === 0) {
-                throw new Error('ZIP file contains no files');
-            }
-            return zip;
-        }
-        catch (error) {
-            if (error instanceof Error && error.message.includes('Central Directory')) {
-                throw new Error('Invalid or corrupted ZIP file');
-            }
-            throw error;
-        }
-    }
-    /**
-     * Updates a CSV string with an object.
-     * @param csvString - The CSV string to update
-     * @param column - The column name to update
-     * @param row - The row index to update
-     * @param value - The value to update the column with
-     * @returns A Promise resolving to the updated CSV string
-     */
-    static async updateCsvField(params) {
-        let csv = params[0].csvString;
-        for (const param of params) {
-            const { column, rowIndex, value } = param;
-            const data = await this.parseCsv(csv, { header: true });
-            const updatedData = data.map((row, index) => (index === rowIndex ? { ...row, [column]: value } : row));
-            csv = papaparse.unparse(updatedData, { header: true });
-        }
-        return csv;
-    }
-    /**
-     * Zips multiple files into a ZIP archive.
-     * @param files An object where keys are filenames and values are either File (browser) or Buffer/Uint8Array (Node.js).
-     * @returns A Promise resolving to a Uint8Array representing the ZIP file content.
-     */
-    static async zip(files) {
-        try {
-            const zip = new JSZip();
-            await Promise.all(Object.entries(files).map(async ([filename, content]) => {
-                const fileData = await normalizeFileContent(content);
-                zip.file(filename, fileData);
-            }));
-            const zipContent = await zip.generateAsync({ type: 'uint8array' });
-            if (!zipContent || zipContent.length === 0) {
-                throw new Error('Failed to generate ZIP: output is empty');
-            }
-            return zipContent;
-        }
-        catch (error) {
-            throw new Error(`Failed to create ZIP archive: ${error.message}`);
-        }
-    }
-}

package/dist/src/files/utils.d.ts

@@ -1,20 +0,0 @@
-export declare const isBrowser: boolean;
-/**
- * Fetches a ZIP file from a URL and returns it as an ArrayBuffer.
- * @param url The URL of the ZIP file to fetch
- * @returns A Promise that resolves to an ArrayBuffer containing the ZIP file data
- * @throws {Error} If the HTTP request fails or returns a non-200 status code
- */
-export declare function fetchZipFromUrl(url: string): Promise<ArrayBuffer>;
-/**
- * Reads a ZIP file from the local filesystem and returns it as an ArrayBuffer.
- * @param path The file system path to the ZIP file
- * @returns A Promise that resolves to an ArrayBuffer containing the ZIP file data
- * @throws {Error} If there is an error reading the file
- */
-export declare function readZipFromFile(path: string): Promise<ArrayBuffer>;
-/**
- * Converts the input file data into an ArrayBuffer or Uint8Array suitable for JSZip.
- * @param content A File (browser) or Buffer/Uint8Array (Node.js)
- */
-export declare function normalizeFileContent(content: Buffer | File | Uint8Array): Promise<ArrayBuffer | Uint8Array>;

package/dist/src/files/utils.js

@@ -1,47 +0,0 @@
-export const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
-/**
- * Fetches a ZIP file from a URL and returns it as an ArrayBuffer.
- * @param url The URL of the ZIP file to fetch
- * @returns A Promise that resolves to an ArrayBuffer containing the ZIP file data
- * @throws {Error} If the HTTP request fails or returns a non-200 status code
- */
-export async function fetchZipFromUrl(url) {
-    const response = await fetch(url);
-    if (!response.ok) {
-        throw new Error(`Failed to fetch ZIP file: HTTP ${response.status} - ${response.statusText}`);
-    }
-    return await response.arrayBuffer();
-}
-/**
- * Reads a ZIP file from the local filesystem and returns it as an ArrayBuffer.
- * @param path The file system path to the ZIP file
- * @returns A Promise that resolves to an ArrayBuffer containing the ZIP file data
- * @throws {Error} If there is an error reading the file
- */
-export async function readZipFromFile(path) {
-    if (isBrowser) {
-        throw new Error('readZipFromFile is not supported in the browser');
-    }
-    // Only require fs/promises in Node.js
-    const { readFile } = await (Function('return import("fs/promises")')());
-    try {
-        const buffer = await readFile(path);
-        return buffer.buffer;
-    }
-    catch (err) {
-        throw new Error(`Failed to read ZIP file: ${err.message}`);
-    }
-}
-/**
- * Converts the input file data into an ArrayBuffer or Uint8Array suitable for JSZip.
- * @param content A File (browser) or Buffer/Uint8Array (Node.js)
- */
-export async function normalizeFileContent(content) {
-    if (isBrowser && content instanceof File) {
-        return await content.arrayBuffer();
-    }
-    if (content instanceof Buffer || content instanceof Uint8Array) {
-        return content;
-    }
-    throw new TypeError('Unsupported file content type for zipping');
-}

package/dist/src/geo/chunk-line.d.ts

@@ -1,10 +0,0 @@
-import { type LineString } from 'geojson';
-/**
- * This function takes a GeoJSON LineString and splits it into equal chunks of a given precision
- * using a custom implementation. This is useful to ensure greater precision when calculating the nearest
- * point on a path, as some paths may have very long "straight" segments with only two points.
- * @param line The LineString to be split into chunks.
- * @param segmentLength The length of each segment in meters.
- * @returns A GeoJSON LineString with the split chunks.
- */
-export declare function chunkLineByDistance(line: LineString, segmentLength: number): LineString;

package/dist/src/geo/chunk-line.js

@@ -1,75 +0,0 @@
-/* * */
-import { toLineStringFromPositions } from './conversions.js';
-import { getDistanceBetweenPositions, interpolatePositions } from './measurements.js';
-/**
- * This function takes a GeoJSON LineString and splits it into equal chunks of a given precision
- * using a custom implementation. This is useful to ensure greater precision when calculating the nearest
- * point on a path, as some paths may have very long "straight" segments with only two points.
- * @param line The LineString to be split into chunks.
- * @param segmentLength The length of each segment in meters.
- * @returns A GeoJSON LineString with the split chunks.
- */
-export function chunkLineByDistance(line, segmentLength) {
-    //
-    //
-    // Exit early if the line is empty
-    if (line.coordinates.length < 2)
-        return line;
-    //
-    // Setup variables to hold the coordinates of the chunked line
-    const chunkedLineCoordinates = [];
-    //
-    // Add the first point to the chunked line
-    chunkedLineCoordinates.push(line.coordinates[0]);
-    //
-    // Loop through the coordinates of the line
-    for (let i = 0; i < line.coordinates.length - 1; i++) {
-        // Extract the coordinates of the current and the next point
-        const [lngA, latA] = line.coordinates[i];
-        const [lngB, latB] = line.coordinates[i + 1];
-        // Calculate the length of the current segment
-        const currentSegmentLength = getDistanceBetweenPositions(line.coordinates[i], line.coordinates[i + 1]);
-        // If the current segment length is greater than the desired segment length
-        if (currentSegmentLength > segmentLength) {
-            // Calculate the number of segments needed to fill the current segment
-            const segmentsNeeded = Math.floor(currentSegmentLength / segmentLength);
-            // Calculate the length of each chunked segment
-            const chunkedSegmentLength = currentSegmentLength / segmentsNeeded;
-            // Calculate the remaining distance to be filled
-            let remainingDist = segmentLength;
-            // Loop through the segments needed
-            for (let j = 0; j < segmentsNeeded; j++) {
-                // Calculate the ratio of the segment
-                const ratio = remainingDist / chunkedSegmentLength;
-                // Interpolate the coordinates of the segment
-                const interpolated = interpolatePositions([lngA, latA], [lngB, latB], ratio);
-                // Add the interpolated coordinates to the chunked line
-                chunkedLineCoordinates.push(interpolated);
-                // Update the remaining distance to be filled
-                remainingDist -= chunkedSegmentLength;
-            }
-            // Add the last point of the segment to the chunked line
-            const lastPoint = line.coordinates[i + 1];
-            if (chunkedLineCoordinates[chunkedLineCoordinates.length - 1][0] !== lastPoint[0] || chunkedLineCoordinates[chunkedLineCoordinates.length - 1][1] !== lastPoint[1]) {
-                chunkedLineCoordinates.push(lastPoint);
-            }
-        }
-        else {
-            // If the current segment length is less than or equal to the desired segment length
-            // Add the current point to the chunked line
-            if (chunkedLineCoordinates[chunkedLineCoordinates.length - 1][0] !== line.coordinates[i][0] || chunkedLineCoordinates[chunkedLineCoordinates.length - 1][1] !== line.coordinates[i][1]) {
-                chunkedLineCoordinates.push(line.coordinates[i]);
-            }
-        }
-    }
-    //
-    // Add the last point of the line to the chunked line
-    const lastPoint = line.coordinates[line.coordinates.length - 1];
-    if (chunkedLineCoordinates[chunkedLineCoordinates.length - 1][0] !== lastPoint[0] || chunkedLineCoordinates[chunkedLineCoordinates.length - 1][1] !== lastPoint[1]) {
-        chunkedLineCoordinates.push(lastPoint);
-    }
-    //
-    // Return the chunked line as a GeoJSON LineString
-    return toLineStringFromPositions(chunkedLineCoordinates);
-    //
-}

package/dist/src/geo/constants.d.ts

@@ -1,8 +0,0 @@
-/**
- * Earth's radius in meters.
- */
-export declare const EARTH_RADIUS = 6371000;
-/**
- * Approximate number of meters per degree of latitude.
- */
-export declare const METERS_PER_DEGREE = 111320;

package/dist/src/geo/constants.js

@@ -1,8 +0,0 @@
-/**
- * Earth's radius in meters.
- */
-export const EARTH_RADIUS = 6_371_000;
-/**
- * Approximate number of meters per degree of latitude.
- */
-export const METERS_PER_DEGREE = 111_320;

package/dist/src/geo/conversions.d.ts

@@ -1,36 +0,0 @@
-import { type HashedShape } from '@tmlmobilidade/types';
-import { type Feature, type GeoJsonProperties, type LineString, type Point, type Polygon, type Position } from 'geojson';
-/**
- * Converts a list of GTFS shape points into a GeoJSON LineString.
- * @param hashedShape The hashed shape containing GTFS shape points.
- * @returns GeoJSON LineString feature
- */
-export declare function toLineStringFromHashedShape(hashedShape: HashedShape): LineString;
-/**
- * Creates a new LineString from the given set of coordinates.
- * @param positions An array of coordinate positions for the LineString. Defaults to an empty array.
- * @returns A GeoJSON LineString with the specified coordinates.
- */
-export declare function toLineStringFromPositions(positions?: Position[]): LineString;
-/**
- * Creates a new Point from the given coordinates.
- * @param position A coordinate position for the Point. Defaults to an empty array.
- * @returns A GeoJSON Point with the specified coordinates.
- */
-export declare function toPointFromPositions(position?: Position): Point;
-/**
- * Creates a new Feature from the given object and properties.
- * @param object The object to convert to a Feature. Can be a LineString, Point, or Polygon.
- * @param properties Optional properties to attach to the Feature. Defaults to an empty object.
- * @returns A GeoJSON Feature with the specified object and properties.
- */
-export declare function toFeatureFromObject<T extends LineString | Point | Polygon>(object: T, properties?: GeoJsonProperties): Feature<T>;
-/**
- * Converts a value in kilometers or meters to meters based on a ballpark value.
- * If the ballpark value is greater than 800 meters, it assumes the value is in meters.
- * Otherwise, it assumes the value is in kilometers and converts it to meters.
- * @param value The value to be converted, which can be a number or a string that can be converted to a number.
- * @param ballpark The ballpark value to determine the unit of the value, which can also be a number or a string that can be converted to a number.
- * @returns The converted value in meters.
- */
-export declare function toMetersFromKilometersOrMeters(value: number | string, ballpark: number | string): number;

package/dist/src/geo/conversions.js

@@ -1,79 +0,0 @@
-/* * */
-/**
- * Converts a list of GTFS shape points into a GeoJSON LineString.
- * @param hashedShape The hashed shape containing GTFS shape points.
- * @returns GeoJSON LineString feature
- */
-export function toLineStringFromHashedShape(hashedShape) {
-    // Exit if no points are provided
-    if (!hashedShape.points?.length)
-        return toLineStringFromPositions([]);
-    // Sort points by shape_pt_sequence
-    const sortedPoints = [...hashedShape.points].sort((a, b) => a.shape_pt_sequence - b.shape_pt_sequence);
-    // Create a LineString feature
-    const coordinates = sortedPoints.map(p => [Number(p.shape_pt_lon), Number(p.shape_pt_lat)]);
-    // Return the LineString feature
-    return toLineStringFromPositions(coordinates);
-}
-/**
- * Creates a new LineString from the given set of coordinates.
- * @param positions An array of coordinate positions for the LineString. Defaults to an empty array.
- * @returns A GeoJSON LineString with the specified coordinates.
- */
-export function toLineStringFromPositions(positions = []) {
-    return {
-        coordinates: positions,
-        type: 'LineString',
-    };
-}
-/**
- * Creates a new Point from the given coordinates.
- * @param position A coordinate position for the Point. Defaults to an empty array.
- * @returns A GeoJSON Point with the specified coordinates.
- */
-export function toPointFromPositions(position = []) {
-    return {
-        coordinates: position,
-        type: 'Point',
-    };
-}
-/**
- * Creates a new Feature from the given object and properties.
- * @param object The object to convert to a Feature. Can be a LineString, Point, or Polygon.
- * @param properties Optional properties to attach to the Feature. Defaults to an empty object.
- * @returns A GeoJSON Feature with the specified object and properties.
- */
-export function toFeatureFromObject(object, properties) {
-    return {
-        geometry: object,
-        properties: properties || {},
-        type: 'Feature',
-    };
-}
-/**
- * Converts a value in kilometers or meters to meters based on a ballpark value.
- * If the ballpark value is greater than 800 meters, it assumes the value is in meters.
- * Otherwise, it assumes the value is in kilometers and converts it to meters.
- * @param value The value to be converted, which can be a number or a string that can be converted to a number.
- * @param ballpark The ballpark value to determine the unit of the value, which can also be a number or a string that can be converted to a number.
- * @returns The converted value in meters.
- */
-export function toMetersFromKilometersOrMeters(value, ballpark) {
-    //
-    const BALLPARK_THRESHOLD = 800; // meters
-    const valueAsNumber = Number(value);
-    const ballparkAsNumber = Number(ballpark);
-    if (Number.isNaN(valueAsNumber))
-        throw new Error('Value must be a number or a string that can be converted to a number.');
-    if (Number.isNaN(ballparkAsNumber))
-        throw new Error('Ballpark must be a number or a string that can be converted to a number.');
-    // If the ballpark is bigger than 800, then the value is in meters
-    // Otherwise, the value is in kilometers. This is because it is unlikely
-    // that a trip will be smaller than 800 meters, and longer than 800 kilometers.
-    if (ballparkAsNumber > BALLPARK_THRESHOLD) {
-        return valueAsNumber;
-    }
-    return valueAsNumber * 1000;
-    //
-}
-;

package/dist/src/geo/coordinates.d.ts

@@ -1,37 +0,0 @@
-/**
- * Checks if the given latitude value is valid given Portugal limits.
- * @param value The latitude value to check.
- * @returns The clamped latitude value if valid, false otherwise.
- */
-export declare function isValidLatitude(value: number): false | number;
-/**
- * Checks if the given longitude value is valid given Portugal limits.
- * @param value The longitude value to check.
- * @returns The clamped longitude value if valid, false otherwise.
- */
-export declare function isValidLongitude(value: number): false | number;
-/**
- * Checks if the given latitude and longitude values form a valid coordinate pair.
- * @param lat The latitude value to check.
- * @param lng The longitude value to check.
- * @returns True if the coordinate pair is valid, false otherwise.
- */
-export declare function isValidCoordinatePair(lat: number, lng: number): boolean;
-/**
- * Clamps a coordinate value to 6 decimal places.
- * @param value The coordinate value to clamp.
- * @returns The clamped coordinate value.
- */
-export declare function clampCoordinate(value: number): number;
-/**
- * Parses a coordinate pair string in the following formats:
- * - `lat, lng`
- * - `lat lng` (with a space or a tab)
- * @param input The coordinate pair string to parse.
- * @param clamp Whether to clamp the latitude and longitude values to 6 decimal places.
- * @returns The parsed coordinates as an object, or null if the input is invalid.
- */
-export declare const parseCoordinatePairString: (input: string, clamp?: boolean) => null | {
-    lat: number;
-    lng: number;
-};

package/dist/src/geo/coordinates.js

@@ -1,64 +0,0 @@
-/* * */
-/**
- * Checks if the given latitude value is valid given Portugal limits.
- * @param value The latitude value to check.
- * @returns The clamped latitude value if valid, false otherwise.
- */
-export function isValidLatitude(value) {
-    const hasValue = value !== undefined && value !== null;
-    const isWithinPortugal = value >= 36.9 && value <= 42.0;
-    if (!hasValue || !isWithinPortugal)
-        return false;
-    return clampCoordinate(value);
-}
-/**
- * Checks if the given longitude value is valid given Portugal limits.
- * @param value The longitude value to check.
- * @returns The clamped longitude value if valid, false otherwise.
- */
-export function isValidLongitude(value) {
-    const hasValue = value !== undefined && value !== null;
-    const isWithinPortugal = value >= -9.5 && value <= -6.0;
-    if (!hasValue || !isWithinPortugal)
-        return false;
-    return clampCoordinate(value);
-}
-/**
- * Checks if the given latitude and longitude values form a valid coordinate pair.
- * @param lat The latitude value to check.
- * @param lng The longitude value to check.
- * @returns True if the coordinate pair is valid, false otherwise.
- */
-export function isValidCoordinatePair(lat, lng) {
-    const isValidLat = isValidLatitude(lat);
-    const isValidLng = isValidLongitude(lng);
-    return !!isValidLat && !!isValidLng;
-}
-/**
- * Clamps a coordinate value to 6 decimal places.
- * @param value The coordinate value to clamp.
- * @returns The clamped coordinate value.
- */
-export function clampCoordinate(value) {
-    return parseFloat(value.toFixed(6));
-}
-/**
- * Parses a coordinate pair string in the following formats:
- * - `lat, lng`
- * - `lat lng` (with a space or a tab)
- * @param input The coordinate pair string to parse.
- * @param clamp Whether to clamp the latitude and longitude values to 6 decimal places.
- * @returns The parsed coordinates as an object, or null if the input is invalid.
- */
-export const parseCoordinatePairString = (input, clamp = true) => {
-    const regex = /^\s*([+-]?\d+(?:\.\d+)?)\s*(?:,|\s)\s*([+-]?\d+(?:\.\d+)?)\s*$/;
-    const match = input.match(regex);
-    if (!match)
-        return null;
-    const lat = parseFloat(match[1]);
-    const lng = parseFloat(match[2]);
-    if (clamp)
-        return isValidCoordinatePair(lat, lng) ? { lat: clampCoordinate(lat), lng: clampCoordinate(lng) } : null;
-    else
-        return isValidCoordinatePair(lat, lng) ? { lat, lng } : null;
-};

package/dist/src/geo/cut-line-at-length.d.ts

@@ -1,10 +0,0 @@
-import { type LineString } from 'geojson';
-/**
- * Cuts a LineString at a specified length.
- * If the line is shorter than the specified length, it returns the entire line.
- * @param line The LineString to cut.
- * @param length The length at which to cut the line, in meters, from the start of the line.
- * @param direction The direction in which to cut the line. If 'forward', it cuts from the start of the line.
- * @returns A new LineString that is cut at the specified length.
- */
-export declare function cutLineStringAtLength(line: LineString, length: number, direction?: 'forward' | 'reversed'): LineString;

package/dist/src/geo/cut-line-at-length.js

@@ -1,68 +0,0 @@
-/* * */
-import { toLineStringFromPositions } from './conversions.js';
-import { getDistanceBetweenPositions, interpolatePositions } from './measurements.js';
-/**
- * Cuts a LineString at a specified length.
- * If the line is shorter than the specified length, it returns the entire line.
- * @param line The LineString to cut.
- * @param length The length at which to cut the line, in meters, from the start of the line.
- * @param direction The direction in which to cut the line. If 'forward', it cuts from the start of the line.
- * @returns A new LineString that is cut at the specified length.
- */
-export function cutLineStringAtLength(line, length, direction = 'forward') {
-    //
-    //
-    // Return the line if it is empty
-    if (line.coordinates.length < 2) {
-        return line;
-    }
-    //
-    // Return an empty line if the length is equal to 0
-    if (length <= 0) {
-        return toLineStringFromPositions([]);
-    }
-    //
-    // Reverse the line if the direction is 'reversed'
-    if (direction === 'reversed') {
-        line.coordinates = line.coordinates.slice().reverse();
-    }
-    //
-    // Hold the cumulative distance between points
-    // and the coordinates of the new line
-    let cumulativeLength = 0;
-    const newLinePositions = [];
-    //
-    // Loop through the coordinates of the line
-    for (let i = 0; i < line.coordinates.length - 1; i++) {
-        // Get the coordinates of the current and the next point
-        const coordA = line.coordinates[i];
-        const coordB = line.coordinates[i + 1];
-        // Calculate the distance between the two points
-        const segmentLength = getDistanceBetweenPositions(coordA, coordB);
-        // If the current segment length plus the cumulative length
-        // extends the desired length of the resulting string
-        // then the line should be cut at the interpolation point
-        if (cumulativeLength + segmentLength >= length) {
-            const remainingLength = length - cumulativeLength;
-            const relativePositionOnSegment = remainingLength / segmentLength;
-            const interpolated = interpolatePositions(coordA, coordB, relativePositionOnSegment);
-            newLinePositions.push(coordA, interpolated);
-            return toLineStringFromPositions(newLinePositions);
-        }
-        // Add the length of the current segment to the
-        // cumulative length of the line up until this point
-        cumulativeLength += segmentLength;
-        // If the cumulative length is already greater than the desired length
-        // then the line should be cut at this point. Break the loop now.
-        if (cumulativeLength > length)
-            break;
-        // If the cumulative length is not yet up to the desired length
-        // then the current point should be added to the new line
-        newLinePositions.push(coordA);
-    }
-    //
-    // If the entire line is shorter than the target length
-    newLinePositions.push(line.coordinates[line.coordinates.length - 1]);
-    return toLineStringFromPositions(newLinePositions);
-    //
-}

package/dist/src/geo/geojson-collections.d.ts

@@ -1,11 +0,0 @@
-import { type Feature, type FeatureCollection, type Geometry } from 'geojson';
-/**
- * Creates a base GeoJSON feature collection for the given feature type.
- * @returns A base GeoJSON feature collection with an empty features array.
- */
-export declare function getBaseGeoJsonFeature<T extends Geometry, K>(type: T['type'], properties?: K): Feature<T, K>;
-/**
- * Creates a base GeoJSON feature collection for the given feature type.
- * @returns A base GeoJSON feature collection with an empty features array.
- */
-export declare function getBaseGeoJsonFeatureCollection<T extends Geometry, K>(): FeatureCollection<T, K>;

package/dist/src/geo/geojson-collections.js

@@ -1,29 +0,0 @@
-/* * */
-/**
- * Creates a base GeoJSON feature collection for the given feature type.
- * @returns A base GeoJSON feature collection with an empty features array.
- */
-export function getBaseGeoJsonFeature(type, properties) {
-    const emptyGeometries = {
-        GeometryCollection: { geometries: [], type: 'GeometryCollection' },
-        LineString: { coordinates: [], type: 'LineString' },
-        MultiLineString: { coordinates: [], type: 'MultiLineString' },
-        MultiPoint: { coordinates: [], type: 'MultiPoint' },
-        MultiPolygon: { coordinates: [], type: 'MultiPolygon' },
-        Point: { coordinates: [0, 0], type: 'Point' },
-        Polygon: { coordinates: [], type: 'Polygon' },
-    };
-    return {
-        geometry: emptyGeometries[type],
-        properties: (properties ?? {}),
-        type: 'Feature',
-    };
-}
-/**
- * Creates a base GeoJSON feature collection for the given feature type.
- * @returns A base GeoJSON feature collection with an empty features array.
- */
-export function getBaseGeoJsonFeatureCollection() {
-    return Object.assign({ features: [], type: 'FeatureCollection' });
-}
-;