svgmapviewer-tools-osm 0.0.1

package/src/lib/geojson/geojson-print.ts

@@ -0,0 +1,211 @@
+import { Doc } from '@effect/printer'
+
+import type {
+  _Coordinates,
+  _Crs,
+  _Feature,
+  _FeatureCollection,
+  _Features,
+  _GeoJSON,
+  _Geometry,
+  _Properties,
+  _Tuple,
+  _Value,
+} from './geojson-types'
+
+//// value
+
+// XXX
+export function truncNumber(n: number): number {
+  return Math.round(n * 1000000) / 1000000
+}
+
+export function printValue(v: _Value, comma: boolean): Doc.Doc<never> {
+  return v === null
+    ? Doc.text('null,')
+    : typeof v === 'number'
+      ? Doc.text(`${truncNumber(v)}${comma ? ',' : ''}`)
+      : Doc.text(`'${v}'${comma ? ',' : ''}`)
+}
+
+//// tuple (for prettier)
+
+export function isTuple(obj: _Coordinates): obj is _Tuple {
+  return (
+    obj instanceof Array &&
+    obj.length === 2 &&
+    typeof obj[0] !== 'object' &&
+    typeof obj[1] !== 'object'
+  )
+}
+
+export function printTuple([a, b]: _Tuple): Doc.Doc<never> {
+  return Doc.hcat([
+    Doc.text(`[`),
+    printValue(a, true),
+    printValue(b, false),
+    Doc.text(`],`),
+  ])
+}
+
+//// type
+
+export function printType(type: string): Doc.Doc<never> {
+  return Doc.text(`type: '${type}',`)
+}
+
+//// properties
+
+export function printProperties1(obj: Readonly<_Properties>): Doc.Doc<never> {
+  return Doc.vsep([
+    Doc.text(`properties: {`),
+    Doc.indent(
+      Doc.vsep(
+        Object.entries(obj).map(([k, v]) =>
+          Doc.hcat([Doc.text(`${k}: `), printValue(v, true)])
+        )
+      ),
+      2
+    ),
+    Doc.text(`},`),
+  ])
+}
+
+export function printProperties(obj: Readonly<_Properties>): Doc.Doc<never> {
+  return Object.keys(obj).length === 0
+    ? Doc.text(`properties: {},`)
+    : printProperties1(obj)
+}
+
+//// crs
+
+export function printCrs(obj: Readonly<_Crs>): Doc.Doc<never> {
+  return Doc.vsep([
+    Doc.text(`crs: {`),
+    Doc.indent(
+      Doc.vsep([printType(obj.type), printProperties(obj.properties)]),
+      2
+    ),
+    Doc.text(`},`),
+  ])
+}
+
+//// coordinates
+
+export function printCoordinates1(
+  objs: Readonly<_Coordinates>,
+  top: boolean
+): Doc.Doc<never> {
+  return isTuple(objs)
+    ? Doc.hcat([Doc.text(top ? `coordinates: ` : ``), printTuple(objs)])
+    : Doc.vsep([
+        Doc.text(top ? `coordinates: [` : `[`),
+        Doc.indent(
+          Doc.vsep(
+            objs.map((obj) =>
+              isTuple(obj) ? printTuple(obj) : printCoordinates(obj, false)
+            )
+          ),
+          2
+        ),
+        Doc.text(`],`),
+      ])
+}
+
+export function printCoordinates(
+  objs: Readonly<_Coordinates>,
+  top: boolean
+): Doc.Doc<never> {
+  return objs.length === 0
+    ? Doc.text(`${top ? 'coordinates: ' : ''}[],`)
+    : printCoordinates1(objs, top)
+}
+
+//// geometry
+
+export function printGeometry(obj: Readonly<_Geometry>): Doc.Doc<never> {
+  return Doc.vsep([
+    Doc.text(`geometry: {`),
+    Doc.indent(
+      Doc.vsep([printType(obj.type), printCoordinates(obj.coordinates, true)]),
+      2
+    ),
+    Doc.text(`},`),
+  ])
+}
+
+//// features
+
+export function printFeature(obj: Readonly<_Feature>): Doc.Doc<never> {
+  return Doc.vsep([
+    Doc.text(`{`),
+    Doc.indent(
+      Doc.vsep([
+        printType(obj.type),
+        printProperties(obj.properties),
+        printGeometry(obj.geometry),
+      ]),
+      2
+    ),
+    Doc.text(`},`),
+  ])
+}
+
+export function printFeatureCollection(
+  obj: Readonly<_FeatureCollection>
+): Doc.Doc<never> {
+  return Doc.vsep([
+    Doc.text(`{`),
+    Doc.indent(
+      Doc.vsep([
+        printType(obj.type),
+        Doc.text(`features: [`),
+        Doc.indent(Doc.vsep(obj.features.map((o) => printFeature(o))), 2),
+        Doc.text(`],`),
+      ]),
+      2
+    ),
+    Doc.text(`},`),
+  ])
+}
+
+export function printFeatures1(objs: Readonly<_Features>): Doc.Doc<never> {
+  return Doc.vsep([
+    Doc.text(`features: [`),
+    Doc.indent(
+      Doc.vsep(
+        objs.map((obj) =>
+          obj.type === 'Feature'
+            ? printFeature(obj)
+            : printFeatureCollection(obj)
+        )
+      ),
+      2
+    ),
+    Doc.text(`],`),
+  ])
+}
+
+export function printFeatures(objs: Readonly<_Features>): Doc.Doc<never> {
+  return objs.length === 0 ? Doc.text(`features: [],`) : printFeatures1(objs)
+}
+
+//// GeoJSON
+
+export function printGeoJSON(obj: Readonly<_GeoJSON>): Doc.Doc<never> {
+  return Doc.vsep([
+    Doc.text(`{`),
+    Doc.indent(
+      Doc.vsep(
+        [
+          [printType(obj.type)],
+          [Doc.text(`name: '${obj.name}',`)],
+          obj.crs === undefined ? [] : [printCrs(obj.crs)],
+          [printFeatures(obj.features)],
+        ].flat()
+      ),
+      2
+    ),
+    Doc.text(`}`),
+  ])
+}

