openskidata-format 14.0.0 → 16.0.0

package/src/SlopeGradingScale.test.ts

@@ -1,151 +0,0 @@
-import { RunDifficulty, RunUse } from "./Run";
-import { getEstimatedRunDifficulty, getSlopeGradingScale } from "./SlopeGradingScale";
-import { mockViewportHint } from "./testUtils";
-
-describe("getEstimatedRunDifficulty", () => {
-  it("should return null for steepness below minimum threshold", () => {
-    const downhillScale = getSlopeGradingScale({
-      type: "Feature",
-      geometry: { type: "LineString", coordinates: [] },
-      properties: {
-        type: "Run" as any,
-        uses: [RunUse.Downhill],
-        id: "test",
-        name: null,
-        ref: null,
-        status: "operating" as any,
-        description: null,
-        difficulty: null,
-        difficultyConvention: "europe" as any,
-        oneway: null,
-        lit: null,
-        gladed: null,
-        patrolled: null,
-        snowmaking: null,
-        snowfarming: null,
-        grooming: null,
-        skiAreas: [],
-        elevationProfile: null,
-        sources: [],
-        websites: [],
-        wikidataID: null,
-        tunnel: null,
-        places: [],
-        viewportHint: mockViewportHint(),
-      },
-    });
-
-    expect(getEstimatedRunDifficulty(0.03, downhillScale)).toBeNull(); // 3% steepness
-  });
-
-  it("should return correct difficulty for downhill slopes", () => {
-    const downhillScale = getSlopeGradingScale({
-      type: "Feature",
-      geometry: { type: "LineString", coordinates: [] },
-      properties: {
-        type: "Run" as any,
-        uses: [RunUse.Downhill],
-        id: "test",
-        name: null,
-        ref: null,
-        status: "operating" as any,
-        description: null,
-        difficulty: null,
-        difficultyConvention: "europe" as any,
-        oneway: null,
-        lit: null,
-        gladed: null,
-        patrolled: null,
-        snowmaking: null,
-        snowfarming: null,
-        grooming: null,
-        skiAreas: [],
-        elevationProfile: null,
-        sources: [],
-        websites: [],
-        wikidataID: null,
-        tunnel: null,
-        places: [],
-        viewportHint: mockViewportHint(),
-      },
-    });
-
-    expect(getEstimatedRunDifficulty(0.1, downhillScale)).toBe(RunDifficulty.EASY); // 10%
-    expect(getEstimatedRunDifficulty(0.3, downhillScale)).toBe(RunDifficulty.INTERMEDIATE); // 30%
-    expect(getEstimatedRunDifficulty(0.6, downhillScale)).toBe(RunDifficulty.ADVANCED); // 60%
-    expect(getEstimatedRunDifficulty(0.9, downhillScale)).toBe(RunDifficulty.EXPERT); // 90%
-    expect(getEstimatedRunDifficulty(1.0, downhillScale)).toBe(RunDifficulty.FREERIDE); // 100%
-  });
-
-  it("should return correct difficulty for nordic slopes", () => {
-    const nordicScale = getSlopeGradingScale({
-      type: "Feature",
-      geometry: { type: "LineString", coordinates: [] },
-      properties: {
-        type: "Run" as any,
-        uses: [RunUse.Nordic],
-        id: "test",
-        name: null,
-        ref: null,
-        status: "operating" as any,
-        description: null,
-        difficulty: null,
-        difficultyConvention: "europe" as any,
-        oneway: null,
-        lit: null,
-        gladed: null,
-        patrolled: null,
-        snowmaking: null,
-        snowfarming: null,
-        grooming: null,
-        skiAreas: [],
-        elevationProfile: null,
-        sources: [],
-        websites: [],
-        wikidataID: null,
-        tunnel: null,
-        places: [],
-        viewportHint: mockViewportHint(),
-      },
-    });
-
-    expect(getEstimatedRunDifficulty(0.05, nordicScale)).toBe(RunDifficulty.EASY); // 5%
-    expect(getEstimatedRunDifficulty(0.12, nordicScale)).toBe(RunDifficulty.INTERMEDIATE); // 12%
-    expect(getEstimatedRunDifficulty(0.25, nordicScale)).toBe(RunDifficulty.ADVANCED); // 25%
-  });
-
-  it("should handle negative steepness (uphill)", () => {
-    const downhillScale = getSlopeGradingScale({
-      type: "Feature",
-      geometry: { type: "LineString", coordinates: [] },
-      properties: {
-        type: "Run" as any,
-        uses: [RunUse.Downhill],
-        id: "test",
-        name: null,
-        ref: null,
-        status: "operating" as any,
-        description: null,
-        difficulty: null,
-        difficultyConvention: "europe" as any,
-        oneway: null,
-        lit: null,
-        gladed: null,
-        patrolled: null,
-        snowmaking: null,
-        snowfarming: null,
-        grooming: null,
-        skiAreas: [],
-        elevationProfile: null,
-        sources: [],
-        websites: [],
-        wikidataID: null,
-        tunnel: null,
-        places: [],
-        viewportHint: mockViewportHint(),
-      },
-    });
-
-    expect(getEstimatedRunDifficulty(-0.1, downhillScale)).toBe(RunDifficulty.EASY); // -10%
-  });
-});

