Typescript types for the GeoJSON RFC7946 specification

GeoJSON.ts

/**
 * Typescript types for the GeoJSON RFC7946 specification. This is not fully RFC-compliant due to lack of support for
 * ranged number data types.
 *
 * See https://tools.ietf.org/html/rfc7946
 */
export declare namespace GeoJSON {
    /**
     * Inside this document, the term "geometry type" refers to seven case-sensitive strings: "Point", "MultiPoint",
     * "LineString", "MultiLineString", "Polygon", "MultiPolygon", and "GeometryCollection".
     */
    export type Geometry = Point | MultiPoint | LineString | MultiLineString | Polygon | MultiPolygon
        | GeometryCollection;
    export type GeometryType = Geometry["type"];

    /**
     * ...the term "GeoJSON types" refers to nine case-sensitive strings: "Feature", "FeatureCollection", and the
     * geometry types listed above.
     */
    export type GeoJson = Geometry | Feature | FeatureCollection;
    export type GeoJsonType = GeoJson["type"];

    // types

    /**
     * A position is an array of numbers. There MUST be two or more elements. The first two elements are longitude and
     * latitude, or easting and northing, precisely in that order and using decimal numbers. Altitude or elevation MAY
     * be included as an optional third element.
     *
     * Implementations SHOULD NOT extend positions beyond three elements because the semantics of extra elements are
     * unspecified and ambiguous.
     */
    export type Position = [longitude: number, latitude: number, elevation?: number]

    export type Record = { [key in string | number]: unknown };

    /**
     * Properties inherit to all GeoJSON types
     */
    export interface GeometryBase extends Record {
        /**
         * A GeoJSON object MAY have a member named "bbox" to include information on the coordinate range for its
         * Geometries, Features, or FeatureCollections. The value of the bbox member MUST be an array of length 2*n
         * where n is the number of dimensions represented in the contained geometries, with all axes of the most
         * southwesterly point followed by all axes of the more northeasterly point. The axes order of a bbox follows
         * the axes order of geometries.
         */
        bbox?: number[];

        /**
         * A GeoJSON object MAY have other members.
         *
         * Members not described in this specification ("foreign members") MAY be used in a GeoJSON document. Note that
         * support for foreign members can vary across implementations, and no normative processing model for foreign
         * members is defined.
         */
    }

    // geometry types

    export interface Point extends GeometryBase {
        type: "Point";
        /**
         * For type "Point", the "coordinates" member is a single position.
         */
        coordinates: Position;
    }

    export interface MultiPoint extends GeometryBase {
        type: "MultiPoint";
        /**
         * For type "MultiPoint", the "coordinates" member is an array of positions.
         */
        coordinates: Position[];
    }

    export interface LineString extends GeometryBase {
        type: "LineString";
        /**
         * For type "LineString", the "coordinates" member is an array of two or more positions.
         */
        coordinates: { 0: Position, 1: Position } & Position[]
    }

    export interface MultiLineString extends GeometryBase {
        type: "MultiLineString";
        /**
         *  For type "MultiLineString", the "coordinates" member is an array of LineString coordinate arrays.
         */
        coordinates: LineString["coordinates"][];
    }

    /**
     * To specify a constraint specific to Polygons, it is useful to introduce the concept of a linear ring:
     *  - A linear ring is a closed LineString with four or more positions.
     *  - The first and last positions are equivalent, and they MUST contain identical values; their representation
     *    SHOULD also be identical.
     *  - A linear ring is the boundary of a surface or the boundary of a hole in a surface.
     *  - A linear ring MUST follow the right-hand rule with respect to the area it bounds, i.e., exterior rings are
     *  counterclockwise, and holes are clockwise.
     */
    export type LinearRing = { 0: Position, 1: Position, 2: Position, 3: Position } & Position[];

    export interface Polygon extends GeometryBase {
        type: "Polygon";
        /**
         * For type "Polygon", the "coordinates" member MUST be an array of linear ring coordinate arrays.
         *
         * For Polygons with more than one of these rings, the first MUST be the exterior ring, and any others MUST be
         * interior rings. The exterior ring bounds the surface, and the interior rings (if present) bound holes within
         * the surface.
         */
        coordinates: LinearRing[];
    }

    export interface MultiPolygon extends GeometryBase {
        type: "MultiPolygon";
        /**
         * For type "MultiPolygon", the "coordinates" member is an array of Polygon coordinate arrays.
         */
        coordinates: Polygon["coordinates"][];
    }

    export interface GeometryCollection {
        /**
         * A GeoJSON object with type "GeometryCollection" is a Geometry object.
         */
        type: "GeometryCollection";
        /**
         *  A GeometryCollection has a member with the name "geometries". The value of "geometries" is an array. Each
         *  element of this array is a GeoJSON Geometry object. It is possible for this array to be empty.
         */
        geometries: Geometry[];
    }

    // GeoJSON types

    export interface Feature {
        /**
         * A Feature object has a "type" member with the value "Feature".
         */
        type: "Feature";
        /**
         * If a Feature has a commonly used identifier, that identifier SHOULD be included as a member of the Feature object
         * with the name "id", and the value of this member is either a JSON string or number.
         */
        id?: string | number;
        /**
         * A Feature object has a member with the name "geometry". The value of the geometry member SHALL be either a
         * Geometry object as defined above or, in the case that the Feature is unlocated, a JSON null value.
         */
        geometry: Geometry | null;
        /**
         * A Feature object has a member with the name "properties". The value of the properties member is an object
         * (any JSON object or a JSON null value).
         */
        properties: Record | null;
    }

    export interface FeatureCollection {
        /**
         * A GeoJSON object with the type "FeatureCollection" is a FeatureCollection object.
         */
        type: "FeatureCollection";
        /**
         * A FeatureCollection object has a member with the name "features". The value of "features" is a JSON array. Each
         * element of the array is a Feature object as defined above. It is possible for this array to be empty.
         */
        features: Feature[];
    }
}

Thanks a lot for this gist. I think the next step would be writing this as a https://github.com/colinhacks/zod schema which would allow validation while still exposing the same types.

Hi! Thanks for the typings! Correct me if I'm wrong but, shouldn't the order of latitude and longitude in Position to be other way around? first longitude and then latitude?

Looks like you are correct - https://datatracker.ietf.org/doc/html/rfc7946#section-3.1.1. I updated the definition.

A position is an array of numbers. There MUST be two or more elements. The first two elements are longitude and latitude, or easting and northing, precisely in that order and using decimal numbers. Altitude or elevation MAY be included as an optional third element.

@peterhirn you could try my very rough package https://www.npmjs.com/package/@jsse/geozod

Премного благодарен