openskidata-format 14.0.0 → 16.0.0

package/src/Lift.ts

@@ -1,219 +0,0 @@
-import distance from '@turf/distance'
-import { ElevationData, getElevationData } from './ElevationProfile'
-import { FeatureType } from './FeatureType'
-import { Place } from './Place'
-import { SkiAreaSummaryFeature } from './SkiArea'
-import { Source } from './Source'
-import { LiftStationPosition, LiftStationSpotFeature } from './Spot'
-import { Status } from './Status'
-import { exhaustiveMatchingGuard } from './util/exhaustiveMatchingGuard'
-import { ViewportHint } from './ViewportHint'
-
-export type LiftFeature = GeoJSON.Feature<LiftGeometry, LiftProperties>
-
-export type LiftGeometry = GeoJSON.LineString | GeoJSON.MultiLineString
-
-/**
- * Access restriction for a lift feature.
- * - 'private': The lift has restricted access (derived from OSM access=private tag)
- * - null: No access restriction or access information not available
- */
-export type Access = 'private' | null
-
-/**
- * A feature representing a ski lift.
- *
- * Lifts are derived from OpenStreetMap aerialway/railway features that are commonly used for winter sports.
- *
- * Note:
- * - Railways (except funiculars) are included only if they are part of a site=piste relation.
- * - Railway parts are not merged together so a single railway line may be represented as multiple features.
- * - Some lifts included in the dataset may be for other purposes (amusement parks, etc).
- *
- * Properties:
- * @property {FeatureType.Lift} type - The feature type, which is always 'Lift'.
- * @property {string} id - Unique identifier for the lift. The ID is just a hash of the feature, so will change if the feature changes in any way.
- * @property {LiftType} liftType - Type of lift (e.g. chair_lift, gondola). Derived from OpenStreetMap aerialway/railway tags.
- * @property {Status} status - Operational status of the lift. Derived from OpenStreetMap lifecycle tags.
- * @property {Access} access - Access restriction for the lift. Set to "private" when derived from OpenStreetMap access=private tag, otherwise null.
- * @property {string | null} name - Name of the lift. Derived from the OpenStreetMap name tag.
- * @property {string | null} ref - Reference code/number for the lift. Derived from the OpenStreetMap ref tag.
- * @property {string | null} refFRCAIRN - French CAIRN reference identifier. Derived from the OpenStreetMap ref:FR:CAIRN tag.
- * @property {string | null} description - Description of the lift. Derived from the OpenStreetMap description tag.
- * @property {boolean | null} oneway - Whether the lift allows riding only in one direction. Derived from the OpenStreetMap oneway tag.
- * @property {number | null} occupancy - Number of people each carrier can transport. Derived from the OpenStreetMap aerialway:occupancy tag.
- * @property {number | null} capacity - Transport capacity in persons/hour. Derived from the OpenStreetMap aerialway:capacity tag.
- * @property {number | null} duration - Duration of lift ride in seconds. Derived from the OpenStreetMap aerialway:duration tag.
- * @property {boolean | null} detachable - Whether the lift has detachable grips. Derived from the OpenStreetMap aerialway:detachable tag.
- * @property {boolean | null} bubble - Whether the lift has bubbles/covers to protect from weather. Derived from the OpenStreetMap aerialway:bubble tag.
- * @property {boolean | null} heating - Whether the lift has heated carriers/seats. Derived from the OpenStreetMap aerialway:heating tag.
- * @property {boolean | null} tunnel - Whether the lift passes through a tunnel, derived from the OpenStreetMap "tunnel" tag. True for any tunnel value (e.g. "yes", "avalanche_protector", "building_passage"), null if untagged.
- * @property {LiftStationSpotFeature[]} stations - Lift station spot features associated with this lift.
- * @property {SkiAreaSummaryFeature[]} skiAreas - Ski areas this lift is a part of.
- * @property {Source[]} sources - Data sources for the feature.
- * @property {string[]} websites - Websites associated with this lift. Derived from the OpenStreetMap website tag.
- * @property {string | null} wikidataID - Wikidata identifier. Derived from the OpenStreetMap wikidata tag.
- * @property {Place[]} places - Geographic places this lift is within (e.g., city, region, country). Derived from reverse geocoding.
- */
-export type LiftProperties = {
-  type: FeatureType.Lift
-  id: string
-  liftType: LiftType
-  status: Status
-  access: Access
-  name: string | null
-  ref: string | null
-  refFRCAIRN: string | null
-  description: string | null
-  oneway: boolean | null
-  occupancy: number | null
-  capacity: number | null
-  duration: number | null
-  detachable: boolean | null
-  bubble: boolean | null
-  heating: boolean | null
-  tunnel: boolean | null
-  stations: LiftStationSpotFeature[]
-  skiAreas: SkiAreaSummaryFeature[]
-  sources: Source[]
-  websites: string[]
-  wikidataID: string | null
-  places: Place[]
-  viewportHint: ViewportHint
-}
-
-export enum LiftType {
-  CableCar = 'cable_car',
-  Gondola = 'gondola',
-  ChairLift = 'chair_lift',
-  MixedLift = 'mixed_lift',
-  DragLift = 'drag_lift',
-  TBar = 't-bar',
-  JBar = 'j-bar',
-  Platter = 'platter',
-  RopeTow = 'rope_tow',
-  MagicCarpet = 'magic_carpet',
-  Funicular = 'funicular',
-  Railway = 'railway',
-}
-
-export type LiftElevationData = ElevationData & {
-  speedInMetersPerSecond: number | null
-  verticalSpeedInMetersPerSecond: number | null
-}
-
-export function getLiftElevationData(
-  feature: LiftFeature,
-): LiftElevationData | null {
-  const geometry = feature.geometry
-  if (
-    !geometry ||
-    geometry.type !== 'LineString' ||
-    geometry.coordinates[0].length < 3
-  ) {
-    return null
-  }
-
-  const elevationData = getElevationData(geometry)
-  const durationInSeconds = feature.properties.duration
-  const terminalDistances = getTerminalStationDistances(feature)
-  const inclinedLength =
-    terminalDistances?.inclinedLengthInMeters ??
-    elevationData.inclinedLengthInMeters
-  const verticalLength =
-    terminalDistances?.verticalInMeters ?? elevationData.verticalInMeters
-
-  return {
-    ...elevationData,
-    speedInMetersPerSecond: durationInSeconds
-      ? inclinedLength / durationInSeconds
-      : null,
-    verticalSpeedInMetersPerSecond: durationInSeconds
-      ? verticalLength / durationInSeconds
-      : null,
-  }
-}
-
-function getTerminalStationDistances(
-  feature: LiftFeature,
-): { inclinedLengthInMeters: number; verticalInMeters: number } | null {
-  const stations = feature.properties.stations
-  const topStation = stations.find(
-    (s) => s.properties.position === LiftStationPosition.Top,
-  )
-  const bottomStation = stations.find(
-    (s) => s.properties.position === LiftStationPosition.Bottom,
-  )
-
-  if (!topStation || !bottomStation) {
-    return null
-  }
-
-  const topCoords = topStation.geometry.coordinates
-  const bottomCoords = bottomStation.geometry.coordinates
-
-  if (topCoords.length < 3 || bottomCoords.length < 3) {
-    return null
-  }
-
-  const horizontalDistanceInMeters = distance(
-    topStation.geometry,
-    bottomStation.geometry,
-    { units: 'meters' },
-  )
-  const verticalInMeters = Math.abs(topCoords[2] - bottomCoords[2])
-  const inclinedLengthInMeters = Math.sqrt(
-    Math.pow(horizontalDistanceInMeters, 2) + Math.pow(verticalInMeters, 2),
-  )
-
-  return { inclinedLengthInMeters, verticalInMeters }
-}
-
-export function getFormattedLiftType(liftType: LiftType): string {
-  switch (liftType) {
-    case LiftType.CableCar:
-      return 'Cable Car'
-    case LiftType.Gondola:
-      return 'Gondola'
-    case LiftType.ChairLift:
-      return 'Chairlift'
-    case LiftType.MixedLift:
-      return 'Hybrid'
-    case LiftType.DragLift:
-      return 'Drag lift'
-    case LiftType.TBar:
-      return 'T-bar'
-    case LiftType.JBar:
-      return 'J-bar'
-    case LiftType.Platter:
-      return 'Platter'
-    case LiftType.RopeTow:
-      return 'Ropetow'
-    case LiftType.MagicCarpet:
-      return 'Magic Carpet'
-    case LiftType.Funicular:
-      return 'Funicular'
-    case LiftType.Railway:
-      return 'Railway'
-    default:
-      return exhaustiveMatchingGuard(liftType)
-  }
-}
-
-export function getLiftColor(status: Status): string {
-  const brightRedColor = 'hsl(0, 82%, 42%)'
-  const dimRedColor = 'hsl(0, 53%, 42%)'
-
-  switch (status) {
-    case Status.Disused:
-    case Status.Abandoned:
-      return dimRedColor
-    case Status.Proposed:
-    case Status.Planned:
-    case Status.Construction:
-    case Status.Operating:
-      return brightRedColor
-    default:
-      return exhaustiveMatchingGuard(status)
-  }
-}

