openskidata-format 14.0.0 → 16.0.0

package/src/Spot.ts

@@ -1,140 +0,0 @@
-import * as GeoJSON from 'geojson'
-import { FeatureType } from './FeatureType'
-import { Place } from './Place'
-import { SkiAreaSummaryFeature } from './SkiArea'
-import { Source } from './Source'
-import { ViewportHint } from './ViewportHint'
-
-/**
- * A GeoJSON feature representing a spot (point of interest) in or around a ski area.
- *
- * Spots are used to represent lift stations, road crossings, or certain terrain features.
- */
-export type SpotFeature = GeoJSON.Feature<SpotGeometry, SpotProperties>
-
-/**
- * A GeoJSON feature representing a lift station spot.
- */
-export type LiftStationSpotFeature = GeoJSON.Feature<
-  SpotGeometry,
-  LiftStationSpotProperties
->
-
-/**
- * Geometry type for spots - always a point.
- */
-export type SpotGeometry = GeoJSON.Point
-
-/**
- * Union of all spot property types.
- */
-export type SpotProperties =
-  | CrossingSpotProperties
-  | LiftStationSpotProperties
-  | AvalancheTransceiverTrainingSpotProperties
-  | AvalancheTransceiverCheckpointSpotProperties
-  | HalfpipeSpotProperties
-
-/**
- * Base properties shared by all spot types.
- */
-export type SpotBaseProperties = {
-  type: FeatureType.Spot
-  id: string
-  skiAreas: SkiAreaSummaryFeature[]
-  sources: Source[]
-  places: Place[]
-  viewportHint: ViewportHint
-}
-
-/**
- * Types of spots that can be found in or around ski areas.
- */
-export enum SpotType {
-  Crossing = 'crossing',
-  LiftStation = 'lift_station',
-  AvalancheTransceiverTraining = 'avalanche_transceiver_training',
-  AvalancheTransceiverCheckpoint = 'avalanche_transceiver_checkpoint',
-  Halfpipe = 'halfpipe',
-}
-
-/**
- * A crossing is a point where a ski run intersects with a road or path,
- * potentially requiring skiers to remove their skis.
- *
- * From OpenStreetMap node with tag `piste:dismount=yes|no|sometimes`.
- */
-export type CrossingSpotProperties = SpotBaseProperties & {
-  spotType: SpotType.Crossing
-  dismount: DismountRequirement
-}
-
-/**
- * Whether dismounting from skis is required at a crossing.
- */
-export enum DismountRequirement {
-  Yes = 'yes',
-  No = 'no',
-  Sometimes = 'sometimes',
-}
-
-/**
- * A lift station is a boarding or alighting point for a ski lift.
- *
- * From OpenStreetMap node or area with tag `aerialway=station`.
- * Areas are represented as a point (centroid).
- *
- * @property {string | null} name - Name of the station, from OpenStreetMap tag `name`.
- * @property {LiftStationPosition | null} position - From OpenStreetMap tag `aerialway:station=bottom|mid|top`.
- * @property {boolean | null} entry - Whether passengers can board here. From OpenStreetMap tag `aerialway:access=entry|both|no`.
- * @property {boolean | null} exit - Whether passengers can alight here. From OpenStreetMap tag `aerialway:access=exit|both|no`.
- * @property {string} liftId - ID of the lift feature associated with this station.
- */
-export type LiftStationSpotProperties = SpotBaseProperties & {
-  spotType: SpotType.LiftStation
-  name: string | null
-  position: LiftStationPosition | null
-  entry: boolean | null
-  exit: boolean | null
-  liftId: string
-}
-
-/**
- * Position of a lift station along the lift line.
- */
-export enum LiftStationPosition {
-  Top = 'top',
-  Mid = 'mid',
-  Bottom = 'bottom',
-}
-
-/**
- * A designated area where skiers can practice using avalanche transceivers.
- *
- * From OpenStreetMap node or area with tags `amenity=avalanche_transceiver` and `avalanche_transceiver=training`.
- * Areas are represented as a point (centroid).
- */
-export type AvalancheTransceiverTrainingSpotProperties = SpotBaseProperties & {
-  spotType: SpotType.AvalancheTransceiverTraining
-}
-
-/**
- * A checkpoint where skiers can verify their avalanche transceiver is functioning.
- *
- * From OpenStreetMap node or area with tags `amenity=avalanche_transceiver` and `avalanche_transceiver=checkpoint`.
- * Areas are represented as a point (centroid).
- */
-export type AvalancheTransceiverCheckpointSpotProperties =
-  SpotBaseProperties & {
-    spotType: SpotType.AvalancheTransceiverCheckpoint
-  }
-
-/**
- * A halfpipe structure for freestyle skiing or snowboarding.
- *
- * From OpenStreetMap node/way/area with tag `man_made=piste:halfpipe`.
- * Areas are represented as a point (centroid).
- */
-export type HalfpipeSpotProperties = SpotBaseProperties & {
-  spotType: SpotType.Halfpipe
-}