package/src/SlopeGradingScale.ts

@@ -1,96 +0,0 @@
-import { RunDifficulty, RunFeature, RunUse } from "./Run";
-import { RunDifficultyConvention } from "./RunDifficultyConvention";
-
-/**
- * Represents a slope grading scale with steepness thresholds for different run types.
- * Used to estimate run difficulty based on slope steepness. Each scale defines
- * threshold points where the difficulty classification changes based on gradient.
- */
-export type SlopeGradingScale = {
-  /** Stops must be ordered ascending by steepness */
-  stops: { maxSteepness: number; difficulty: RunDifficulty | null }[];
-};
-
-/**
- * Gets the appropriate slope grading scale for a run based on its use types.
- * Different run uses (downhill, nordic, etc.) have different steepness thresholds
- * for difficulty classification due to the nature of the activity and equipment used.
- * 
- * @param feature - The run feature to get the grading scale for
- * @returns The appropriate slope grading scale with steepness thresholds
- */
-export function getSlopeGradingScale(feature: RunFeature): SlopeGradingScale {
-  // Check for downhill or skitour uses first (they have the same scale)
-  if (
-    feature.properties.uses.includes(RunUse.Downhill) ||
-    feature.properties.uses.includes(RunUse.Skitour)
-  ) {
-    return getSlopeGradingScaleForUse(RunUse.Downhill, feature.properties.difficultyConvention);
-  } else if (feature.properties.uses.includes(RunUse.Nordic)) {
-    return getSlopeGradingScaleForUse(RunUse.Nordic, feature.properties.difficultyConvention);
-  } else {
-    return { stops: [] };
-  }
-}
-
-/**
- * Estimates the run difficulty based on steepness and the provided slope grading scale.
- * Uses the absolute value of steepness to handle both uphill and downhill slopes.
- * Finds the first threshold that the steepness falls under.
- * 
- * @param steepness - The steepness value (slope gradient as a decimal, e.g., 0.1 = 10%)
- * @param scale - The slope grading scale with steepness thresholds
- * @returns The estimated difficulty based on steepness, or null if no match or below minimum threshold
- */
-export function getEstimatedRunDifficulty(
-  steepness: number,
-  scale: SlopeGradingScale
-): RunDifficulty | null {
-  const absoluteSteepness = Math.abs(steepness);
-  return (
-    scale.stops.find((stop) => stop.maxSteepness > absoluteSteepness)
-      ?.difficulty || null
-  );
-}
-
-/**
- * Gets the appropriate slope grading scale for a specific run use and region.
- * Different run uses (downhill, nordic, etc.) have different steepness thresholds
- * for difficulty classification. This function allows for regional variations
- * in the future if different conventions use different slope scales.
- * 
- * @param runUse - The type of run use to get the grading scale for
- * @param convention - The regional difficulty convention (currently not used but available for future regional variations)
- * @returns The appropriate slope grading scale with steepness thresholds
- */
-export function getSlopeGradingScaleForUse(
-  runUse: RunUse,
-  convention: RunDifficultyConvention
-): SlopeGradingScale {
-  // Currently convention is not used, but is available for future regional variations
-  switch (runUse) {
-    case RunUse.Downhill:
-    case RunUse.Skitour:
-      return {
-        stops: [
-          { maxSteepness: 0.05, difficulty: null }, // No difficulty below 5%
-          { maxSteepness: 0.25, difficulty: RunDifficulty.EASY },
-          { maxSteepness: 0.4, difficulty: RunDifficulty.INTERMEDIATE },
-          { maxSteepness: 0.8, difficulty: RunDifficulty.ADVANCED }, // Advanced up to 80%
-          { maxSteepness: 1.0, difficulty: RunDifficulty.EXPERT }, // Expert up to 100%
-          { maxSteepness: 1.2, difficulty: RunDifficulty.FREERIDE }, // Freeride up to 120%
-          { maxSteepness: Infinity, difficulty: RunDifficulty.EXTREME }, // Extreme above 120%
-        ],
-      };
-    case RunUse.Nordic:
-    return {
-        stops: [
-          { maxSteepness: 0.1, difficulty: RunDifficulty.EASY },
-          { maxSteepness: 0.15, difficulty: RunDifficulty.INTERMEDIATE },
-          { maxSteepness: 0.3, difficulty: RunDifficulty.ADVANCED },
-        ],
-      };
-    default:
-      return { stops: [] };
-  }
-}