package/src/LiftNameFormatter.ts

@@ -1,116 +0,0 @@
-import { LiftProperties, LiftType, getFormattedLiftType } from './Lift'
-
-export function getLiftNameAndType(properties: LiftProperties) {
-  const name = properties.name
-
-  const liftType = getAugmentedLiftType(properties)
-
-  if (name && liftType) {
-    return `${name} (${liftType})`
-  } else if (name) {
-    return name
-  } else {
-    return liftType
-  }
-}
-
-function getAugmentedLiftType(properties: LiftProperties): string | null {
-  const components = []
-
-  const heated = properties.heating
-  const bubble = properties.bubble
-  if (heated === true) {
-    components.push('Heated')
-  }
-
-  if (
-    bubble === true &&
-    properties.liftType !== LiftType.CableCar &&
-    properties.liftType !== LiftType.Gondola
-  ) {
-    components.push('Bubble')
-  }
-
-  if (!isOccupancyImplicit(properties) && properties.occupancy) {
-    components.push(properties.occupancy + 'p')
-  }
-
-  const liftType =
-    implicitOccupancyLiftType(properties) ||
-    getFormattedLiftType(properties.liftType)
-  if (liftType !== null) {
-    components.push(liftType)
-  }
-
-  return components.join(' ')
-}
-
-function implicitOccupancyLiftType(properties: LiftProperties): string | null {
-  const occupancy = properties.occupancy
-  if (properties.liftType === LiftType.ChairLift) {
-    switch (occupancy) {
-      case 1:
-        return 'Single'
-      case 2:
-        return 'Double'
-      case 3:
-        return 'Triple'
-      case 4:
-        return 'Quad'
-      default:
-        return null
-    }
-  }
-
-  switch (properties.liftType) {
-    case LiftType.TBar:
-      return 'T-bar'
-    case LiftType.JBar:
-      return 'J-bar'
-    case LiftType.Platter:
-      return 'Platter'
-    case LiftType.RopeTow:
-      return 'Ropetow'
-    case LiftType.MagicCarpet:
-      return 'Magic Carpet'
-  }
-  return null
-}
-
-function isOccupancyImplicit(properties: LiftProperties) {
-  const implicitLiftType = implicitOccupancyLiftType(properties)
-  if (implicitLiftType) {
-    return true
-  }
-
-  return containsAny(properties.name, [
-    't-bar',
-    'j-bar',
-    'platter',
-    'rope tow',
-    'ropetow',
-    'rope-tow',
-    'carpet',
-    'single',
-    'double',
-    'triple',
-    'quad',
-    '1er',
-    '2er',
-    '3er',
-    '4er',
-    '6er',
-    '8er',
-  ])
-}
-
-function containsAny(input: string | null, lowerCaseSearchList: string[]) {
-  if (input === null) {
-    return false
-  }
-
-  const lowerCaseInput = input.toLowerCase()
-  return lowerCaseSearchList.some((searchItem) => {
-    return lowerCaseInput.includes(searchItem)
-  })
-}

