@speleotica/frcsdata 4.3.1 → 5.0.0-beta.1

package/src/survey/ZodFrcsSurveyFileToJson.ts

@@ -0,0 +1,297 @@
+import { Angle, Length, Unit, UnitizedNumber } from '@speleotica/unitized'
+import z from 'zod'
+import type { DeepMapJson, JsonAngle, JsonLength } from './FrcsSurveyFileJson'
+import type { SourceLoc } from '../SourceLoc'
+import type {
+  FrcsShot,
+  FrcsSurveyFile,
+  FrcsTrip,
+  FrcsTripHeader,
+  FrcsUnits,
+  InvalidFrcsShot,
+  InvalidFrcsSurveyFile,
+  InvalidFrcsTrip,
+  InvalidFrcsTripHeader,
+  InvalidFrcsUnits,
+} from './FrcsSurveyFile'
+import { ParseIssue } from '../ParseIssue'
+
+type DeepMapJsonSchema<T> = z.ZodType<DeepMapJson<T>, any, T>
+
+const ZodLengthUnit = z
+  .instanceof<typeof Unit<Length>>(Unit)
+  .transform((unit) => {
+    switch (unit) {
+      case Length.meters:
+        return 'm'
+      case Length.kilometers:
+        return 'km'
+      case Length.centimeters:
+        return 'cm'
+      case Length.feet:
+        return 'ft'
+      case Length.inches:
+        return 'in'
+      case Length.yards:
+        return 'yd'
+      case Length.miles:
+        return 'mi'
+    }
+    throw new Error('invalid unit')
+  })
+
+ZodLengthUnit satisfies DeepMapJsonSchema<Unit<Length>>
+
+const ZodAngleUnit = z
+  .instanceof<typeof Unit<Angle>>(Unit)
+  .transform((unit) => {
+    switch (unit) {
+      case Angle.degrees:
+        return 'deg'
+      case Angle.radians:
+        return 'rad'
+      case Angle.gradians:
+        return 'grad'
+      case Angle.milsNATO:
+        return 'mil'
+      case Angle.percentGrade:
+        return '%'
+    }
+    throw new Error('invalid unit')
+  })
+
+ZodAngleUnit satisfies DeepMapJsonSchema<Unit<Angle>>
+
+const ZodLength = z
+  .instanceof<typeof UnitizedNumber<Length>>(UnitizedNumber)
+  .transform(
+    (length) =>
+      [
+        length.get(length.unit),
+        ZodLengthUnit.parse(length.unit),
+      ] satisfies JsonLength
+  )
+
+ZodLength satisfies DeepMapJsonSchema<UnitizedNumber<Length>>
+
+const ZodAngle = z
+  .instanceof<typeof UnitizedNumber<Angle>>(UnitizedNumber)
+  .transform(
+    (angle) =>
+      [
+        angle.get(angle.unit),
+        ZodAngleUnit.parse(angle.unit),
+      ] satisfies JsonAngle
+  )
+
+ZodAngle satisfies DeepMapJsonSchema<UnitizedNumber<Angle>>
+
+const ZodSourceLoc = z.strictObject({
+  start: z.strictObject({
+    index: z.number(),
+    line: z.number(),
+    column: z.number(),
+  }),
+  end: z.strictObject({
+    index: z.number(),
+    line: z.number(),
+    column: z.number(),
+  }),
+})
+
+ZodSourceLoc satisfies DeepMapJsonSchema<SourceLoc>
+
+const ZodFrcsShotBase = z.strictObject({
+  from: z.string(),
+  to: z.string().optional(),
+  specialKind: z.enum(['horizontal', 'diagonal']).optional(),
+  distance: ZodLength,
+  horizontalDistance: ZodLength.optional(),
+  verticalDistance: ZodLength.optional(),
+  frontsightAzimuth: ZodAngle.optional(),
+  frontsightInclination: ZodAngle.optional(),
+  backsightAzimuth: ZodAngle.optional(),
+  backsightInclination: ZodAngle.optional(),
+  /**
+   * LRUDs at from station
+   */
+  fromLruds: z
+    .strictObject({
+      left: ZodLength.optional(),
+      right: ZodLength.optional(),
+      up: ZodLength.optional(),
+      down: ZodLength.optional(),
+    })
+    .optional(),
+  /**
+   * LRUDs at to station
+   */
+  toLruds: z
+    .strictObject({
+      left: ZodLength.optional(),
+      right: ZodLength.optional(),
+      up: ZodLength.optional(),
+      down: ZodLength.optional(),
+    })
+    .optional(),
+
+  excludeDistance: z
+    .boolean()
+    .optional()
+    .transform((b) => b || undefined),
+  isSplay: z
+    .boolean()
+    .optional()
+    .transform((b) => b || undefined),
+  comment: z.string().optional(),
+  loc: ZodSourceLoc.optional(),
+  locs: z
+    .strictObject({
+      comment: ZodSourceLoc.optional(),
+    })
+    .optional(),
+})
+
+const ZodFrcsUnits = z.strictObject({
+  distanceUnit: ZodLengthUnit,
+  azimuthUnit: ZodAngleUnit,
+  inclinationUnit: ZodAngleUnit,
+  backsightAzimuthCorrected: z.boolean().optional(),
+  backsightInclinationCorrected: z.boolean().optional(),
+  hasBacksightAzimuth: z.boolean().optional(),
+  hasBacksightInclination: z.boolean().optional(),
+  loc: ZodSourceLoc.optional(),
+  locs: z
+    .strictObject({
+      distanceUnit: ZodSourceLoc.optional(),
+      azimuthUnit: ZodSourceLoc.optional(),
+      inclinationUnit: ZodSourceLoc.optional(),
+      backsightAzimuthCorrected: ZodSourceLoc.optional(),
+      backsightInclinationCorrected: ZodSourceLoc.optional(),
+      hasBacksightAzimuth: ZodSourceLoc.optional(),
+      hasBacksightInclination: ZodSourceLoc.optional(),
+    })
+    .optional(),
+})
+
+ZodFrcsUnits satisfies DeepMapJsonSchema<FrcsUnits>
+
+const ZodFrcsShot = ZodFrcsShotBase.extend({
+  recorded: ZodFrcsShotBase.extend({
+    units: ZodFrcsUnits.optional(),
+  }).optional(),
+})
+
+ZodFrcsShot satisfies DeepMapJsonSchema<FrcsShot>
+
+const ZodDate = z.date().transform((d) => d.toISOString().substring(0, 10))
+
+const ZodFrcsTripHeader = z.strictObject({
+  name: z.string(),
+  comment: z.string().optional(),
+  section: z.string().optional(),
+  date: ZodDate.optional(),
+  team: z.array(z.string()).optional(),
+  loc: ZodSourceLoc.optional(),
+  locs: z
+    .strictObject({
+      name: ZodSourceLoc,
+      comment: ZodSourceLoc.optional(),
+      section: ZodSourceLoc.optional(),
+      date: ZodSourceLoc.optional(),
+      team: z.array(ZodSourceLoc).optional(),
+    })
+    .optional(),
+})
+
+ZodFrcsTripHeader satisfies DeepMapJsonSchema<FrcsTripHeader>
+
+const ZodFrcsTrip = z.strictObject({
+  tripNumber: z.number().int().min(1),
+  header: ZodFrcsTripHeader,
+  units: ZodFrcsUnits,
+  shots: z.array(ZodFrcsShot),
+  loc: ZodSourceLoc.optional(),
+})
+
+ZodFrcsTrip satisfies DeepMapJsonSchema<FrcsTrip>
+
+export const ZodFrcsSurveyFileToJson = z.strictObject({
+  cave: z.string().optional(),
+  columns: z
+    .strictObject({
+      toStation: z.number(),
+      fromStation: z.number(),
+      distance: z.number(),
+      distanceFeet: z.number(),
+      distanceInches: z.number(),
+      kind: z.number(),
+      exclude: z.number(),
+      frontsightAzimuth: z.number(),
+      backsightAzimuth: z.number(),
+      frontsightInclination: z.number(),
+      backsightInclination: z.number(),
+      left: z.number(),
+      right: z.number(),
+      up: z.number(),
+      down: z.number(),
+    })
+    .optional(),
+  location: z.string().optional(),
+  comment: z.string().optional(),
+  trips: z.array(ZodFrcsTrip),
+  locs: z
+    .strictObject({
+      cave: ZodSourceLoc.optional(),
+      location: ZodSourceLoc.optional(),
+      comment: ZodSourceLoc.optional(),
+    })
+    .optional(),
+  issues: z.array(ParseIssue).optional(),
+})
+
+ZodFrcsSurveyFileToJson satisfies DeepMapJsonSchema<FrcsSurveyFile>
+
+function Invalid<T extends z.ZodTypeAny>(schema: T) {
+  return z.strictObject({
+    INVALID: schema,
+    issues: z.array(z.number()).optional(),
+  })
+}
+
+const ZodInvalidFrcsShot = Invalid(ZodFrcsShot.partial())
+
+ZodInvalidFrcsShot satisfies DeepMapJsonSchema<InvalidFrcsShot>
+
+const ZodInvalidFrcsUnits = Invalid(ZodFrcsUnits.partial())
+
+ZodInvalidFrcsUnits satisfies DeepMapJsonSchema<InvalidFrcsUnits>
+
+const ZodInvalidFrcsTripHeader = Invalid(ZodFrcsTripHeader.partial())
+
+ZodInvalidFrcsTripHeader satisfies DeepMapJsonSchema<InvalidFrcsTripHeader>
+
+const ZodInvalidFrcsTrip = Invalid(
+  z.strictObject({
+    tripNumber: z.number().int().min(1).optional(),
+    header: z.union([ZodInvalidFrcsTripHeader, ZodFrcsTripHeader]),
+    units: z.union([ZodInvalidFrcsUnits, ZodFrcsUnits]),
+    shots: z.array(z.union([ZodInvalidFrcsShot, ZodFrcsShot])),
+  })
+)
+
+ZodInvalidFrcsTrip satisfies DeepMapJsonSchema<InvalidFrcsTrip>
+
+export const ZodInvalidFrcsSurveyFileToJson = z.strictObject({
+  INVALID: ZodFrcsSurveyFileToJson.extend({
+    trips: z.array(z.union([ZodInvalidFrcsTrip, ZodFrcsTrip])),
+  }),
+  issues: z.array(ParseIssue),
+})
+
+ZodInvalidFrcsSurveyFileToJson satisfies DeepMapJsonSchema<InvalidFrcsSurveyFile>
+
+export const ZodValidOrInvalidFrcsSurveyFileToJson = z.union([
+  ZodInvalidFrcsSurveyFileToJson,
+  ZodFrcsSurveyFileToJson,
+])