package/src/SnowCoverHistory.test.ts

@@ -1,103 +0,0 @@
-import { getMonthlySnowCover, SnowCoverHistory, MonthlySnowCoverHistory } from './SnowCoverHistory'
-
-describe('getMonthlySnowCover', () => {
-  it('should process daily data into monthly averages', () => {
-    const input: SnowCoverHistory = [
-      {
-        year: 2023,
-        days: [
-          [1, 80, 95],   // Jan 1
-          [15, 75, 90],  // Jan 15
-          [32, 60, 85],  // Feb 1
-          [46, 65, 80],  // Feb 15
-          [60, 40, 75],  // Mar 1
-          [74, 35, 70],  // Mar 15
-        ]
-      }
-    ]
-
-    const result = getMonthlySnowCover(input)
-
-    expect(result).toHaveLength(1)
-    expect(result[0].year).toBe(2023)
-    expect(result[0].months).toHaveLength(3)
-
-    // January: (80*95 + 75*90) / (95 + 90) = (7600 + 6750) / 185 = 77.57
-    expect(result[0].months[0][0]).toBe(1) // Month
-    expect(result[0].months[0][1]).toBeCloseTo(77.57, 1) // Snow cover
-    expect(result[0].months[0][2]).toBe(92.5) // Valid pixels average
-
-    // February: (60*85 + 65*80) / (85 + 80) = (5100 + 5200) / 165 = 62.42
-    expect(result[0].months[1][0]).toBe(2)
-    expect(result[0].months[1][1]).toBeCloseTo(62.42, 1)
-    expect(result[0].months[1][2]).toBe(82.5)
-
-    // March: (40*75 + 35*70) / (75 + 70) = (3000 + 2450) / 145 = 37.59
-    expect(result[0].months[2][0]).toBe(3)
-    expect(result[0].months[2][1]).toBeCloseTo(37.59, 1)
-    expect(result[0].months[2][2]).toBe(72.5)
-  })
-
-  it('should handle multiple years', () => {
-    const input: SnowCoverHistory = [
-      {
-        year: 2022,
-        days: [[1, 50, 80]]
-      },
-      {
-        year: 2023,
-        days: [[1, 60, 90]]
-      }
-    ]
-
-    const result = getMonthlySnowCover(input)
-
-    expect(result).toHaveLength(2)
-    expect(result[0].year).toBe(2022)
-    expect(result[1].year).toBe(2023)
-  })
-
-  it('should handle empty data', () => {
-    const input: SnowCoverHistory = []
-    const result = getMonthlySnowCover(input)
-    expect(result).toEqual([])
-  })
-
-  it('should handle zero valid pixels gracefully', () => {
-    const input: SnowCoverHistory = [
-      {
-        year: 2023,
-        days: [
-          [1, 80, 0],   // No valid pixels
-          [15, 75, 100] // Full valid pixels
-        ]
-      }
-    ]
-
-    const result = getMonthlySnowCover(input)
-
-    expect(result[0].months[0][0]).toBe(1)
-    expect(result[0].months[0][1]).toBe(75) // Only the second day contributes
-    expect(result[0].months[0][2]).toBe(50) // Average of 0 and 100
-  })
-
-  it('should handle data across multiple months', () => {
-    const input: SnowCoverHistory = [
-      {
-        year: 2023,
-        days: [
-          [1, 80, 90],   // January
-          [100, 40, 70], // April (day 100)
-          [335, 50, 80]  // December (day 335)
-        ]
-      }
-    ]
-
-    const result = getMonthlySnowCover(input)
-
-    expect(result[0].months).toHaveLength(3)
-    expect(result[0].months[0][0]).toBe(1)  // January
-    expect(result[0].months[1][0]).toBe(4)  // April  
-    expect(result[0].months[2][0]).toBe(12) // December
-  })
-})

package/src/SnowCoverHistory.ts

