@kaiord/zwo 4.7.2 → 7.0.0

package/dist/browser.d.ts

@@ -1,6 +1,6 @@
 import { Logger, TextReader, TextWriter } from '@kaiord/core';
-import { Z as ZwiftValidator } from './fast-xml-parser-YgKah3Fp.js';
-export { d as ZwiftValidationError, b as ZwiftValidationResult, c as createFastXmlZwiftReader, a as createFastXmlZwiftWriter } from './fast-xml-parser-YgKah3Fp.js';
+import { Z as ZwiftValidator } from './fast-xml-parser-otyxjhMa.js';
+export { a as ZwiftValidationError, b as ZwiftValidationResult, c as createFastXmlZwiftReader, d as createFastXmlZwiftWriter } from './fast-xml-parser-otyxjhMa.js';
 
 /**
  * Creates a Zwift validator for browser environments.

package/dist/browser.js

@@ -1,4 +1,4 @@
-import { createConsoleLogger, createZwiftParsingError, createZwiftValidationError, intensitySchema, targetTypeSchema, targetUnitSchema, durationTypeSchema } from '@kaiord/core';
+import { createConsoleLogger, createZwiftParsingError, createZwiftValidationError, targetTypeSchema, targetUnitSchema, intensitySchema, durationTypeSchema } from '@kaiord/core';
 import { XMLParser, XMLValidator, XMLBuilder } from 'fast-xml-parser';
 
 // src/browser.ts
@@ -79,24 +79,26 @@ var encodePowerTargets = (onStep, offStep, intervalsT) => {
     intervalsT["@_OffPower"] = offStep.target.value.value / 100;
   }
 };
-var encodeCadenceTargets = (onStep, offStep, intervalsT) => {
-  if (onStep.target.type === "cadence" && onStep.target.value.unit === "rpm") {
-    intervalsT["@_Cadence"] = onStep.target.value.value;
-  } else {
-    const onStepExtensions = onStep.extensions?.zwift;
-    const cadence = onStepExtensions?.cadence;
-    if (cadence !== void 0) {
-      intervalsT["@_Cadence"] = cadence;
+var resolveStepCadence = (step) => {
+  if (step.target.type === "cadence") {
+    const val = step.target.value;
+    if (val.unit === "rpm") return val.value;
+    if (val.unit === "range" && val.min !== void 0 && val.max !== void 0) {
+      return Math.round((val.min + val.max) / 2);
     }
   }
-  if (offStep.target.type === "cadence" && offStep.target.value.unit === "rpm") {
-    intervalsT["@_CadenceResting"] = offStep.target.value.value;
-  } else {
-    const offStepExtensions = offStep.extensions?.zwift;
-    const cadenceResting = offStepExtensions?.cadence;
-    if (cadenceResting !== void 0) {
-      intervalsT["@_CadenceResting"] = cadenceResting;
-    }
+  const zwift = step.extensions ? step.extensions.zwift : void 0;
+  const ext = zwift;
+  return ext ? ext.cadence : void 0;
+};
+var encodeCadenceTargets = (onStep, offStep, intervalsT) => {
+  const cadence = resolveStepCadence(onStep);
+  if (cadence !== void 0) {
+    intervalsT["@_Cadence"] = cadence;
+  }
+  const cadenceResting = resolveStepCadence(offStep);
+  if (cadenceResting !== void 0) {
+    intervalsT["@_CadenceResting"] = cadenceResting;
   }
 };
 var encodeIntervalsT = (repetitionBlock) => {
@@ -201,6 +203,16 @@ var encodeMetadata = (step, interval) => {
     interval["@_kaiord:equipment"] = step.equipment;
   }
 };
+var convertZwiftCadenceTarget = (cadence, isRunning = false) => {
+  const rpm = isRunning ? cadence / 2 : cadence;
+  return {
+    type: targetTypeSchema.enum.cadence,
+    value: {
+      unit: "rpm",
+      value: rpm
+    }
+  };
+};
 var convertZwiftPowerTarget = (ftpPercentage) => {
   return {
     type: targetTypeSchema.enum.power,
@@ -232,16 +244,6 @@ var convertPowerZoneToPercentFtp = (zone) => {
   };
   return zoneMap[zone] || 100;
 };
-var convertZwiftCadenceTarget = (cadence, isRunning = false) => {
-  const rpm = isRunning ? cadence / 2 : cadence;
-  return {
-    type: targetTypeSchema.enum.cadence,
-    value: {
-      unit: "rpm",
-      value: rpm
-    }
-  };
-};
 
 // src/adapters/krd-to-zwift/power-encoder.ts
 var encodeSteadyStatePowerTarget = (step, interval) => {
@@ -425,7 +427,13 @@ var mapSportType = (sport) => {
 };
 
 // src/adapters/krd-to-zwift/workout-file-builder.ts
-var buildWorkoutFile = (workoutData, zwiftExtensions, metadata, fitExtensions, logger) => {
+var buildWorkoutFile = ({
+  workoutData,
+  zwiftExtensions,
+  metadata,
+  fitExtensions,
+  logger
+}) => {
   const workoutFile = {};
   addWorkoutProperties(workoutFile, workoutData.name, zwiftExtensions);
   workoutFile.sportType = mapSportType(workoutData.sport);
@@ -470,13 +478,13 @@ var convertKRDToZwift = (krd, logger) => {
   logger.debug("Building Zwift workout structure from KRD");
   const workoutData = extractWorkoutData(krd);
   const zwiftExtensions = krd.extensions?.zwift || {};
-  const workoutFile = buildWorkoutFile(
+  const workoutFile = buildWorkoutFile({
     workoutData,
     zwiftExtensions,
-    krd.metadata,
-    krd.extensions?.fit,
+    metadata: krd.metadata,
+    fitExtensions: krd.extensions?.fit,
     logger
-  );
+  });
   const xmlString = buildXmlString(workoutFile);
   logger.debug("Zwift XML structure built successfully");
   return xmlString;
@@ -552,25 +560,31 @@ var extractTags = (tags) => {
   const tagArray = Array.isArray(tags.tag) ? tags.tag : [tags.tag];
   return tagArray.map((t) => t["@_name"]);
 };
-var mapZwiftDuration = (data) => {
-  if (data["kaiord:originalDurationType"] === "distance") {
+var mapOriginalDurationType = (data) => {
+  const orig = data["kaiord:originalDurationType"];
+  if (orig === "distance") {
     return {
       type: durationTypeSchema.enum.distance,
       meters: data["kaiord:originalDurationMeters"] || data.Duration || 0
     };
   }
-  if (data["kaiord:originalDurationType"] === "heart_rate_less_than") {
+  if (orig === "heart_rate_less_than") {
     return {
       type: durationTypeSchema.enum.heart_rate_less_than,
       bpm: data["kaiord:originalDurationBpm"] || 0
     };
   }
-  if (data["kaiord:originalDurationType"] === "power_less_than") {
+  if (orig === "power_less_than") {
     return {
       type: durationTypeSchema.enum.power_less_than,
       watts: data["kaiord:originalDurationWatts"] || 0
     };
   }
+  return void 0;
+};
+var mapZwiftDuration = (data) => {
+  const original = mapOriginalDurationType(data);
+  if (original) return original;
   if (data.Duration === void 0 || data.Duration <= 0) {
     return { type: durationTypeSchema.enum.open };
   }