package/src/Place.ts

@@ -1,11 +0,0 @@
-export type Place = {
-  iso3166_1Alpha2: string
-  iso3166_2: string | null
-  localized: {
-    en: {
-      country: string
-      region: string | null
-      locality: string | null
-    }
-  }
-}

package/src/Run.ts

@@ -1,242 +0,0 @@
-import * as GeoJSON from 'geojson'
-import {
-  ElevationData,
-  ElevationProfile,
-  getElevationData,
-  getProfileGeometry,
-} from './ElevationProfile'
-import { FeatureType } from './FeatureType'
-import { Place } from './Place'
-import { RunDifficultyConvention } from './RunDifficultyConvention'
-import { SkiAreaSummaryFeature } from './SkiArea'
-import { SnowCoverHistory } from './SnowCoverHistory'
-import { Source } from './Source'
-import { Status } from './Status'
-import { exhaustiveMatchingGuard } from './util/exhaustiveMatchingGuard'
-import { ViewportHint } from './ViewportHint'
-
-export type RunGeometry = GeoJSON.LineString | GeoJSON.Polygon
-
-/**
- * Represents a segment of a ski run/trail.
- *
- * Runs are derived from OpenStreetMap pistes, which are defined as all ways/areas/relations containing a "piste:type" tag.
- * Piste relations support is limited, it is only used to enhance the data of its member ways. There is no way to access the relation itself in the output data.
- *
- * A single run as marked on the mountain may be broken up into several run features, especially if the run has branches, or changes in tags (e.g. difficulty, use).
- *
- * In the future, there might be a "Route" entity introduced to represent a whole run, which would be composed of multiple run features.
- *
- * Note: winter hiking trails and trails of other winter sports disciplines are also included in this dataset.
- *
- * In postprocessing:
- * - overlapping ways are merged into a single run feature with multiple uses.
- * - connected run segments with the same properties are merged into a single run feature.
- */
-export type RunFeature = GeoJSON.Feature<RunGeometry, RunProperties>
-
-/**
- * Represents the properties of a ski run.
- *
- * Properties:
- * @property {FeatureType.Run} type - The feature type, which is always 'Run'.
- * @property {RunUse[]} uses - Use types for the run (e.g. downhill, nordic), derived from OpenStreetMap "piste:type" tags.
- * @property {string} id - Unique identifier for the run. The ID is just a hash of the feature, so will change if the feature changes in any way.
- * @property {string | null} name - Name of the run, if available
- * @property {string | null} ref - Reference code/number for the run. Derived from the OpenStreetMap piste:ref and ref tags.
- * @property {Status} status - Operational status. Note: as only operational runs are included in this dataset, this will always be 'operating'.
- * @property {string | null} description - Description of the run, derived from the OpenStreetMap "piste:description" or "description" tag.
- * @property {RunDifficulty | null} difficulty - Difficulty rating of the run, derived from the OpenStreetMap "piste:difficulty" tag
- * @property {RunDifficultyConvention} difficultyConvention - Regional convention used for representing run difficulty. Derived from location.
- * @property {boolean | null} oneway - Whether the run is one-way only, derived from the OpenStreetMap "piste:oneway" or "oneway" tag, in addition to defaults based on run use.
- * @property {boolean | null} lit - Whether the run has lighting for night skiing, derived from the OpenStreetMap "piste:lit" or "lit" tag.
- * @property {boolean | null} gladed - Whether the run is through gladed/tree terrain, derived from the OpenStreetMap "piste:gladed" or "gladed" tag.
- * @property {boolean | null} patrolled - Whether the run is patrolled by ski patrol, derived from the OpenStreetMap "piste:patrolled" or "patrolled" tag.
- * @property {boolean | null} snowmaking - Whether the run has its operation secured through snowmaking, derived from the OpenStreetMap "piste:snowmaking" tag.
- * @property {boolean | null} snowfarming - Whether the run has its early season operation secured through snowfarming (storing snow from previous season), derived from the OpenStreetMap "piste:snowfarming" tag.
- * @property {boolean | null} tunnel - Whether the run passes through a tunnel, derived from the OpenStreetMap "tunnel" tag. True for any tunnel value (e.g. "yes", "avalanche_protector", "building_passage"), null if untagged.
- * @property {RunGrooming | null} grooming - Grooming status/type of the run, derived from the OpenStreetMap "piste:grooming" tag. If not specified explicitly, for difficulties "expert", "freeride", and "extreme", grooming is assumed to be "backcountry".
- * @property {SkiAreaSummaryFeature[]} skiAreas - Ski areas this run belongs to. Derived from the OpenStreetMap site=piste relation or landuse=winter_sports area and proximity to ski area features. Runs with "backcountry" grooming are not associated with ski areas unless they have a "piste:patrolled=yes" or "patrolled=yes" OpenStreetMap tag, or are part of a "site=piste" ski area relation.
- * @property {ElevationProfile | null} elevationProfile - Elevation profile of the run, only available for runs with LineString geometry.
- * @property {Source[]} sources - Data sources for this run's information
- * @property {string[]} websites - Websites associated with this run, derived from the OpenStreetMap website tag
- * @property {string | null} wikidataID - Wikidata identifier, if available, derived from the OpenStreetMap wikidata tag
- * @property {Place[]} places - Geographic places this run is within (e.g., city, region, country). Derived from reverse geocoding.
- * @property {SnowCoverHistory} [snowCoverHistory] - Historical snow cover data for this run, if available
- */
-export type RunProperties = {
-  type: FeatureType.Run
-  uses: RunUse[]
-  id: string
-  name: string | null
-  ref: string | null
-  status: Status
-  description: string | null
-  difficulty: RunDifficulty | null
-  difficultyConvention: RunDifficultyConvention
-  oneway: boolean | null
-  lit: boolean | null
-  gladed: boolean | null
-  patrolled: boolean | null
-  snowmaking: boolean | null
-  snowfarming: boolean | null
-  tunnel: boolean | null
-  grooming: RunGrooming | null
-  skiAreas: SkiAreaSummaryFeature[]
-  elevationProfile: ElevationProfile | null
-  sources: Source[]
-  websites: string[]
-  wikidataID: string | null
-  places: Place[]
-  snowCoverHistory?: SnowCoverHistory
-  viewportHint: ViewportHint
-}
-
-export enum RunUse {
-  Downhill = 'downhill',
-  Nordic = 'nordic',
-  Skitour = 'skitour',
-  Sled = 'sled',
-  Hike = 'hike',
-  Sleigh = 'sleigh',
-  IceSkate = 'ice_skate',
-  SnowPark = 'snow_park',
-  Playground = 'playground',
-  Connection = 'connection',
-  Fatbike = 'fatbike',
-}
-
-export enum RunGrooming {
-  Classic = 'classic',
-  Mogul = 'mogul',
-  ClassicAndSkating = 'classic+skating',
-  Skating = 'skating',
-  Scooter = 'scooter',
-  Backcountry = 'backcountry',
-}
-
-export enum RunDifficulty {
-  NOVICE = 'novice',
-  EASY = 'easy',
-  INTERMEDIATE = 'intermediate',
-  ADVANCED = 'advanced',
-  EXPERT = 'expert',
-  FREERIDE = 'freeride',
-  EXTREME = 'extreme',
-}
-
-export enum RunColorName {
-  GREEN = 'green',
-  BLUE = 'blue',
-  RED = 'red',
-  BLACK = 'black',
-  ORANGE = 'orange',
-  GREY = 'grey',
-}
-
-export enum RunColorValue {
-  GREEN = 'hsl(125, 100%, 33%)',
-  BLUE = 'hsl(208, 100%, 33%)',
-  RED = 'hsl(359, 94%, 53%)',
-  BLACK = 'hsl(0, 0%, 0%)',
-  ORANGE = 'hsl(34, 100%, 50%)',
-  GREY = 'hsl(0, 0%, 35%)',
-}
-
-
-export function getRunElevationData(feature: RunFeature): ElevationData | null {
-  const geometry = feature.geometry
-  const profile = feature.properties.elevationProfile
-  if (!profile || !geometry || geometry.type !== 'LineString') {
-    return null
-  }
-
-  // Get a geometry that includes elevation data at an even spacing along the run
-  const profileGeometry = getProfileGeometry(geometry, profile)
-  return getElevationData(profileGeometry)
-}
-
-export function getRunColor(
-  convention: RunDifficultyConvention,
-  difficulty: RunDifficulty | null,
-): RunColorValue {
-  return runColorNameToValue(getRunColorName(convention, difficulty))
-}
-
-export function runColorNameToValue(color: RunColorName): RunColorValue {
-  switch (color) {
-    case RunColorName.GREEN:
-      return RunColorValue.GREEN
-    case RunColorName.BLUE:
-      return RunColorValue.BLUE
-    case RunColorName.RED:
-      return RunColorValue.RED
-    case RunColorName.BLACK:
-      return RunColorValue.BLACK
-    case RunColorName.ORANGE:
-      return RunColorValue.ORANGE
-    case RunColorName.GREY:
-      return RunColorValue.GREY
-    default:
-      throw 'invalid color'
-  }
-}
-
-export function getRunColorName(
-  convention: RunDifficultyConvention,
-  difficulty: RunDifficulty | null,
-): RunColorName {
-  switch (convention) {
-    case RunDifficultyConvention.EUROPE:
-      switch (difficulty) {
-        case RunDifficulty.NOVICE:
-          return RunColorName.GREEN
-        case RunDifficulty.EASY:
-          return RunColorName.BLUE
-        case RunDifficulty.INTERMEDIATE:
-          return RunColorName.RED
-        case RunDifficulty.ADVANCED:
-        case RunDifficulty.EXPERT:
-          return RunColorName.BLACK
-        case RunDifficulty.FREERIDE:
-        case RunDifficulty.EXTREME:
-          return RunColorName.ORANGE
-        default:
-          return RunColorName.GREY
-      }
-    case RunDifficultyConvention.JAPAN:
-      switch (difficulty) {
-        case RunDifficulty.NOVICE:
-        case RunDifficulty.EASY:
-          return RunColorName.GREEN
-        case RunDifficulty.INTERMEDIATE:
-          return RunColorName.RED
-        case RunDifficulty.ADVANCED:
-        case RunDifficulty.EXPERT:
-          return RunColorName.BLACK
-        case RunDifficulty.FREERIDE:
-        case RunDifficulty.EXTREME:
-          return RunColorName.ORANGE
-        default:
-          return RunColorName.GREY
-      }
-    case RunDifficultyConvention.NORTH_AMERICA:
-      switch (difficulty) {
-        case RunDifficulty.NOVICE:
-        case RunDifficulty.EASY:
-          return RunColorName.GREEN
-        case RunDifficulty.INTERMEDIATE:
-          return RunColorName.BLUE
-        case RunDifficulty.ADVANCED:
-        case RunDifficulty.EXPERT:
-          return RunColorName.BLACK
-        case RunDifficulty.FREERIDE:
-        case RunDifficulty.EXTREME:
-          return RunColorName.ORANGE
-        default:
-          return RunColorName.GREY
-      }
-    default:
-      return exhaustiveMatchingGuard(convention)
-  }
-}