@@ -1,107 +0,0 @@
-/**
- * Historical snow cover information for a geometry.
- * Data is organized chronologically, with the oldest year first.
- * 
- * @property {number} year - The year for this data
- * @property {Array<[number, number, number]>} days - Daily measurements as tuples of [day of year, NDSI snow cover value, % of valid pixels]
- */
-export type SnowCoverHistory = {
-  year: number
-  /**
-   * Array of daily snow cover measurements ordered chronologically by day of year.
-   * Each tuple contains:
-   * - Day of year (1-365/366)
-   * - NDSI snow cover value (0-100) - measures snow presence, not depth
-   * - Percentage of valid pixels (0-100) - pixels with valid data for that day
-   * 
-   * Data source: VIIRS/NPP CGF Snow Cover Daily L3 Global 375m product (VNP10A1F)
-   * Resolution: 375m (affects measurement accuracy for small geometries)
-   * Frequency: Weekly under cloud-free conditions, varies in practice
-   * 
-   * Valid pixel percentage may be less than 100% due to:
-   * - Cloud cover
-   * - Different cloud gap filling dates for pixels
-   * - Incomplete pipeline data
-   */
-  days: [number, number, number][]
-}[]
-
-/**
- * Monthly aggregated snow cover history.
- * Data is organized chronologically, with the oldest year first.
- * 
- * @property {number} year - The year for this data
- * @property {Array<[number, number, number]>} months - Monthly aggregations as tuples of [month, average snow cover, average valid pixels]
- */
-export type MonthlySnowCoverHistory = {
-  year: number
-  /**
-   * Array of monthly snow cover aggregations ordered chronologically by month.
-   * Each tuple contains:
-   * - Month (1-12)
-   * - Average NDSI snow cover value (0-100) - weighted by valid pixels
-   * - Average percentage of valid pixels (0-100) - across all days in month
-   */
-  months: [number, number, number][]
-}[]
-
-/**
- * Converts daily snow cover measurements to monthly aggregations.
- * 
- * Snow cover values are weighted by valid pixel percentages when calculating monthly averages.
- * Input data is assumed to be sorted chronologically.
- * 
- * @param snowCoverHistory Daily snow cover history to aggregate
- * @returns Monthly aggregated snow cover history
- */
-export function getMonthlySnowCover(
-  snowCoverHistory: SnowCoverHistory
-): MonthlySnowCoverHistory {
-  return snowCoverHistory.map(yearData => {
-    const monthlyData = new Map<number, { values: number[], validPixels: number[], count: number }>()
-    
-    // Group daily data by month
-    yearData.days.forEach(([dayOfYear, snowCover, validPixelPercent]) => {
-      const date = dayOfYearToDate(yearData.year, dayOfYear)
-      const month = date.getMonth() + 1 // Convert to 1-12
-      
-      if (!monthlyData.has(month)) {
-        monthlyData.set(month, { values: [], validPixels: [], count: 0 })
-      }
-      
-      const monthData = monthlyData.get(month)!
-      monthData.values.push(snowCover * validPixelPercent / 100) // Weight by valid pixels
-      monthData.validPixels.push(validPixelPercent)
-      monthData.count++
-    })
-    
-    // Calculate monthly averages
-    const months: [number, number, number][] = []
-    monthlyData.forEach((data, month) => {
-      const totalValidPixels = data.validPixels.reduce((sum, val) => sum + val, 0)
-      const weightedSnowCover = data.values.reduce((sum, val) => sum + val, 0)
-      const avgValidPixels = totalValidPixels / data.count
-      const avgSnowCover = avgValidPixels > 0 ? (weightedSnowCover / totalValidPixels) * 100 : 0
-      
-      months.push([month, Math.round(avgSnowCover * 100) / 100, Math.round(avgValidPixels * 100) / 100])
-    })
-    
-    return {
-      year: yearData.year,
-      months
-    }
-  })
-}
-
-/**
- * Converts day of year to a Date object.
- * 
- * @param year The year
- * @param dayOfYear Day of year (1-365/366)
- * @returns Date object for the specified day
- */
-function dayOfYearToDate(year: number, dayOfYear: number): Date {
-  const date = new Date(year, 0, 1)
-  date.setDate(dayOfYear)
-  return date
-}

package/src/Source.test.ts