package/src/{formatFrcsShot.ts → survey/formatFrcsShot.ts}

@@ -1,8 +1,7 @@
-import { FrcsUnits } from './FrcsTrip'
-import { FrcsShot, FrcsShotKind } from './FrcsShot'
+import type { FrcsUnits, FrcsShot } from './FrcsSurveyFile'
 import { Length, Unit, UnitType, UnitizedNumber } from '@speleotica/unitized'
 import {
-  FrcsShotColumnConfig,
+  type FrcsShotColumnConfig,
   defaultFrcsShotColumnConfig,
 } from './FrcsSurveyFile'
 
@@ -24,6 +23,16 @@ export function makeFormatFrcsShot({
     return station.padStart(columns.toStation, ' ')
   }
 
+  function formatSpecialKind(specialKind: FrcsShot['specialKind']): string {
+    switch (specialKind) {
+      case 'diagonal':
+        return 'D'
+      case 'horizontal':
+        return 'H'
+    }
+    return ' '
+  }
+
   function trimZeroes(str: string): string {
     const match = /(-?\d+)(\.[1-9]*)0+$/.exec(str)
     if (!match) return str
@@ -46,11 +55,13 @@ export function makeFormatFrcsShot({
         return formatNum(num.get(verbatim ? num.unit : unit || num.unit))
       }
       if (num == null || !Number.isFinite(num)) return ' '.repeat(width)
-      const precision = Math.max(0, width - String(Math.trunc(num)).length - 1)
-      const formatted = trimZeroes(num.toFixed(precision))
-      return formatted.length <= width
-        ? formatted.padStart(width, ' ')
-        : formatted.substring(0, width)
+      const formatted = trimZeroes(num.toFixed(2))
+      if (formatted.length <= width) return formatted.padStart(width, ' ')
+      if (formatted.length > width + 2) return formatted.substring(0, width)
+      return trimZeroes(num.toFixed(2 - formatted.length + width)).padStart(
+        width,
+        ' '
+      )
     }
     return formatNum
   }
@@ -125,7 +136,7 @@ export function makeFormatFrcsShot({
     }
 
     const distColumnValue =
-      shot.kind === FrcsShotKind.Horizontal
+      shot.specialKind === 'horizontal'
         ? shot.horizontalDistance
         : shot.distance
 
@@ -135,28 +146,34 @@ export function makeFormatFrcsShot({
       inches
         ? formatFeet(distColumnValue)
         : formatDistance(distColumnValue, distanceUnit, isRecorded),
-      inches ? formatInches(distColumnValue) : shot.kind,
-      inches ? shot.kind : shot.excludeDistance ? '*' : ' ',
+      inches
+        ? formatInches(distColumnValue)
+        : formatSpecialKind(shot.specialKind),
+      inches
+        ? formatSpecialKind(shot.specialKind)
+        : shot.excludeDistance
+        ? '*'
+        : ' ',
       formatFsAzimuth(shot.frontsightAzimuth, azimuthUnit, isRecorded),
       formatBsAzimuth(shot.backsightAzimuth, azimuthUnit, isRecorded),
-      shot.kind === FrcsShotKind.Normal
-        ? formatFsInclination(
-            shot.frontsightInclination,
-            inclinationUnit,
-            isRecorded
-          )
-        : formatVerticalDistance(
+      shot.specialKind
+        ? formatVerticalDistance(
             shot.verticalDistance,
             distanceUnit,
             isRecorded
+          )
+        : formatFsInclination(
+            shot.frontsightInclination,
+            inclinationUnit,
+            isRecorded
           ),
-      shot.kind === FrcsShotKind.Normal
-        ? formatBsInclination(
+      shot.specialKind
+        ? EMPTY_BS_INCLINATION
+        : formatBsInclination(
             shot.backsightInclination,
             inclinationUnit,
             isRecorded
-          )
-        : EMPTY_BS_INCLINATION,
+          ),
       formatLeft(shot.toLruds?.left, distanceUnit, isRecorded),
       formatRight(shot.toLruds?.right, distanceUnit, isRecorded),
       formatUp(shot.toLruds?.up, distanceUnit, isRecorded),

package/src/{formatFrcsSurveyFile.ts → survey/formatFrcsSurveyFile.ts}

@@ -1,6 +1,5 @@
 import { Angle, Length, Unit } from '@speleotica/unitized'
-import { FrcsSurveyFile } from './FrcsSurveyFile'
-import { FrcsUnits } from './FrcsTrip'
+import type { FrcsSurveyFile, FrcsUnits } from './FrcsSurveyFile'
 import { makeFormatFrcsShot } from './formatFrcsShot'
 
 export async function* formatFrcsSurveyFile(
@@ -12,7 +11,7 @@ export async function* formatFrcsSurveyFile(
   }
   for (let tripIndex = 0; tripIndex < file.trips.length; tripIndex++) {
     const trip = file.trips[tripIndex]
-    const { shots, header } = trip
+    const { shots, header, units } = trip
     const { name, team, date, comment } = header
     if (tripIndex > 0) yield ' *\n'
     yield name.replace(/\n?$/, '\n')
@@ -23,7 +22,7 @@ export async function* formatFrcsSurveyFile(
     if (line2) yield `${line2}\n`
     if (comment) yield comment.replace(/\n?$/, '\n')
     yield ' *\n'
-    yield formatUnits(header)
+    yield formatUnits(units)
 
     let alternateUnits: FrcsUnits | undefined
 
@@ -44,7 +43,7 @@ export async function* formatFrcsSurveyFile(
       }
       yield formatFrcsShot(
         shot.recorded || shot,
-        alternateUnits || header
+        alternateUnits || units
       ).replace(/\n?$/, '\n')
     }
   }

package/src/survey/getColumnRanges.ts

@@ -0,0 +1,82 @@
+import type { FrcsShotColumnConfig } from './FrcsSurveyFile'
+
+type ColumnRanges = {
+  toStation: [number, number]
+  fromStation: [number, number]
+  distance: [number, number]
+  distanceFeet: [number, number]
+  distanceInches: [number, number]
+  kind: [number, number]
+  exclude: [number, number]
+  frontsightAzimuth: [number, number]
+  backsightAzimuth: [number, number]
+  frontsightInclination: [number, number]
+  backsightInclination: [number, number]
+  left: [number, number]
+  right: [number, number]
+  up: [number, number]
+  down: [number, number]
+}
+
+export function getColumnRanges(config: FrcsShotColumnConfig): {
+  decimal: ColumnRanges
+  feetAndInches: ColumnRanges
+} {
+  const decimal: ColumnRanges = {
+    toStation: [0, 0],
+    fromStation: [0, 0],
+    distance: [0, 0],
+    distanceFeet: [0, 0],
+    distanceInches: [0, 0],
+    kind: [0, 0],
+    exclude: [0, 0],
+    frontsightAzimuth: [0, 0],
+    backsightAzimuth: [0, 0],
+    frontsightInclination: [0, 0],
+    backsightInclination: [0, 0],
+    left: [0, 0],
+    right: [0, 0],
+    up: [0, 0],
+    down: [0, 0],
+  }
+  const feetAndInches: ColumnRanges = {
+    toStation: [0, 0],
+    fromStation: [0, 0],
+    distance: [0, 0],
+    distanceFeet: [0, 0],
+    distanceInches: [0, 0],
+    kind: [0, 0],
+    exclude: [0, 0],
+    frontsightAzimuth: [0, 0],
+    backsightAzimuth: [0, 0],
+    frontsightInclination: [0, 0],
+    backsightInclination: [0, 0],
+    left: [0, 0],
+    right: [0, 0],
+    up: [0, 0],
+    down: [0, 0],
+  }
+
+  let c = 0
+  for (const [key, value] of Object.entries(config) as [
+    keyof FrcsShotColumnConfig,
+    FrcsShotColumnConfig[keyof FrcsShotColumnConfig]
+  ][]) {
+    if (key === 'distanceFeet' || key === 'distanceInches') continue
+    decimal[key][0] = c
+    decimal[key][1] = c + value
+    c += value
+  }
+  c = 0
+  for (const [key, value] of Object.entries(config) as [
+    keyof FrcsShotColumnConfig,
+    FrcsShotColumnConfig[keyof FrcsShotColumnConfig]
+  ][]) {
+    if (key === 'distance') continue
+    const width = key === 'frontsightAzimuth' ? value - 1 : value
+    feetAndInches[key][0] = c
+    feetAndInches[key][1] = c + width
+    c += width
+  }
+  return { decimal, feetAndInches }
+}

package/src/survey/normalizeTeamMemberName.ts

@@ -0,0 +1,10 @@
+export function normalizeTeamMemberName(name: string) {
+  if (name.toUpperCase() === name) {
+    name = name.replace(
+      /(\S)(\S*)/g,
+      (match, head, tail) => `${head}${tail.toLowerCase()}`
+    )
+  }
+  name = name.replace(/_/g, ' ')
+  return name
+}