package/src/lib/geojson/geojson-schema.test.ts

@@ -0,0 +1,42 @@
+import { expect, test } from '@rstest/core'
+import * as fs from 'node:fs'
+
+import { decodeGeoJSON, decodeProperties } from './geojson-schema'
+
+test('decodeProperties', () => {
+  const o = {
+    a: 1,
+    b: 'b',
+    c: null,
+  }
+  const x = decodeProperties(o)
+  expect(x).toEqual(o)
+})
+
+test('decodeGeoJSON', () => {
+  exampleGeoJsonFiles.forEach((p) => {
+    try {
+      const content = fs.readFileSync(p)
+      const o = JSON.parse(content.toString())
+      const x = decodeGeoJSON(o)
+      expect(x).toEqual(o)
+    } catch (e) {
+      console.error(p, e)
+    }
+  })
+})
+
+const exampleGeoJsonFiles = [
+  '../example-osm/src/data/areas_extent.json',
+  '../example-osm/src/data/areas.json',
+  '../example-osm/src/data/internals_extent.json',
+  '../example-osm/src/data/internals.json',
+  '../example-osm/src/data/map-lines.json',
+  '../example-osm/src/data/map-multilinestrings.json',
+  '../example-osm/src/data/map-multipolygons.json',
+  '../example-osm/src/data/map-other_relations.json',
+  '../example-osm/src/data/map-points.json',
+  '../example-osm/src/data/measures.json',
+  '../example-osm/src/data/origin.json',
+  '../example-osm/src/data/viewbox.json',
+] as const

package/src/lib/geojson/geojson-schema.ts