@@ -1,50 +0,0 @@
-import {
-  getSourceName,
-  getSourceURL,
-  getStormSkiingChartCSVURL,
-  SourceType,
-} from './Source'
-
-describe('getSourceURL', () => {
-  it('links to an OpenStreetMap element', () => {
-    expect(
-      getSourceURL({ type: SourceType.OPENSTREETMAP, id: 'relation/5883752' }),
-    ).toBe('https://www.openstreetmap.org/relation/5883752')
-  })
-
-  it('links to a Skimap.org ski area', () => {
-    expect(getSourceURL({ type: SourceType.SKIMAP_ORG, id: '181' })).toBe(
-      'https://www.skimap.org/SkiAreas/view/181',
-    )
-  })
-
-  it('links to a cell of the ski pass chart', () => {
-    expect(
-      getSourceURL({ type: SourceType.STORM_SKIING, id: '677843907!AI64' }),
-    ).toBe(
-      'https://docs.google.com/spreadsheets/d/1G2-l2DVg7-QwroOi7EqRDrJYJ4ICYLcJbLx-nARJdrA/edit?gid=677843907#gid=677843907&range=AI64',
-    )
-  })
-
-  it('rejects a ski pass chart id without a sheet', () => {
-    expect(() =>
-      getSourceURL({ type: SourceType.STORM_SKIING, id: 'AI64' }),
-    ).toThrow('Malformed stormskiing.com source id')
-  })
-})
-
-describe('getSourceName', () => {
-  it('names every source type', () => {
-    for (const type of Object.values(SourceType)) {
-      expect(getSourceName(type).length).toBeGreaterThan(0)
-    }
-  })
-})
-
-describe('getStormSkiingChartCSVURL', () => {
-  it('builds the CSV export URL for a sheet', () => {
-    expect(getStormSkiingChartCSVURL('677843907')).toBe(
-      'https://docs.google.com/spreadsheets/d/1G2-l2DVg7-QwroOi7EqRDrJYJ4ICYLcJbLx-nARJdrA/export?format=csv&gid=677843907',
-    )
-  })
-})

package/src/Source.ts

@@ -1,72 +0,0 @@
-import { exhaustiveMatchingGuard } from './util/exhaustiveMatchingGuard'
-
-export enum SourceType {
-  SKIMAP_ORG = 'skimap.org',
-  OPENSTREETMAP = 'openstreetmap',
-  STORM_SKIING = 'stormskiing.com',
-}
-
-export type Source = {
-  type: SourceType
-  id: string
-}
-
-/**
- * The Storm Skiing Journal's ski pass chart, a Google Sheets document.
- *
- * A `STORM_SKIING` source id references a single cell of that document, in `<gid>!<A1>` form
- * (e.g. `677843907!AI64`), so it can be linked to directly.
- */
-export const STORM_SKIING_CHART_DOCUMENT_ID =
-  '1G2-l2DVg7-QwroOi7EqRDrJYJ4ICYLcJbLx-nARJdrA'
-
-/**
- * URL of the CSV export of one sheet of the ski pass chart. Used to fetch the chart; the ids of
- * the sources derived from it are resolved by `getSourceURL`.
- */
-export function getStormSkiingChartCSVURL(gid: string): string {
-  return (
-    `https://docs.google.com/spreadsheets/d/${STORM_SKIING_CHART_DOCUMENT_ID}` +
-    `/export?format=csv&gid=${gid}`
-  )
-}
-
-export function getSourceURL(source: Source): string {
-  switch (source.type) {
-    case SourceType.OPENSTREETMAP:
-      return 'https://www.openstreetmap.org/' + source.id
-    case SourceType.SKIMAP_ORG:
-      return 'https://www.skimap.org/SkiAreas/view/' + source.id
-    case SourceType.STORM_SKIING: {
-      const separatorIndex = source.id.indexOf('!')
-      if (separatorIndex === -1) {
-        throw new Error(
-          `Malformed ${SourceType.STORM_SKIING} source id "${source.id}". Expected <gid>!<A1 reference>.`,
-        )
-      }
-      const gid = source.id.slice(0, separatorIndex)
-      const range = source.id.slice(separatorIndex + 1)
-      // The gid appears twice: as a query parameter to select the sheet, and in the fragment,
-      // which is the only place Google Sheets accepts a cell range.
-      return (
-        `https://docs.google.com/spreadsheets/d/${STORM_SKIING_CHART_DOCUMENT_ID}` +
-        `/edit?gid=${gid}#gid=${gid}&range=${range}`
-      )
-    }
-    default:
-      return exhaustiveMatchingGuard(source.type)
-  }
-}
-
-export function getSourceName(type: SourceType): string {
-  switch (type) {
-    case SourceType.OPENSTREETMAP:
-      return 'OpenStreetMap'
-    case SourceType.SKIMAP_ORG:
-      return 'Skimap.org'
-    case SourceType.STORM_SKIING:
-      return 'The Storm Skiing Journal'
-    default:
-      return exhaustiveMatchingGuard(type)
-  }
-}