package/src/Status.ts

@@ -1,20 +0,0 @@
-/**
- * Status of a feature.
- *
- * Note that this is not real-time status but indicates whether a feature is in operation when conditions permit or is abandoned, etc.
- *
- * Primarily derived from OpenStreetMap tags.
- * Additionally, Skimap.org data provides status information for ski area features only.
- *
- * Tagging schemes supported are:
- * - lifecycle prefixes (preferred) https://wiki.openstreetmap.org/wiki/Lifecycle_prefix
- * - separate lifecycle tags ("proposed=yes", etc)
- */
-export enum Status {
-  Operating = 'operating',
-  Disused = 'disused',
-  Abandoned = 'abandoned',
-  Proposed = 'proposed',
-  Planned = 'planned',
-  Construction = 'construction',
-}

package/src/ViewportHint.ts

@@ -1,208 +0,0 @@
-import * as GeoJSON from 'geojson'
-import distance from '@turf/distance'
-
-/**
- * Pre-computed viewport positioning data stored on every feature's properties.
- * Camera space: Y axis points uphill (along bearing), X axis points screen-right.
- * Metric values are in that rotated frame with elevation-adjusted Y positions
- * (at 45° pitch, Δe metres above mean elevation shifts Y by Δe metres).
- */
-export type ViewportHint = {
-  /** Geographic centre of the rotated bounding box as [lng, lat]. */
-  center: [number, number]
-
-  /**
-   * Uphill bearing in degrees clockwise from north. null when elevation variation is
-   * insufficient to determine orientation — client should use top-down view (pitch 0, bearing 0).
-   */
-  bearing: number | null
-
-  /** Bounding box width along the camera X axis, in metres. */
-  rotatedWidthMeters: number
-
-  /** Bounding box height along the camera Y axis, in metres (elevation-adjusted). */
-  rotatedHeightMeters: number
-
-  /**
-   * Most-downhill edge of the elevation-adjusted bounding box in camera-Y metres, relative
-   * to mean feature elevation. Used to compute the perspective centre shift at 45° pitch:
-   * look-at point = minCameraY + nearFraction * rotatedHeightMeters, where
-   * nearFraction = nearGround / (nearGround + farGround) from camera pitch and vFOV.
-   */
-  minCameraY: number
-}
-
-/**
- * Computes a ViewportHint from one or more GeoJSON geometries.
- * All geometry types are accepted; elevation is read from the Z coordinate (defaults to 0).
- * Throws if no coordinates are found.
- */
-export function computeViewportHint(
-  geometries: GeoJSON.Geometry[],
-): ViewportHint {
-  // Collect all coordinates (for bbox + elevation stats) and consecutive segment pairs
-  // (for the downhill bearing calculation).
-  const allCoords: [number, number, number][] = []
-  const bearingSegments: [[number, number, number], [number, number, number]][] =
-    []
-
-  for (const geom of geometries) {
-    collectGeometry(geom, allCoords, bearingSegments)
-  }
-
-  if (allCoords.length === 0) throw new Error('computeViewportHint: no coordinates found in provided geometries')
-
-  let minLng = Infinity,
-    maxLng = -Infinity
-  let minLat = Infinity,
-    maxLat = -Infinity
-  for (const [lng, lat] of allCoords) {
-    if (lng < minLng) minLng = lng
-    if (lng > maxLng) maxLng = lng
-    if (lat < minLat) minLat = lat
-    if (lat > maxLat) maxLat = lat
-  }
-
-  const centerLng = (minLng + maxLng) / 2
-  const centerLat = (minLat + maxLat) / 2
-
-  // Weight each segment's downhill direction by length to find dominant bearing.
-  let sumSin = 0,
-    sumCos = 0
-  for (const [[lng0, lat0, elev0], [lng1, lat1, elev1]] of bearingSegments) {
-    if (elev0 === elev1) continue
-    const [fromLng, fromLat, toLng, toLat] =
-      elev0 > elev1
-        ? [lng0, lat0, lng1, lat1]
-        : [lng1, lat1, lng0, lat0]
-    const bear = greatCircleBearing(fromLat, fromLng, toLat, toLng)
-    const len = distance([lng0, lat0], [lng1, lat1], { units: 'meters' })
-    const bearingRad = (bear * Math.PI) / 180
-    sumSin += Math.sin(bearingRad) * len
-    sumCos += Math.cos(bearingRad) * len
-  }
-
-  // Uphill bearing = downhill + 180°; null if no elevation variation found.
-  // A small offset is added so the camera is angled slightly to the side of the fall line,
-  // giving a better 3-D profile of the terrain rather than pointing straight uphill.
-  const bearingSideOffsetDeg = 30
-  let mapBearing: number | null = null
-  if (sumSin !== 0 || sumCos !== 0) {
-    const dominantDownhill = (Math.atan2(sumSin, sumCos) * 180) / Math.PI
-    const normalizedDownhill = ((dominantDownhill % 360) + 360) % 360
-    mapBearing = (normalizedDownhill + 180 + bearingSideOffsetDeg) % 360
-  }
-
-  const metersPerDeg = 111320
-  const cosLat = Math.cos(centerLat * (Math.PI / 180))
-  const bearingRad = ((mapBearing ?? 0) * Math.PI) / 180
-
-  let elevationSum = 0
-  for (const [, , elev] of allCoords) elevationSum += elev
-  const meanElevation = elevationSum / allCoords.length
-
-  let minCameraX = Infinity,
-    maxCameraX = -Infinity
-  let minCameraY = Infinity,
-    maxCameraY = -Infinity
-
-  for (const [lng, lat, elev] of allCoords) {
-    const dx = (lng - centerLng) * cosLat * metersPerDeg
-    const dy = (lat - centerLat) * metersPerDeg
-    const cx = dx * Math.cos(bearingRad) - dy * Math.sin(bearingRad)
-    const cy = dx * Math.sin(bearingRad) + dy * Math.cos(bearingRad)
-    // At 45° pitch, elevation above mean shifts apparent Y by the same amount (tan 45° = 1).
-    const cyEffective = cy + (elev - meanElevation)
-    if (cx < minCameraX) minCameraX = cx
-    if (cx > maxCameraX) maxCameraX = cx
-    if (cyEffective < minCameraY) minCameraY = cyEffective
-    if (cyEffective > maxCameraY) maxCameraY = cyEffective
-  }
-
-  return {
-    center: [centerLng, centerLat],
-    bearing: mapBearing,
-    rotatedWidthMeters: maxCameraX - minCameraX,
-    rotatedHeightMeters: maxCameraY - minCameraY,
-    minCameraY,
-  }
-}
-
-/** Recursively extracts coordinates and segment pairs from a geometry. */
-function collectGeometry(
-  geom: GeoJSON.Geometry,
-  allCoords: [number, number, number][],
-  bearingSegments: [[number, number, number], [number, number, number]][],
-): void {
-  switch (geom.type) {
-    case 'Point': {
-      const [lng, lat, elev = 0] = geom.coordinates
-      allCoords.push([lng, lat, elev])
-      break
-    }
-    case 'MultiPoint': {
-      for (const pos of geom.coordinates) {
-        const [lng, lat, elev = 0] = pos
-        allCoords.push([lng, lat, elev])
-      }
-      break
-    }
-    case 'LineString':
-      collectPositions(geom.coordinates, allCoords, bearingSegments)
-      break
-    case 'MultiLineString':
-      for (const line of geom.coordinates) {
-        collectPositions(line, allCoords, bearingSegments)
-      }
-      break
-    case 'Polygon':
-      for (const ring of geom.coordinates) {
-        collectPositions(ring, allCoords, bearingSegments)
-      }
-      break
-    case 'MultiPolygon':
-      for (const polygon of geom.coordinates) {
-        for (const ring of polygon) {
-          collectPositions(ring, allCoords, bearingSegments)
-        }
-      }
-      break
-    case 'GeometryCollection':
-      for (const g of geom.geometries) {
-        collectGeometry(g, allCoords, bearingSegments)
-      }
-      break
-  }
-}
-
-/** Adds positions to allCoords and consecutive pairs to bearingSegments. Z defaults to 0. */
-function collectPositions(
-  positions: GeoJSON.Position[],
-  allCoords: [number, number, number][],
-  bearingSegments: [[number, number, number], [number, number, number]][],
-): void {
-  const elevated: [number, number, number][] = positions.map(
-    ([lng, lat, elev = 0]) => [lng, lat, elev],
-  )
-  for (const coord of elevated) allCoords.push(coord)
-  for (let i = 0; i < elevated.length - 1; i++) {
-    bearingSegments.push([elevated[i], elevated[i + 1]])
-  }
-}
-
-/** Great-circle bearing from (lat1, lng1) to (lat2, lng2), in degrees 0–360. */
-function greatCircleBearing(
-  lat1: number,
-  lng1: number,
-  lat2: number,
-  lng2: number,
-): number {
-  const toRad = (d: number) => (d * Math.PI) / 180
-  const φ1 = toRad(lat1)
-  const φ2 = toRad(lat2)
-  const Δλ = toRad(lng2 - lng1)
-  const y = Math.sin(Δλ) * Math.cos(φ2)
-  const x =
-    Math.cos(φ1) * Math.sin(φ2) - Math.sin(φ1) * Math.cos(φ2) * Math.cos(Δλ)
-  return ((Math.atan2(y, x) * 180) / Math.PI + 360) % 360
-}

package/src/index.ts

@@ -1,15 +0,0 @@
-export * from './ElevationProfile'
-export * from './FeatureType'
-export * from './Lift'
-export * from './LiftNameFormatter'
-export * from './Place'
-export * from './Run'
-export * from './RunDifficultyConvention'
-export * from './SlopeGradingScale'
-export * from './SkiArea'
-export * from './SkiPass'
-export * from './SnowCoverHistory'
-export * from './Source'
-export * from './Spot'
-export * from './Status'
-export * from './ViewportHint'

package/src/testUtils.ts

@@ -1,5 +0,0 @@
-import { ViewportHint } from './ViewportHint'
-
-export function mockViewportHint(): ViewportHint {
-  return { center: [0, 0], bearing: null, rotatedWidthMeters: 0, rotatedHeightMeters: 0, minCameraY: 0 }
-}

package/src/util/exhaustiveMatchingGuard.ts

@@ -1,3 +0,0 @@
-export const exhaustiveMatchingGuard = (value: never): never => {
-  throw new Error(`Unhandled case: ${value}`)
-}