@@ -0,0 +1,151 @@
+import type { ParseOptions } from 'effect/SchemaAST'
+
+import { Schema } from 'effect'
+
+import type { _Crs, _Features, _Properties } from './geojson-types'
+
+const PropertiesSchema = Schema.Record({
+  key: Schema.String,
+  value: Schema.Union(Schema.Null, Schema.Number, Schema.String),
+})
+
+const PointType = Schema.Literal('Point')
+const MultiPointType = Schema.Literal('MultiPoint')
+const LineStringType = Schema.Literal('LineString')
+const MultiLineStringType = Schema.Literal('MultiLineString')
+const PolygonType = Schema.Literal('Polygon')
+const MultiPolygonType = Schema.Literal('MultiPolygon')
+// XXX const GeometryCollectionType = Schema.Literal('GeometryCollection')
+const FeatureType = Schema.Literal('Feature')
+const FeatureCollectionType = Schema.Literal('FeatureCollection')
+
+const PointCoordinate = Schema.Tuple(Schema.Number, Schema.Number)
+const MultiPointCoordinate = Schema.Array(PointCoordinate)
+const LineStringCoordinate = Schema.Array(PointCoordinate)
+const MultiLineStringCoordinate = Schema.Array(LineStringCoordinate)
+const PolygonCoordinate = Schema.Array(LineStringCoordinate)
+const MultiPolygonCoordinate = Schema.Array(PolygonCoordinate)
+
+////
+
+const PointGeometry = Schema.Struct({
+  type: PointType,
+  coordinates: PointCoordinate,
+})
+const MultiPointGeometry = Schema.Struct({
+  type: MultiPointType,
+  coordinates: MultiPointCoordinate,
+})
+const LineStringGeometry = Schema.Struct({
+  type: LineStringType,
+  coordinates: LineStringCoordinate,
+})
+const MultiLineStringGeometry = Schema.Struct({
+  type: MultiLineStringType,
+  coordinates: MultiLineStringCoordinate,
+})
+const PolygonGeometry = Schema.Struct({
+  type: PolygonType,
+  coordinates: PolygonCoordinate,
+})
+const MultiPolygonGeometry = Schema.Struct({
+  type: MultiPolygonType,
+  coordinates: MultiPolygonCoordinate,
+})
+
+////
+
+const PointFeature = Schema.Struct({
+  type: FeatureType,
+  properties: PropertiesSchema,
+  geometry: PointGeometry,
+})
+const MultiPointFeature = Schema.Struct({
+  type: FeatureType,
+  properties: PropertiesSchema,
+  geometry: MultiPointGeometry,
+})
+const LineStringFeature = Schema.Struct({
+  type: FeatureType,
+  properties: PropertiesSchema,
+  geometry: LineStringGeometry,
+})
+const MultiLineStringFeature = Schema.Struct({
+  type: FeatureType,
+  properties: PropertiesSchema,
+  geometry: MultiLineStringGeometry,
+})
+const PolygonFeature = Schema.Struct({
+  type: FeatureType,
+  properties: PropertiesSchema,
+  geometry: PolygonGeometry,
+})
+const MultiPolygonFeature = Schema.Struct({
+  type: FeatureType,
+  properties: PropertiesSchema,
+  geometry: MultiPolygonGeometry,
+})
+
+const FeatureSchema = Schema.Union(
+  PointFeature,
+  MultiPointFeature,
+  LineStringFeature,
+  MultiLineStringFeature,
+  PolygonFeature,
+  MultiPolygonFeature
+)
+const FeatureCollectionSchema = Schema.Struct({
+  type: FeatureCollectionType,
+  features: Schema.Array(FeatureSchema),
+})
+
+const Features = Schema.Array(
+  Schema.Union(FeatureSchema, FeatureCollectionSchema)
+)
+
+////
+
+const CrsNameType = Schema.Literal('name')
+const CrsLinkType = Schema.Literal('link')
+
+const CrsName = Schema.Struct({
+  type: CrsNameType,
+  properties: Schema.Struct({
+    name: Schema.String,
+  }),
+})
+const CrsLink = Schema.Struct({
+  type: CrsLinkType,
+  properties: Schema.Struct({
+    href: Schema.String,
+    type: Schema.String,
+  }),
+})
+
+const CrsSchema = Schema.Union(CrsName, CrsLink)
+
+////
+
+const GeoJSONSchema = Schema.Struct({
+  type: Schema.String,
+  name: Schema.String,
+  crs: Schema.Union(Schema.Undefined, CrsSchema),
+  features: Features,
+})
+
+////
+
+export const decodeProperties: (
+  u: unknown,
+  overrideOptions?: ParseOptions
+) => _Properties = Schema.decodeUnknownSync(PropertiesSchema)
+
+export const decodeGeoJSON: (
+  u: unknown,
+  overrideOptions?: ParseOptions
+) => {
+  readonly type: string
+  readonly features: _Features
+  readonly name: string
+  readonly crs: undefined | _Crs
+} = Schema.decodeUnknownSync(GeoJSONSchema)

package/src/lib/geojson/geojson-types.ts

