@frictionless-ts/table 1.0.1

package/build/field/types/geojson.spec.js

@@ -0,0 +1,522 @@
+import * as pl from "nodejs-polars";
+import { describe, expect, it } from "vitest";
+import { inspectTable } from "../../table/index.js";
+describe("validateGeojsonField", () => {
+    it("should not errors for valid GeoJSON Point", async () => {
+        const table = pl
+            .DataFrame({
+            location: [
+                '{"type":"Point","coordinates":[0,0]}',
+                '{"type":"Point","coordinates":[12.5,41.9]}',
+                '{"type":"Point","coordinates":[-73.9,40.7]}',
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "location",
+                    type: "geojson",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toHaveLength(0);
+    });
+    it("should not errors for valid GeoJSON geometries", async () => {
+        const table = pl
+            .DataFrame({
+            geometry: [
+                '{"type":"LineString","coordinates":[[0,0],[1,1]]}',
+                '{"type":"Polygon","coordinates":[[[0,0],[1,0],[1,1],[0,1],[0,0]]]}',
+                '{"type":"MultiPoint","coordinates":[[0,0],[1,1]]}',
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "geometry",
+                    type: "geojson",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toHaveLength(0);
+    });
+    it("should not errors for valid GeoJSON Feature", async () => {
+        const table = pl
+            .DataFrame({
+            feature: [
+                '{"type":"Feature","geometry":{"type":"Point","coordinates":[0,0]},"properties":{"name":"Test"}}',
+                '{"type":"Feature","geometry":{"type":"LineString","coordinates":[[0,0],[1,1]]},"properties":{"id":1}}',
+                '{"type":"Feature","geometry":null,"properties":{}}',
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "feature",
+                    type: "geojson",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toHaveLength(0);
+    });
+    it("should not errors for valid GeoJSON FeatureCollection", async () => {
+        const table = pl
+            .DataFrame({
+            collection: [
+                '{"type":"FeatureCollection","features":[{"type":"Feature","geometry":{"type":"Point","coordinates":[0,0]},"properties":{}}]}',
+                '{"type":"FeatureCollection","features":[]}',
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "collection",
+                    type: "geojson",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toHaveLength(0);
+    });
+    it("should not errors for null values", async () => {
+        const table = pl
+            .DataFrame({
+            location: [
+                '{"type":"Point","coordinates":[0,0]}',
+                null,
+                '{"type":"Feature","geometry":null,"properties":{}}',
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "location",
+                    type: "geojson",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toHaveLength(0);
+    });
+    it("should errors for JSON arrays", async () => {
+        const table = pl
+            .DataFrame({
+            data: [
+                '{"type":"Point","coordinates":[0,0]}',
+                "[[0,0],[1,1]]",
+                '{"type":"Feature","geometry":null,"properties":{}}',
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "data",
+                    type: "geojson",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/type",
+                fieldName: "data",
+                fieldType: "geojson",
+                rowNumber: 2,
+                cell: "[[0,0],[1,1]]",
+            },
+        ]);
+    });
+    it("should errors for invalid JSON", async () => {
+        const table = pl
+            .DataFrame({
+            data: [
+                '{"type":"Point","coordinates":[0,0]}',
+                "invalid json",
+                "{broken}",
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "data",
+                    type: "geojson",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors.filter(e => e.type === "cell/type")).toHaveLength(2);
+        expect(errors).toContainEqual({
+            type: "cell/type",
+            fieldName: "data",
+            fieldType: "geojson",
+            rowNumber: 2,
+            cell: "invalid json",
+        });
+        expect(errors).toContainEqual({
+            type: "cell/type",
+            fieldName: "data",
+            fieldType: "geojson",
+            rowNumber: 3,
+            cell: "{broken}",
+        });
+    });
+    it("should errors for empty strings", async () => {
+        const table = pl
+            .DataFrame({
+            data: [
+                '{"type":"Point","coordinates":[0,0]}',
+                "",
+                '{"type":"Feature","geometry":null,"properties":{}}',
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "data",
+                    type: "geojson",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/type",
+                fieldName: "data",
+                fieldType: "geojson",
+                rowNumber: 2,
+                cell: "",
+            },
+        ]);
+    });
+    it("should errors for JSON primitives", async () => {
+        const table = pl
+            .DataFrame({
+            data: ['"string"', "123", "true", "false", "null"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "data",
+                    type: "geojson",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/type",
+                fieldName: "data",
+                fieldType: "geojson",
+                rowNumber: 1,
+                cell: '"string"',
+            },
+            {
+                type: "cell/type",
+                fieldName: "data",
+                fieldType: "geojson",
+                rowNumber: 2,
+                cell: "123",
+            },
+            {
+                type: "cell/type",
+                fieldName: "data",
+                fieldType: "geojson",
+                rowNumber: 3,
+                cell: "true",
+            },
+            {
+                type: "cell/type",
+                fieldName: "data",
+                fieldType: "geojson",
+                rowNumber: 4,
+                cell: "false",
+            },
+            {
+                type: "cell/type",
+                fieldName: "data",
+                fieldType: "geojson",
+                rowNumber: 5,
+                cell: "null",
+            },
+        ]);
+    });
+    it("should errors for invalid GeoJSON Point coordinates", async () => {
+        const table = pl
+            .DataFrame({
+            location: [
+                '{"type":"Point","coordinates":[0,0]}',
+                '{"type":"Point","coordinates":[0]}',
+                '{"type":"Point","coordinates":[0,0,0,0]}',
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "location",
+                    type: "geojson",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toHaveLength(2);
+        expect(errors).toContainEqual({
+            type: "cell/type",
+            fieldName: "location",
+            fieldType: "geojson",
+            rowNumber: 2,
+            cell: '{"type":"Point","coordinates":[0]}',
+        });
+        expect(errors).toContainEqual({
+            type: "cell/type",
+            fieldName: "location",
+            fieldType: "geojson",
+            rowNumber: 3,
+            cell: '{"type":"Point","coordinates":[0,0,0,0]}',
+        });
+    });
+    it("should errors for invalid GeoJSON LineString", async () => {
+        const table = pl
+            .DataFrame({
+            line: [
+                '{"type":"LineString","coordinates":[[0,0],[1,1]]}',
+                '{"type":"LineString","coordinates":[[0,0]]}',
+                '{"type":"LineString","coordinates":[0,0]}',
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "line",
+                    type: "geojson",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toHaveLength(2);
+        expect(errors).toContainEqual({
+            type: "cell/type",
+            fieldName: "line",
+            fieldType: "geojson",
+            rowNumber: 2,
+            cell: '{"type":"LineString","coordinates":[[0,0]]}',
+        });
+        expect(errors).toContainEqual({
+            type: "cell/type",
+            fieldName: "line",
+            fieldType: "geojson",
+            rowNumber: 3,
+            cell: '{"type":"LineString","coordinates":[0,0]}',
+        });
+    });
+    it("should errors for incomplete GeoJSON Feature", async () => {
+        const table = pl
+            .DataFrame({
+            feature: [
+                '{"type":"Feature","geometry":{"type":"Point","coordinates":[0,0]},"properties":{}}',
+                '{"type":"Feature","geometry":{"type":"Point","coordinates":[0,0]}}',
+                '{"type":"Feature","properties":{}}',
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "feature",
+                    type: "geojson",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toHaveLength(2);
+        expect(errors).toContainEqual({
+            type: "cell/type",
+            fieldName: "feature",
+            fieldType: "geojson",
+            rowNumber: 2,
+            cell: '{"type":"Feature","geometry":{"type":"Point","coordinates":[0,0]}}',
+        });
+        expect(errors).toContainEqual({
+            type: "cell/type",
+            fieldName: "feature",
+            fieldType: "geojson",
+            rowNumber: 3,
+            cell: '{"type":"Feature","properties":{}}',
+        });
+    });
+    it("should errors for invalid GeoJSON FeatureCollection", async () => {
+        const table = pl
+            .DataFrame({
+            collection: [
+                '{"type":"FeatureCollection","features":[{"type":"Feature","geometry":{"type":"Point","coordinates":[0,0]},"properties":{}}]}',
+                '{"type":"FeatureCollection"}',
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "collection",
+                    type: "geojson",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/type",
+                fieldName: "collection",
+                fieldType: "geojson",
+                rowNumber: 2,
+                cell: '{"type":"FeatureCollection"}',
+            },
+        ]);
+    });
+    it("should not validate jsonSchema constraints for geojson fields", async () => {
+        const table = pl
+            .DataFrame({
+            location: [
+                '{"type":"Point","coordinates":[0,0]}',
+                '{"type":"Point","coordinates":[100,200]}',
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "location",
+                    type: "geojson",
+                    constraints: {
+                        jsonSchema: {
+                            type: "object",
+                            properties: {
+                                coordinates: {
+                                    type: "array",
+                                    items: { type: "number", minimum: -50, maximum: 50 },
+                                },
+                            },
+                        },
+                    },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toHaveLength(0);
+    });
+    it("should not errors for valid TopoJSON", async () => {
+        const table = pl
+            .DataFrame({
+            topology: [
+                '{"type":"Topology","objects":{"example":{"type":"GeometryCollection","geometries":[{"type":"Point","coordinates":[0,0]}]}},"arcs":[]}',
+                '{"type":"Topology","objects":{"collection":{"type":"GeometryCollection","geometries":[]}},"arcs":[]}',
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "topology",
+                    type: "geojson",
+                    format: "topojson",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toHaveLength(0);
+    });
+    it("should errors for invalid TopoJSON structure", async () => {
+        const table = pl
+            .DataFrame({
+            topology: [
+                '{"type":"Topology","objects":{"example":{"type":"GeometryCollection","geometries":[]}},"arcs":[]}',
+                '{"type":"Topology","objects":{}}',
+                '{"type":"Topology"}',
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "topology",
+                    type: "geojson",
+                    format: "topojson",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toHaveLength(2);
+        expect(errors).toContainEqual({
+            type: "cell/type",
+            fieldName: "topology",
+            fieldType: "geojson",
+            fieldFormat: "topojson",
+            rowNumber: 2,
+            cell: '{"type":"Topology","objects":{}}',
+        });
+        expect(errors).toContainEqual({
+            type: "cell/type",
+            fieldName: "topology",
+            fieldType: "geojson",
+            fieldFormat: "topojson",
+            rowNumber: 3,
+            cell: '{"type":"Topology"}',
+        });
+    });
+    it("should accept TopoJSON geometry objects", async () => {
+        const table = pl
+            .DataFrame({
+            geometry: [
+                '{"type":"Point","coordinates":[0,0]}',
+                '{"type":"LineString","arcs":[0,1]}',
+                '{"type":"Polygon","arcs":[[0,1,2]]}',
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "geometry",
+                    type: "geojson",
+                    format: "topojson",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toHaveLength(0);
+    });
+    it("should handle null values for topojson format", async () => {
+        const table = pl
+            .DataFrame({
+            topology: [
+                '{"type":"Topology","objects":{"example":{"type":"GeometryCollection","geometries":[]}},"arcs":[]}',
+                null,
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "topology",
+                    type: "geojson",
+                    format: "topojson",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toHaveLength(0);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"geojson.spec.js","sourceRoot":"","sources":["../../../field/types/geojson.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Schema } from \"@frictionless-ts/metadata\"\nimport * as pl from \"nodejs-polars\"\nimport { describe, expect, it } from \"vitest\"\nimport { inspectTable } from \"../../table/index.ts\"\n\ndescribe(\"validateGeojsonField\", () => {\n  it(\"should not errors for valid GeoJSON Point\", async () => {\n    const table = pl\n      .DataFrame({\n        location: [\n          '{\"type\":\"Point\",\"coordinates\":[0,0]}',\n          '{\"type\":\"Point\",\"coordinates\":[12.5,41.9]}',\n          '{\"type\":\"Point\",\"coordinates\":[-73.9,40.7]}',\n        ],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"location\",\n          type: \"geojson\",\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toHaveLength(0)\n  })\n\n  it(\"should not errors for valid GeoJSON geometries\", async () => {\n    const table = pl\n      .DataFrame({\n        geometry: [\n          '{\"type\":\"LineString\",\"coordinates\":[[0,0],[1,1]]}',\n          '{\"type\":\"Polygon\",\"coordinates\":[[[0,0],[1,0],[1,1],[0,1],[0,0]]]}',\n          '{\"type\":\"MultiPoint\",\"coordinates\":[[0,0],[1,1]]}',\n        ],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"geometry\",\n          type: \"geojson\",\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toHaveLength(0)\n  })\n\n  it(\"should not errors for valid GeoJSON Feature\", async () => {\n    const table = pl\n      .DataFrame({\n        feature: [\n          '{\"type\":\"Feature\",\"geometry\":{\"type\":\"Point\",\"coordinates\":[0,0]},\"properties\":{\"name\":\"Test\"}}',\n          '{\"type\":\"Feature\",\"geometry\":{\"type\":\"LineString\",\"coordinates\":[[0,0],[1,1]]},\"properties\":{\"id\":1}}',\n          '{\"type\":\"Feature\",\"geometry\":null,\"properties\":{}}',\n        ],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"feature\",\n          type: \"geojson\",\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toHaveLength(0)\n  })\n\n  it(\"should not errors for valid GeoJSON FeatureCollection\", async () => {\n    const table = pl\n      .DataFrame({\n        collection: [\n          '{\"type\":\"FeatureCollection\",\"features\":[{\"type\":\"Feature\",\"geometry\":{\"type\":\"Point\",\"coordinates\":[0,0]},\"properties\":{}}]}',\n          '{\"type\":\"FeatureCollection\",\"features\":[]}',\n        ],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"collection\",\n          type: \"geojson\",\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toHaveLength(0)\n  })\n\n  it(\"should not errors for null values\", async () => {\n    const table = pl\n      .DataFrame({\n        location: [\n          '{\"type\":\"Point\",\"coordinates\":[0,0]}',\n          null,\n          '{\"type\":\"Feature\",\"geometry\":null,\"properties\":{}}',\n        ],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"location\",\n          type: \"geojson\",\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toHaveLength(0)\n  })\n\n  it(\"should errors for JSON arrays\", async () => {\n    const table = pl\n      .DataFrame({\n        data: [\n          '{\"type\":\"Point\",\"coordinates\":[0,0]}',\n          \"[[0,0],[1,1]]\",\n          '{\"type\":\"Feature\",\"geometry\":null,\"properties\":{}}',\n        ],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"data\",\n          type: \"geojson\",\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toEqual([\n      {\n        type: \"cell/type\",\n        fieldName: \"data\",\n        fieldType: \"geojson\",\n        rowNumber: 2,\n        cell: \"[[0,0],[1,1]]\",\n      },\n    ])\n  })\n\n  it(\"should errors for invalid JSON\", async () => {\n    const table = pl\n      .DataFrame({\n        data: [\n          '{\"type\":\"Point\",\"coordinates\":[0,0]}',\n          \"invalid json\",\n          \"{broken}\",\n        ],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"data\",\n          type: \"geojson\",\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors.filter(e => e.type === \"cell/type\")).toHaveLength(2)\n    expect(errors).toContainEqual({\n      type: \"cell/type\",\n      fieldName: \"data\",\n      fieldType: \"geojson\",\n      rowNumber: 2,\n      cell: \"invalid json\",\n    })\n    expect(errors).toContainEqual({\n      type: \"cell/type\",\n      fieldName: \"data\",\n      fieldType: \"geojson\",\n      rowNumber: 3,\n      cell: \"{broken}\",\n    })\n  })\n\n  it(\"should errors for empty strings\", async () => {\n    const table = pl\n      .DataFrame({\n        data: [\n          '{\"type\":\"Point\",\"coordinates\":[0,0]}',\n          \"\",\n          '{\"type\":\"Feature\",\"geometry\":null,\"properties\":{}}',\n        ],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"data\",\n          type: \"geojson\",\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toEqual([\n      {\n        type: \"cell/type\",\n        fieldName: \"data\",\n        fieldType: \"geojson\",\n        rowNumber: 2,\n        cell: \"\",\n      },\n    ])\n  })\n\n  it(\"should errors for JSON primitives\", async () => {\n    const table = pl\n      .DataFrame({\n        data: ['\"string\"', \"123\", \"true\", \"false\", \"null\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"data\",\n          type: \"geojson\",\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toEqual([\n      {\n        type: \"cell/type\",\n        fieldName: \"data\",\n        fieldType: \"geojson\",\n        rowNumber: 1,\n        cell: '\"string\"',\n      },\n      {\n        type: \"cell/type\",\n        fieldName: \"data\",\n        fieldType: \"geojson\",\n        rowNumber: 2,\n        cell: \"123\",\n      },\n      {\n        type: \"cell/type\",\n        fieldName: \"data\",\n        fieldType: \"geojson\",\n        rowNumber: 3,\n        cell: \"true\",\n      },\n      {\n        type: \"cell/type\",\n        fieldName: \"data\",\n        fieldType: \"geojson\",\n        rowNumber: 4,\n        cell: \"false\",\n      },\n      {\n        type: \"cell/type\",\n        fieldName: \"data\",\n        fieldType: \"geojson\",\n        rowNumber: 5,\n        cell: \"null\",\n      },\n    ])\n  })\n\n  it(\"should errors for invalid GeoJSON Point coordinates\", async () => {\n    const table = pl\n      .DataFrame({\n        location: [\n          '{\"type\":\"Point\",\"coordinates\":[0,0]}',\n          '{\"type\":\"Point\",\"coordinates\":[0]}',\n          '{\"type\":\"Point\",\"coordinates\":[0,0,0,0]}',\n        ],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"location\",\n          type: \"geojson\",\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toHaveLength(2)\n    expect(errors).toContainEqual({\n      type: \"cell/type\",\n      fieldName: \"location\",\n      fieldType: \"geojson\",\n      rowNumber: 2,\n      cell: '{\"type\":\"Point\",\"coordinates\":[0]}',\n    })\n    expect(errors).toContainEqual({\n      type: \"cell/type\",\n      fieldName: \"location\",\n      fieldType: \"geojson\",\n      rowNumber: 3,\n      cell: '{\"type\":\"Point\",\"coordinates\":[0,0,0,0]}',\n    })\n  })\n\n  it(\"should errors for invalid GeoJSON LineString\", async () => {\n    const table = pl\n      .DataFrame({\n        line: [\n          '{\"type\":\"LineString\",\"coordinates\":[[0,0],[1,1]]}',\n          '{\"type\":\"LineString\",\"coordinates\":[[0,0]]}',\n          '{\"type\":\"LineString\",\"coordinates\":[0,0]}',\n        ],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"line\",\n          type: \"geojson\",\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toHaveLength(2)\n    expect(errors).toContainEqual({\n      type: \"cell/type\",\n      fieldName: \"line\",\n      fieldType: \"geojson\",\n      rowNumber: 2,\n      cell: '{\"type\":\"LineString\",\"coordinates\":[[0,0]]}',\n    })\n    expect(errors).toContainEqual({\n      type: \"cell/type\",\n      fieldName: \"line\",\n      fieldType: \"geojson\",\n      rowNumber: 3,\n      cell: '{\"type\":\"LineString\",\"coordinates\":[0,0]}',\n    })\n  })\n\n  it(\"should errors for incomplete GeoJSON Feature\", async () => {\n    const table = pl\n      .DataFrame({\n        feature: [\n          '{\"type\":\"Feature\",\"geometry\":{\"type\":\"Point\",\"coordinates\":[0,0]},\"properties\":{}}',\n          '{\"type\":\"Feature\",\"geometry\":{\"type\":\"Point\",\"coordinates\":[0,0]}}',\n          '{\"type\":\"Feature\",\"properties\":{}}',\n        ],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"feature\",\n          type: \"geojson\",\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toHaveLength(2)\n    expect(errors).toContainEqual({\n      type: \"cell/type\",\n      fieldName: \"feature\",\n      fieldType: \"geojson\",\n      rowNumber: 2,\n      cell: '{\"type\":\"Feature\",\"geometry\":{\"type\":\"Point\",\"coordinates\":[0,0]}}',\n    })\n    expect(errors).toContainEqual({\n      type: \"cell/type\",\n      fieldName: \"feature\",\n      fieldType: \"geojson\",\n      rowNumber: 3,\n      cell: '{\"type\":\"Feature\",\"properties\":{}}',\n    })\n  })\n\n  it(\"should errors for invalid GeoJSON FeatureCollection\", async () => {\n    const table = pl\n      .DataFrame({\n        collection: [\n          '{\"type\":\"FeatureCollection\",\"features\":[{\"type\":\"Feature\",\"geometry\":{\"type\":\"Point\",\"coordinates\":[0,0]},\"properties\":{}}]}',\n          '{\"type\":\"FeatureCollection\"}',\n        ],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"collection\",\n          type: \"geojson\",\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toEqual([\n      {\n        type: \"cell/type\",\n        fieldName: \"collection\",\n        fieldType: \"geojson\",\n        rowNumber: 2,\n        cell: '{\"type\":\"FeatureCollection\"}',\n      },\n    ])\n  })\n\n  it(\"should not validate jsonSchema constraints for geojson fields\", async () => {\n    const table = pl\n      .DataFrame({\n        location: [\n          '{\"type\":\"Point\",\"coordinates\":[0,0]}',\n          '{\"type\":\"Point\",\"coordinates\":[100,200]}',\n        ],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"location\",\n          type: \"geojson\",\n          constraints: {\n            jsonSchema: {\n              type: \"object\",\n              properties: {\n                coordinates: {\n                  type: \"array\",\n                  items: { type: \"number\", minimum: -50, maximum: 50 },\n                },\n              },\n            },\n          },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toHaveLength(0)\n  })\n\n  it(\"should not errors for valid TopoJSON\", async () => {\n    const table = pl\n      .DataFrame({\n        topology: [\n          '{\"type\":\"Topology\",\"objects\":{\"example\":{\"type\":\"GeometryCollection\",\"geometries\":[{\"type\":\"Point\",\"coordinates\":[0,0]}]}},\"arcs\":[]}',\n          '{\"type\":\"Topology\",\"objects\":{\"collection\":{\"type\":\"GeometryCollection\",\"geometries\":[]}},\"arcs\":[]}',\n        ],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"topology\",\n          type: \"geojson\",\n          format: \"topojson\",\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toHaveLength(0)\n  })\n\n  it(\"should errors for invalid TopoJSON structure\", async () => {\n    const table = pl\n      .DataFrame({\n        topology: [\n          '{\"type\":\"Topology\",\"objects\":{\"example\":{\"type\":\"GeometryCollection\",\"geometries\":[]}},\"arcs\":[]}',\n          '{\"type\":\"Topology\",\"objects\":{}}',\n          '{\"type\":\"Topology\"}',\n        ],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"topology\",\n          type: \"geojson\",\n          format: \"topojson\",\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toHaveLength(2)\n    expect(errors).toContainEqual({\n      type: \"cell/type\",\n      fieldName: \"topology\",\n      fieldType: \"geojson\",\n      fieldFormat: \"topojson\",\n      rowNumber: 2,\n      cell: '{\"type\":\"Topology\",\"objects\":{}}',\n    })\n    expect(errors).toContainEqual({\n      type: \"cell/type\",\n      fieldName: \"topology\",\n      fieldType: \"geojson\",\n      fieldFormat: \"topojson\",\n      rowNumber: 3,\n      cell: '{\"type\":\"Topology\"}',\n    })\n  })\n\n  it(\"should accept TopoJSON geometry objects\", async () => {\n    const table = pl\n      .DataFrame({\n        geometry: [\n          '{\"type\":\"Point\",\"coordinates\":[0,0]}',\n          '{\"type\":\"LineString\",\"arcs\":[0,1]}',\n          '{\"type\":\"Polygon\",\"arcs\":[[0,1,2]]}',\n        ],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"geometry\",\n          type: \"geojson\",\n          format: \"topojson\",\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toHaveLength(0)\n  })\n\n  it(\"should handle null values for topojson format\", async () => {\n    const table = pl\n      .DataFrame({\n        topology: [\n          '{\"type\":\"Topology\",\"objects\":{\"example\":{\"type\":\"GeometryCollection\",\"geometries\":[]}},\"arcs\":[]}',\n          null,\n        ],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"topology\",\n          type: \"geojson\",\n          format: \"topojson\",\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toHaveLength(0)\n  })\n})\n"]}

package/build/field/types/geopoint.d.ts

@@ -0,0 +1,4 @@
+import type { GeopointField } from "@frictionless-ts/metadata";
+import * as pl from "nodejs-polars";
+export declare function parseGeopointField(field: GeopointField, fieldExpr: pl.Expr): pl.Expr;
+export declare function stringifyGeopointField(field: GeopointField, fieldExpr: pl.Expr): pl.Expr;

package/build/field/types/geopoint.js

@@ -0,0 +1,59 @@
+import * as pl from "nodejs-polars";
+// TODO:
+// Add more validation:
+// - Check the length of the list is 2 (no list.lenghts in polars currently)
+// - Check the values are within -180..180 and -90..90
+// - Return null instead of list if any of the values are out of range
+export function parseGeopointField(field, fieldExpr) {
+    // Default format is "lon,lat" string
+    const format = field.format ?? "default";
+    if (format === "default") {
+        fieldExpr = fieldExpr.str.split(",").cast(pl.List(pl.Float64));
+    }
+    if (format === "array") {
+        fieldExpr = fieldExpr.str
+            .replaceAll("[\\[\\]\\s]", "")
+            .str.split(",")
+            .cast(pl.List(pl.Float64));
+    }
+    if (format === "object") {
+        fieldExpr = pl
+            .concatList([
+            fieldExpr.str.jsonPathMatch("$.lon").cast(pl.Float64),
+            fieldExpr.str.jsonPathMatch("$.lat").cast(pl.Float64),
+        ])
+            .alias(field.name);
+    }
+    return fieldExpr;
+}
+export function stringifyGeopointField(field, fieldExpr) {
+    // Default format is "lon,lat" string
+    const format = field.format ?? "default";
+    if (format === "default") {
+        return fieldExpr.cast(pl.List(pl.String)).lst.join(",");
+    }
+    if (format === "array") {
+        return pl
+            .concatString([
+            pl.lit("["),
+            fieldExpr.lst.get(0).cast(pl.String),
+            pl.lit(","),
+            fieldExpr.lst.get(1).cast(pl.String),
+            pl.lit("]"),
+        ], "")
+            .alias(field.name);
+    }
+    if (format === "object") {
+        return pl
+            .concatString([
+            pl.lit('{"lon":'),
+            fieldExpr.lst.get(0).cast(pl.String),
+            pl.lit(',"lat":'),
+            fieldExpr.lst.get(1).cast(pl.String),
+            pl.lit("}"),
+        ], "")
+            .alias(field.name);
+    }
+    return fieldExpr;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/field/types/geopoint.spec.d.ts

@@ -0,0 +1 @@
+export {};