package/src/RunDifficultyConvention.test.ts

@@ -1,79 +0,0 @@
-import { getRunDifficultyConvention, RunDifficultyConvention } from "./RunDifficultyConvention";
-
-describe("getRunDifficultyConvention", () => {
-  it("should return JAPAN for locations in Japan", () => {
-    // Point in Japan (Tokyo)
-    const tokyoGeometry = {
-      type: "Point" as const,
-      coordinates: [139.6917, 35.6895]
-    };
-
-    expect(getRunDifficultyConvention(tokyoGeometry)).toBe(RunDifficultyConvention.JAPAN);
-  });
-
-  it("should return NORTH_AMERICA for locations in North America", () => {
-    // Point in Colorado, USA
-    const coloradoGeometry = {
-      type: "Point" as const,
-      coordinates: [-106.3731, 39.1911]
-    };
-
-    expect(getRunDifficultyConvention(coloradoGeometry)).toBe(RunDifficultyConvention.NORTH_AMERICA);
-
-    // Point in British Columbia, Canada
-    const bcGeometry = {
-      type: "Point" as const,
-      coordinates: [-123.1207, 49.2827]
-    };
-
-    expect(getRunDifficultyConvention(bcGeometry)).toBe(RunDifficultyConvention.NORTH_AMERICA);
-  });
-
-  it("should return EUROPE for locations in Europe", () => {
-    // Point in the Alps (Chamonix, France)
-    const chamonixGeometry = {
-      type: "Point" as const,
-      coordinates: [6.8694, 45.9237]
-    };
-
-    expect(getRunDifficultyConvention(chamonixGeometry)).toBe(RunDifficultyConvention.EUROPE);
-
-    // Point in Austria
-    const austriaGeometry = {
-      type: "Point" as const,
-      coordinates: [13.7558, 47.8095]
-    };
-
-    expect(getRunDifficultyConvention(austriaGeometry)).toBe(RunDifficultyConvention.EUROPE);
-  });
-
-  it("should return EUROPE as default for other locations", () => {
-    // Point in South America (should default to Europe)
-    const southAmericaGeometry = {
-      type: "Point" as const,
-      coordinates: [-58.3816, -34.6037] // Buenos Aires, Argentina
-    };
-
-    expect(getRunDifficultyConvention(southAmericaGeometry)).toBe(RunDifficultyConvention.EUROPE);
-  });
-
-  it("should work with LineString geometry", () => {
-    // LineString crossing through Europe
-    const lineGeometry = {
-      type: "LineString" as const,
-      coordinates: [[6.8, 45.9], [6.9, 46.0]]
-    };
-
-    expect(getRunDifficultyConvention(lineGeometry)).toBe(RunDifficultyConvention.EUROPE);
-  });
-
-  it("should work with Polygon geometry", () => {
-    // Polygon in North America
-    const polygonGeometry = {
-      type: "Polygon" as const,
-      coordinates: [[[-106.4, 39.1], [-106.3, 39.1], [-106.3, 39.2], [-106.4, 39.2], [-106.4, 39.1]]]
-    };
-
-    expect(getRunDifficultyConvention(polygonGeometry)).toBe(RunDifficultyConvention.NORTH_AMERICA);
-  });
-});