@@ -0,0 +1,116 @@
+//// value, tuple
+
+export type _Value = null | number | string
+export type _Tuple = readonly [number, number]
+
+//// properties
+
+export type _Properties = {
+  readonly [x: string]: _Value
+}
+
+//// coordinates
+
+export type _PointCoordinates = readonly [number, number]
+export type _MultiPointCoordinates = readonly _PointCoordinates[]
+export type _LineCoordinates = _MultiPointCoordinates
+export type _MultiLineCoordinates = readonly _LineCoordinates[]
+export type _PolygonCoordinates = _MultiLineCoordinates
+export type _MultiPolygonCoordinates = readonly _PolygonCoordinates[]
+
+export type _Coordinates =
+  | _PointCoordinates
+  | _MultiPointCoordinates
+  //| _LineCoordinates
+  | _MultiLineCoordinates
+  //| _PolygonCoordinates
+  | _MultiPolygonCoordinates
+
+//// geometry
+
+type __Geometry<t, c> = {
+  readonly type: t
+  readonly coordinates: c
+}
+
+export type _PointGeometry = __Geometry<'Point', _PointCoordinates>
+export type _MultiPointGeometry = __Geometry<
+  'MultiPoint',
+  _MultiPointCoordinates
+>
+export type _LineStringGeometry = __Geometry<'LineString', _LineCoordinates>
+export type _MultiLineStringGeometry = __Geometry<
+  'MultiLineString',
+  _MultiLineCoordinates
+>
+export type _PolygonGeometry = __Geometry<'Polygon', _PolygonCoordinates>
+export type _MultiPolygonGeometry = __Geometry<
+  'MultiPolygon',
+  _MultiPolygonCoordinates
+>
+
+export type _Geometry =
+  | _PointGeometry
+  | _MultiPointGeometry
+  | _LineStringGeometry
+  | _MultiLineStringGeometry
+  | _PolygonGeometry
+  | _MultiPolygonGeometry
+
+//// features
+
+export type __Feature<G = _Geometry> = {
+  readonly type: 'Feature'
+  readonly properties: _Properties
+  readonly geometry: G
+}
+
+export type _PointFeature = __Feature<_PointGeometry>
+export type _MultiPointFeature = __Feature<_MultiPointGeometry>
+export type _LineStringFeature = __Feature<_LineStringGeometry>
+export type _MultiLineStringFeature = __Feature<_MultiLineStringGeometry>
+export type _PolygonFeature = __Feature<_PolygonGeometry>
+export type _MultiPolygonFeature = __Feature<_MultiPolygonGeometry>
+
+export type _Feature =
+  | _PointFeature
+  | _MultiPointFeature
+  | _LineStringFeature
+  | _MultiLineStringFeature
+  | _PolygonFeature
+  | _MultiPolygonFeature
+
+export type _FeatureCollection = {
+  readonly type: 'FeatureCollection'
+  readonly features: readonly _Feature[]
+}
+
+export type _GeometryCollection = {
+  readonly type: 'GeometryCollection'
+  readonly geometries: readonly _Geometry[]
+}
+
+export type _Features = readonly (_Feature | _FeatureCollection)[]
+
+//// crs
+
+export type _CrsName = {
+  readonly type: 'name'
+  readonly properties: _Properties
+}
+
+export type _CrsLink = {
+  readonly type: 'link'
+  readonly properties: _Properties
+}
+
+export type _Crs = _CrsName | _CrsLink
+
+//// GeoJSON
+
+export type _GeoJSON = {
+  readonly type: string
+  readonly name: string
+  readonly crs?: _Crs
+  readonly features: _Features
+}

package/src/lib/osm.test.ts

@@ -0,0 +1,17 @@
+import { expect, test } from '@rstest/core'
+
+import { splitOtherTags } from './osm'
+
+test('split other_tags', () => {
+  const v = `"a"=>"a","b"=>"1","c"=>"1.23","d"=>"null"`
+  const x = {
+    a: 'a',
+    b: 1,
+    c: 1.23,
+    d: null,
+  }
+
+  const p = splitOtherTags(v)
+
+  expect(p).toEqual(x)
+})

package/src/lib/osm.ts

@@ -0,0 +1,18 @@
+import { Array, Record } from 'effect'
+
+import type { _Properties, _Value } from './geojson/geojson-types'
+
+function expandVal(s: string): _Value {
+  return s === 'null' ? null : !isNaN(Number(s)) ? Number(s) : s
+}
+
+export function splitOtherTags(s: string): _Properties {
+  const kvs = s
+    .split(/"=>"/g)
+    .flatMap((s) => s.replace(/^"/, '').replace(/"$/, '').split(/","/))
+  const range = Array.range(0, kvs.length / 2 - 1)
+  const pairs = range
+    .map((i) => [kvs[i * 2], kvs[i * 2 + 1]] as [string, string])
+    .map(([k, v]) => [k, expandVal(v)] as [string, _Value])
+  return Record.fromEntries(pairs)
+}

package/src/lib/print-utils.test.ts

@@ -0,0 +1,12 @@
+import { expect, test } from '@rstest/core'
+
+import { splitTypes } from './print-utils'
+
+test('split types', () => {
+  const s = 'a<b<c, d>, e<f, g>, h>'
+
+  const t = splitTypes(s)
+  const x = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
+
+  expect(t).toEqual(x)
+})

package/src/lib/print-utils.ts

@@ -0,0 +1,22 @@
+import { Array, Order, pipe } from 'effect'
+
+function uncomma(s: string): string[] {
+  return Array.fromIterable(s.split(/,/)).map((ss) => ss.trim())
+}
+
+function splitTypes1(t: string): string[] {
+  const re = /<([^<>]*)>/g
+  if (t.match(re)) {
+    const all = t.matchAll(re)
+    const aaa = Array.fromIterable(all).map((m) => uncomma(m[1]))
+    const rest = t.replaceAll(re, '')
+    const bbb = splitTypes(rest)
+    return aaa.concat(bbb).flat()
+  } else {
+    return uncomma(t)
+  }
+}
+
+export function splitTypes(t: string): string[] {
+  return pipe(t, splitTypes1, Array.sort(Order.string))
+}