@zendir/ui 0.4.1 → 0.6.0

package/dist/react/charts/unified/generators.js

@@ -1,518 +1,581 @@
-const SPEED_OF_LIGHT = 299792458;
-const EARTH_RADIUS = 6371;
-const MU_EARTH = 398600.4418;
+//#region src/react/charts/unified/generators.ts
+var SPEED_OF_LIGHT = 299792458;
+var EARTH_RADIUS = 6371;
+var MU_EARTH = 398600.4418;
+/**
+* Generate realistic LEO satellite power system telemetry
+*
+* Models:
+* - Solar array power variation with orbit phase (cosine pointing loss)
+* - Eclipse periods with zero solar input
+* - Battery charge/discharge with 90% round-trip efficiency
+* - Load shedding during eclipse
+*/
 function generatePowerData(config = {}) {
-  const {
-    orbitPeriod = 5400,
-    eclipseDuration = 2100,
-    solarArrayPower = 85,
-    loadPower = 45,
-    batteryCapacity = 300,
-    initialSoC = 80,
-    eclipseLoadReduction = 0.7,
-    orbits = 2,
-    resolution = 60
-  } = config;
-  const data = [];
-  const totalDuration = orbitPeriod * orbits;
-  let batterySoC = initialSoC;
-  const batteryEfficiency = 0.9;
-  const eclipseStart = 0.4;
-  const eclipseEnd = eclipseStart + eclipseDuration / orbitPeriod;
-  for (let t = 0; t < totalDuration; t += resolution) {
-    const orbitPhase = t % orbitPeriod / orbitPeriod;
-    const inEclipse = orbitPhase >= eclipseStart && orbitPhase < eclipseEnd;
-    const pointingFactor = 0.9 + 0.1 * Math.sin(orbitPhase * Math.PI * 2);
-    const solarPower = inEclipse ? 0 : solarArrayPower * pointingFactor;
-    const consumption = inEclipse ? loadPower * eclipseLoadReduction : loadPower;
-    const netPower = solarPower - consumption;
-    const energyDelta = netPower * resolution / 3600;
-    const efficiencyFactor = netPower > 0 ? batteryEfficiency : 1 / batteryEfficiency;
-    batterySoC += energyDelta * efficiencyFactor / batteryCapacity * 100;
-    batterySoC = Math.max(0, Math.min(100, batterySoC));
-    data.push({
-      time: Date.now() + t * 1e3,
-      solarPower: Math.round(solarPower * 10) / 10,
-      consumption: Math.round(consumption * 10) / 10,
-      netPower: Math.round(netPower * 10) / 10,
-      batteryPercent: Math.round(batterySoC * 10) / 10,
-      eclipse: inEclipse
-    });
-  }
-  return data;
+	const { orbitPeriod = 5400, eclipseDuration = 2100, solarArrayPower = 85, loadPower = 45, batteryCapacity = 300, initialSoC = 80, eclipseLoadReduction = .7, orbits = 2, resolution = 60 } = config;
+	const data = [];
+	const totalDuration = orbitPeriod * orbits;
+	let batterySoC = initialSoC;
+	const batteryEfficiency = .9;
+	const eclipseStart = .4;
+	const eclipseEnd = eclipseStart + eclipseDuration / orbitPeriod;
+	for (let t = 0; t < totalDuration; t += resolution) {
+		const orbitPhase = t % orbitPeriod / orbitPeriod;
+		const inEclipse = orbitPhase >= eclipseStart && orbitPhase < eclipseEnd;
+		const pointingFactor = .9 + .1 * Math.sin(orbitPhase * Math.PI * 2);
+		const solarPower = inEclipse ? 0 : solarArrayPower * pointingFactor;
+		const consumption = inEclipse ? loadPower * eclipseLoadReduction : loadPower;
+		const netPower = solarPower - consumption;
+		const energyDelta = netPower * resolution / 3600;
+		batterySoC += energyDelta * (netPower > 0 ? batteryEfficiency : 1 / batteryEfficiency) / batteryCapacity * 100;
+		batterySoC = Math.max(0, Math.min(100, batterySoC));
+		data.push({
+			time: Date.now() + t * 1e3,
+			solarPower: Math.round(solarPower * 10) / 10,
+			consumption: Math.round(consumption * 10) / 10,
+			netPower: Math.round(netPower * 10) / 10,
+			batteryPercent: Math.round(batterySoC * 10) / 10,
+			eclipse: inEclipse
+		});
+	}
+	return data;
 }
+/**
+* Generate realistic spacecraft attitude telemetry
+*
+* Models:
+* - Slew maneuver with trapezoidal velocity profile
+* - Fine pointing settling with exponential decay
+* - Random jitter (Gaussian distribution)
+* - Angular velocity from finite differences
+*/
 function generateAttitudeData(config = {}) {
-  const {
-    initialAttitude = [0, -45, 90],
-    targetAttitude = [0, 30, 180],
-    slewRate = 0.5,
-    settleTime = 30,
-    jitter = 0.02,
-    samplingRate = 1,
-    duration = 300
-  } = config;
-  const data = [];
-  const dt = 1 / samplingRate;
-  const deltaAttitude = targetAttitude.map((t, i) => t - initialAttitude[i]);
-  const totalAngle = Math.sqrt(deltaAttitude.reduce((sum, d) => sum + d * d, 0));
-  const slewDuration = totalAngle / slewRate;
-  deltaAttitude.map((d) => d / totalAngle);
-  const gaussRandom = () => {
-    const u1 = Math.random();
-    const u2 = Math.random();
-    return Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
-  };
-  let prevRoll = initialAttitude[0];
-  let prevPitch = initialAttitude[1];
-  let prevYaw = initialAttitude[2];
-  for (let t = 0; t < duration; t += dt) {
-    let roll, pitch, yaw;
-    let pointingError;
-    if (t < slewDuration) {
-      const progress = t / slewDuration;
-      const smoothProgress = 0.5 - 0.5 * Math.cos(progress * Math.PI);
-      roll = initialAttitude[0] + deltaAttitude[0] * smoothProgress;
-      pitch = initialAttitude[1] + deltaAttitude[1] * smoothProgress;
-      yaw = initialAttitude[2] + deltaAttitude[2] * smoothProgress;
-      pointingError = totalAngle * (1 - progress);
-    } else if (t < slewDuration + settleTime) {
-      const settleProgress = (t - slewDuration) / settleTime;
-      const decayFactor = Math.exp(-3 * settleProgress);
-      const overshoot = 0.05 * Math.sin(settleProgress * Math.PI * 4) * decayFactor;
-      roll = targetAttitude[0] + overshoot + jitter * gaussRandom();
-      pitch = targetAttitude[1] + overshoot + jitter * gaussRandom();
-      yaw = targetAttitude[2] + overshoot + jitter * gaussRandom();
-      pointingError = Math.abs(overshoot) + jitter * Math.abs(gaussRandom());
-    } else {
-      roll = targetAttitude[0] + jitter * gaussRandom();
-      pitch = targetAttitude[1] + jitter * gaussRandom();
-      yaw = targetAttitude[2] + jitter * gaussRandom();
-      pointingError = jitter * Math.sqrt(
-        Math.pow(gaussRandom(), 2) + Math.pow(gaussRandom(), 2) + Math.pow(gaussRandom(), 2)
-      );
-    }
-    const angularVelocity = Math.sqrt(
-      Math.pow((roll - prevRoll) / dt, 2) + Math.pow((pitch - prevPitch) / dt, 2) + Math.pow((yaw - prevYaw) / dt, 2)
-    );
-    data.push({
-      time: Date.now() + t * 1e3,
-      roll: Math.round(roll * 100) / 100,
-      pitch: Math.round(pitch * 100) / 100,
-      yaw: Math.round(yaw * 100) / 100,
-      pointingError: Math.round(pointingError * 1e3) / 1e3,
-      angularVelocity: Math.round(angularVelocity * 1e3) / 1e3
-    });
-    prevRoll = roll;
-    prevPitch = pitch;
-    prevYaw = yaw;
-  }
-  return data;
+	const { initialAttitude = [
+		0,
+		-45,
+		90
+	], targetAttitude = [
+		0,
+		30,
+		180
+	], slewRate = .5, settleTime = 30, jitter = .02, samplingRate = 1, duration = 300 } = config;
+	const data = [];
+	const dt = 1 / samplingRate;
+	const deltaAttitude = targetAttitude.map((t, i) => t - initialAttitude[i]);
+	const totalAngle = Math.sqrt(deltaAttitude.reduce((sum, d) => sum + d * d, 0));
+	const slewDuration = totalAngle / slewRate;
+	deltaAttitude.map((d) => d / totalAngle);
+	const gaussRandom = () => {
+		const u1 = Math.random();
+		const u2 = Math.random();
+		return Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+	};
+	let prevRoll = initialAttitude[0];
+	let prevPitch = initialAttitude[1];
+	let prevYaw = initialAttitude[2];
+	for (let t = 0; t < duration; t += dt) {
+		let roll, pitch, yaw;
+		let pointingError;
+		if (t < slewDuration) {
+			const progress = t / slewDuration;
+			const smoothProgress = .5 - .5 * Math.cos(progress * Math.PI);
+			roll = initialAttitude[0] + deltaAttitude[0] * smoothProgress;
+			pitch = initialAttitude[1] + deltaAttitude[1] * smoothProgress;
+			yaw = initialAttitude[2] + deltaAttitude[2] * smoothProgress;
+			pointingError = totalAngle * (1 - progress);
+		} else if (t < slewDuration + settleTime) {
+			const settleProgress = (t - slewDuration) / settleTime;
+			const decayFactor = Math.exp(-3 * settleProgress);
+			const overshoot = .05 * Math.sin(settleProgress * Math.PI * 4) * decayFactor;
+			roll = targetAttitude[0] + overshoot + jitter * gaussRandom();
+			pitch = targetAttitude[1] + overshoot + jitter * gaussRandom();
+			yaw = targetAttitude[2] + overshoot + jitter * gaussRandom();
+			pointingError = Math.abs(overshoot) + jitter * Math.abs(gaussRandom());
+		} else {
+			roll = targetAttitude[0] + jitter * gaussRandom();
+			pitch = targetAttitude[1] + jitter * gaussRandom();
+			yaw = targetAttitude[2] + jitter * gaussRandom();
+			pointingError = jitter * Math.sqrt(Math.pow(gaussRandom(), 2) + Math.pow(gaussRandom(), 2) + Math.pow(gaussRandom(), 2));
+		}
+		const angularVelocity = Math.sqrt(Math.pow((roll - prevRoll) / dt, 2) + Math.pow((pitch - prevPitch) / dt, 2) + Math.pow((yaw - prevYaw) / dt, 2));
+		data.push({
+			time: Date.now() + t * 1e3,
+			roll: Math.round(roll * 100) / 100,
+			pitch: Math.round(pitch * 100) / 100,
+			yaw: Math.round(yaw * 100) / 100,
+			pointingError: Math.round(pointingError * 1e3) / 1e3,
+			angularVelocity: Math.round(angularVelocity * 1e3) / 1e3
+		});
+		prevRoll = roll;
+		prevPitch = pitch;
+		prevYaw = yaw;
+	}
+	return data;
 }
+/**
+* Generate realistic Doppler tracking data for a satellite pass
+*
+* Uses simplified orbital mechanics:
+* - Circular orbit at specified altitude
+* - Pass geometry from maximum elevation
+* - Doppler shift from velocity projection
+*/
 function generateDopplerData(config = {}) {
-  const {
-    carrierFrequency = 437e6,
-    // 437 MHz (UHF amateur)
-    altitude = 400,
-    // km (ISS altitude)
-    maxElevation = 75,
-    passDuration = 600,
-    // 10 minutes
-    resolution = 1,
-    measurementNoise = 50,
-    // Hz
-    satelliteName = "ISS",
-    groundStation: _groundStation = "Home Station"
-  } = config;
-  const predicted = [];
-  const measured = [];
-  const orbitRadius = EARTH_RADIUS + altitude;
-  const orbitalVelocity = Math.sqrt(MU_EARTH / orbitRadius);
-  const maxDoppler = carrierFrequency * (orbitalVelocity * 1e3 / SPEED_OF_LIGHT);
-  const elevationRad = maxElevation * Math.PI / 180;
-  const passHalfAngle = Math.PI / 2 - elevationRad;
-  const now = Date.now();
-  const aos = now;
-  const los = now + passDuration * 1e3;
-  const tca = now + passDuration / 2 * 1e3;
-  const gaussRandom = () => {
-    const u1 = Math.random();
-    const u2 = Math.random();
-    return Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
-  };
-  for (let t = 0; t <= passDuration; t += resolution) {
-    const time = now + t * 1e3;
-    const passPhase = t / passDuration;
-    const angle = (passPhase - 0.5) * 2 * passHalfAngle;
-    const dopplerShift = maxDoppler * Math.sin(angle);
-    const elevation = maxElevation * Math.cos(angle);
-    predicted.push({
-      time,
-      dopplerShift: Math.round(dopplerShift),
-      elevation: Math.round(elevation * 10) / 10
-    });
-    const measuredShift = dopplerShift + measurementNoise * gaussRandom();
-    measured.push({
-      time,
-      dopplerShift: Math.round(measuredShift),
-      elevation: Math.round(elevation * 10) / 10
-    });
-  }
-  const passInfo = {
-    name: satelliteName,
-    aos: new Date(aos),
-    los: new Date(los),
-    tca: new Date(tca),
-    maxElevation
-  };
-  return { predicted, measured, passInfo };
+	const { carrierFrequency = 437e6, altitude = 400, maxElevation = 75, passDuration = 600, resolution = 1, measurementNoise = 50, satelliteName = "ISS", groundStation: _groundStation = "Home Station" } = config;
+	const predicted = [];
+	const measured = [];
+	const orbitRadius = EARTH_RADIUS + altitude;
+	const maxDoppler = carrierFrequency * (Math.sqrt(MU_EARTH / orbitRadius) * 1e3 / SPEED_OF_LIGHT);
+	const elevationRad = maxElevation * Math.PI / 180;
+	const passHalfAngle = Math.PI / 2 - elevationRad;
+	const now = Date.now();
+	const aos = now;
+	const los = now + passDuration * 1e3;
+	const tca = now + passDuration / 2 * 1e3;
+	const gaussRandom = () => {
+		const u1 = Math.random();
+		const u2 = Math.random();
+		return Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+	};
+	for (let t = 0; t <= passDuration; t += resolution) {
+		const time = now + t * 1e3;
+		const angle = (t / passDuration - .5) * 2 * passHalfAngle;
+		const dopplerShift = maxDoppler * Math.sin(angle);
+		const elevation = maxElevation * Math.cos(angle);
+		predicted.push({
+			time,
+			dopplerShift: Math.round(dopplerShift),
+			elevation: Math.round(elevation * 10) / 10
+		});
+		const measuredShift = dopplerShift + measurementNoise * gaussRandom();
+		measured.push({
+			time,
+			dopplerShift: Math.round(measuredShift),
+			elevation: Math.round(elevation * 10) / 10
+		});
+	}
+	return {
+		predicted,
+		measured,
+		passInfo: {
+			name: satelliteName,
+			aos: new Date(aos),
+			los: new Date(los),
+			tca: new Date(tca),
+			maxElevation
+		}
+	};
 }
+/**
+* Generate realistic RF waterfall data
+*
+* Models:
+* - Gaussian noise floor
+* - CW signals (narrow spikes)
+* - SSB signals (offset sideband with modulation)
+* - Digital signals (wider, flatter spectrum)
+* - Time-varying Doppler drift
+*/
 function generateWaterfallData(config = {}) {
-  const {
-    centerFrequency = 437e6,
-    bandwidth = 1e5,
-    fftBins = 512,
-    noiseFloor = -120,
-    timeSamples = 100,
-    signals = [
-      { offset: -3e4, power: -80, bandwidth: 500, type: "cw" },
-      { offset: 0, power: -75, bandwidth: 2e4, type: "digital" },
-      { offset: 25e3, power: -90, bandwidth: 3e3, type: "ssb" }
-    ]
-  } = config;
-  const data = [];
-  const freqStep = bandwidth / fftBins;
-  const noiseStdDev = 3;
-  const gaussRandom = () => {
-    const u1 = Math.random();
-    const u2 = Math.random();
-    return Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
-  };
-  const frequencies = [];
-  for (let f = 0; f < fftBins; f++) {
-    frequencies.push(centerFrequency + (f - fftBins / 2) * freqStep);
-  }
-  for (let t = 0; t < timeSamples; t++) {
-    const powers = [];
-    const time = Date.now() - (timeSamples - t) * 100;
-    for (let f = 0; f < fftBins; f++) {
-      const freqOffset = (f - fftBins / 2) * freqStep;
-      let power = noiseFloor + noiseStdDev * gaussRandom();
-      for (const signal of signals) {
-        const signalOffset = signal.offset + (signal.dopplerDrift || 0) * (t / 10);
-        const distance = Math.abs(freqOffset - signalOffset);
-        if (signal.type === "cw") {
-          if (distance < signal.bandwidth * 2) {
-            const shape = Math.pow(Math.sin(Math.PI * distance / signal.bandwidth) / (Math.PI * distance / signal.bandwidth + 1e-3), 2);
-            power = Math.max(power, signal.power + 10 * Math.log10(shape + 1e-3) + gaussRandom());
-          }
-        } else if (signal.type === "ssb") {
-          if (freqOffset >= signalOffset && freqOffset <= signalOffset + signal.bandwidth) {
-            const modulation = 0.5 + 0.5 * Math.sin(t * 0.3 + f * 0.1);
-            power = Math.max(power, signal.power - 3 + 6 * modulation + 2 * gaussRandom());
-          }
-        } else if (signal.type === "digital") {
-          if (distance < signal.bandwidth / 2) {
-            power = Math.max(power, signal.power + gaussRandom());
-          } else if (distance < signal.bandwidth) {
-            const rolloff = 1 - (distance - signal.bandwidth / 2) / (signal.bandwidth / 2);
-            power = Math.max(power, signal.power - 20 * (1 - rolloff) + gaussRandom());
-          }
-        } else if (signal.type === "beacon") {
-          if (distance < signal.bandwidth) {
-            power = Math.max(power, signal.power);
-          }
-        }
-      }
-      powers.push(Math.round(power * 10) / 10);
-    }
-    data.push({ time, frequencies: [...frequencies], powers });
-  }
-  return data;
+	const { centerFrequency = 437e6, bandwidth = 1e5, fftBins = 512, noiseFloor = -120, timeSamples = 100, signals = [
+		{
+			offset: -3e4,
+			power: -80,
+			bandwidth: 500,
+			type: "cw"
+		},
+		{
+			offset: 0,
+			power: -75,
+			bandwidth: 2e4,
+			type: "digital"
+		},
+		{
+			offset: 25e3,
+			power: -90,
+			bandwidth: 3e3,
+			type: "ssb"
+		}
+	] } = config;
+	const data = [];
+	const freqStep = bandwidth / fftBins;
+	const noiseStdDev = 3;
+	const gaussRandom = () => {
+		const u1 = Math.random();
+		const u2 = Math.random();
+		return Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+	};
+	const frequencies = [];
+	for (let f = 0; f < fftBins; f++) frequencies.push(centerFrequency + (f - fftBins / 2) * freqStep);
+	for (let t = 0; t < timeSamples; t++) {
+		const powers = [];
+		const time = Date.now() - (timeSamples - t) * 100;
+		for (let f = 0; f < fftBins; f++) {
+			const freqOffset = (f - fftBins / 2) * freqStep;
+			let power = noiseFloor + noiseStdDev * gaussRandom();
+			for (const signal of signals) {
+				const signalOffset = signal.offset + (signal.dopplerDrift || 0) * (t / 10);
+				const distance = Math.abs(freqOffset - signalOffset);
+				if (signal.type === "cw") {
+					if (distance < signal.bandwidth * 2) {
+						const shape = Math.pow(Math.sin(Math.PI * distance / signal.bandwidth) / (Math.PI * distance / signal.bandwidth + .001), 2);
+						power = Math.max(power, signal.power + 10 * Math.log10(shape + .001) + gaussRandom());
+					}
+				} else if (signal.type === "ssb") {
+					if (freqOffset >= signalOffset && freqOffset <= signalOffset + signal.bandwidth) {
+						const modulation = .5 + .5 * Math.sin(t * .3 + f * .1);
+						power = Math.max(power, signal.power - 3 + 6 * modulation + 2 * gaussRandom());
+					}
+				} else if (signal.type === "digital") {
+					if (distance < signal.bandwidth / 2) power = Math.max(power, signal.power + gaussRandom());
+					else if (distance < signal.bandwidth) {
+						const rolloff = 1 - (distance - signal.bandwidth / 2) / (signal.bandwidth / 2);
+						power = Math.max(power, signal.power - 20 * (1 - rolloff) + gaussRandom());
+					}
+				} else if (signal.type === "beacon") {
+					if (distance < signal.bandwidth) power = Math.max(power, signal.power);
+				}
+			}
+			powers.push(Math.round(power * 10) / 10);
+		}
+		data.push({
+			time,
+			frequencies: [...frequencies],
+			powers
+		});
+	}
+	return data;
 }
+/**
+* Generate realistic ground station contact windows
+*
+* Uses simplified visibility calculation based on:
+* - Orbital period from altitude
+* - Swath width from elevation angle
+* - Ground track precession
+*/
 function generateContactWindows(config = {}) {
-  const {
-    groundStations = [
-      { name: "Svalbard (SG)", latitude: 78.2, longitude: 15.4 },
-      { name: "McMurdo (MCM)", latitude: -77.8, longitude: 166.7 },
-      { name: "Hawaii (HBK)", latitude: 21.5, longitude: -158 },
-      { name: "Kiruna (KIR)", latitude: 67.9, longitude: 20.9 }
-    ],
-    altitude = 400,
-    inclination = 51.6,
-    duration = 24,
-    minElevation = 5
-  } = config;
-  const result = [];
-  const now = Date.now();
-  const orbitPeriod = 2 * Math.PI * Math.sqrt(Math.pow(EARTH_RADIUS + altitude, 3) / MU_EARTH);
-  const passesPerDay = Math.floor(duration * 3600 / orbitPeriod);
-  for (const gs of groundStations) {
-    const windows = [];
-    const isVisible = Math.abs(gs.latitude) <= inclination + 15;
-    if (!isVisible) continue;
-    const passesForStation = Math.floor(passesPerDay * (0.3 + 0.7 * Math.cos(gs.latitude * Math.PI / 180)));
-    for (let i = 0; i < passesForStation; i++) {
-      const passStart = now + i * duration * 3600 * 1e3 / passesForStation;
-      const passStart2 = passStart + (Math.random() - 0.5) * orbitPeriod * 500;
-      const maxEl = minElevation + Math.random() * (85 - minElevation);
-      const passDuration = 10 * 60 * 1e3 * (1 - maxEl / 180);
-      const signalQuality = maxEl > 45 ? "good" : maxEl > 20 ? "marginal" : "poor";
-      windows.push({
-        start: passStart2,
-        end: passStart2 + passDuration,
-        label: `Pass ${i + 1}`,
-        signalQuality,
-        elevation: Math.round(maxEl)
-      });
-    }
-    result.push({ id: gs.name, name: gs.name, windows });
-  }
-  return result;
+	const { groundStations = [
+		{
+			name: "Svalbard (SG)",
+			latitude: 78.2,
+			longitude: 15.4
+		},
+		{
+			name: "McMurdo (MCM)",
+			latitude: -77.8,
+			longitude: 166.7
+		},
+		{
+			name: "Hawaii (HBK)",
+			latitude: 21.5,
+			longitude: -158
+		},
+		{
+			name: "Kiruna (KIR)",
+			latitude: 67.9,
+			longitude: 20.9
+		}
+	], altitude = 400, inclination = 51.6, duration = 24, minElevation = 5 } = config;
+	const result = [];
+	const now = Date.now();
+	const orbitPeriod = 2 * Math.PI * Math.sqrt(Math.pow(EARTH_RADIUS + altitude, 3) / MU_EARTH);
+	const passesPerDay = Math.floor(duration * 3600 / orbitPeriod);
+	for (const gs of groundStations) {
+		const windows = [];
+		if (!(Math.abs(gs.latitude) <= inclination + 15)) continue;
+		const passesForStation = Math.floor(passesPerDay * (.3 + .7 * Math.cos(gs.latitude * Math.PI / 180)));
+		for (let i = 0; i < passesForStation; i++) {
+			const passStart2 = now + i * duration * 3600 * 1e3 / passesForStation + (Math.random() - .5) * orbitPeriod * 500;
+			const maxEl = minElevation + Math.random() * (85 - minElevation);
+			const passDuration = 600 * 1e3 * (1 - maxEl / 180);
+			const signalQuality = maxEl > 45 ? "good" : maxEl > 20 ? "marginal" : "poor";
+			windows.push({
+				start: passStart2,
+				end: passStart2 + passDuration,
+				label: `Pass ${i + 1}`,
+				signalQuality,
+				elevation: Math.round(maxEl)
+			});
+		}
+		result.push({
+			id: gs.name,
+			name: gs.name,
+			windows
+		});
+	}
+	return result;
 }
+/**
+* Generate heliocentric orbit visualization data
+*/
 function generateHeliocentricOrbits(config = {}) {
-  const {
-    bodies = [
-      { name: "Earth", type: "planet", semiMajorAxis: 1, eccentricity: 0.017, inclination: 0, argumentOfPerihelion: 102, trueAnomaly: 0, color: "#3498db" },
-      { name: "Mars", type: "planet", semiMajorAxis: 1.52, eccentricity: 0.093, inclination: 1.85, argumentOfPerihelion: 286, trueAnomaly: 45, color: "#e74c3c" },
-      { name: "Voyager 1", type: "spacecraft", semiMajorAxis: 40, eccentricity: 0.99, inclination: 35, argumentOfPerihelion: 0, trueAnomaly: 170, color: "#3E3CFF" }
-    ],
-    orbitPoints = 72
-  } = config;
-  return bodies.map((body) => {
-    const { semiMajorAxis: a, eccentricity: e, inclination: i, argumentOfPerihelion: omega, trueAnomaly: nu } = body;
-    const orbitPath = [];
-    for (let j = 0; j <= orbitPoints; j++) {
-      const angle = j / orbitPoints * 2 * Math.PI;
-      const r2 = a * (1 - e * e) / (1 + e * Math.cos(angle));
-      const xOrbit2 = r2 * Math.cos(angle);
-      const yOrbit2 = r2 * Math.sin(angle);
-      const omegaRad2 = omega * Math.PI / 180;
-      const iRad2 = i * Math.PI / 180;
-      const x2 = xOrbit2 * Math.cos(omegaRad2) - yOrbit2 * Math.cos(iRad2) * Math.sin(omegaRad2);
-      const y2 = xOrbit2 * Math.sin(omegaRad2) + yOrbit2 * Math.cos(iRad2) * Math.cos(omegaRad2);
-      const z2 = yOrbit2 * Math.sin(iRad2);
-      orbitPath.push({ x: x2, y: y2, z: z2 });
-    }
-    const nuRad = nu * Math.PI / 180;
-    const r = a * (1 - e * e) / (1 + e * Math.cos(nuRad));
-    const xOrbit = r * Math.cos(nuRad);
-    const yOrbit = r * Math.sin(nuRad);
-    const omegaRad = omega * Math.PI / 180;
-    const iRad = i * Math.PI / 180;
-    const x = xOrbit * Math.cos(omegaRad) - yOrbit * Math.cos(iRad) * Math.sin(omegaRad);
-    const y = xOrbit * Math.sin(omegaRad) + yOrbit * Math.cos(iRad) * Math.cos(omegaRad);
-    const z = yOrbit * Math.sin(iRad);
-    const period = 365.25 * Math.pow(a, 1.5);
-    return {
-      name: body.name,
-      type: body.type,
-      x,
-      y,
-      z,
-      orbitPath,
-      color: body.color,
-      semiMajorAxis: a,
-      period,
-      inclination: i,
-      size: body.type === "planet" ? 20 : 12
-    };
-  });
+	const { bodies = [
+		{
+			name: "Earth",
+			type: "planet",
+			semiMajorAxis: 1,
+			eccentricity: .017,
+			inclination: 0,
+			argumentOfPerihelion: 102,
+			trueAnomaly: 0,
+			color: "#3498db"
+		},
+		{
+			name: "Mars",
+			type: "planet",
+			semiMajorAxis: 1.52,
+			eccentricity: .093,
+			inclination: 1.85,
+			argumentOfPerihelion: 286,
+			trueAnomaly: 45,
+			color: "#e74c3c"
+		},
+		{
+			name: "Voyager 1",
+			type: "spacecraft",
+			semiMajorAxis: 40,
+			eccentricity: .99,
+			inclination: 35,
+			argumentOfPerihelion: 0,
+			trueAnomaly: 170,
+			color: "#3E3CFF"
+		}
+	], orbitPoints = 72 } = config;
+	return bodies.map((body) => {
+		const { semiMajorAxis: a, eccentricity: e, inclination: i, argumentOfPerihelion: omega, trueAnomaly: nu } = body;
+		const orbitPath = [];
+		for (let j = 0; j <= orbitPoints; j++) {
+			const angle = j / orbitPoints * 2 * Math.PI;
+			const r = a * (1 - e * e) / (1 + e * Math.cos(angle));
+			const xOrbit = r * Math.cos(angle);
+			const yOrbit = r * Math.sin(angle);
+			const omegaRad = omega * Math.PI / 180;
+			const iRad = i * Math.PI / 180;
+			const x = xOrbit * Math.cos(omegaRad) - yOrbit * Math.cos(iRad) * Math.sin(omegaRad);
+			const y = xOrbit * Math.sin(omegaRad) + yOrbit * Math.cos(iRad) * Math.cos(omegaRad);
+			const z = yOrbit * Math.sin(iRad);
+			orbitPath.push({
+				x,
+				y,
+				z
+			});
+		}
+		const nuRad = nu * Math.PI / 180;
+		const r = a * (1 - e * e) / (1 + e * Math.cos(nuRad));
+		const xOrbit = r * Math.cos(nuRad);
+		const yOrbit = r * Math.sin(nuRad);
+		const omegaRad = omega * Math.PI / 180;
+		const iRad = i * Math.PI / 180;
+		const x = xOrbit * Math.cos(omegaRad) - yOrbit * Math.cos(iRad) * Math.sin(omegaRad);
+		const y = xOrbit * Math.sin(omegaRad) + yOrbit * Math.cos(iRad) * Math.cos(omegaRad);
+		const z = yOrbit * Math.sin(iRad);
+		const period = 365.25 * Math.pow(a, 1.5);
+		return {
+			name: body.name,
+			type: body.type,
+			x,
+			y,
+			z,
+			orbitPath,
+			color: body.color,
+			semiMajorAxis: a,
+			period,
+			inclination: i,
+			size: body.type === "planet" ? 20 : 12
+		};
+	});
 }
+/**
+* Generate a single RF spectrum snapshot
+*/
 function generateSpectrum(config = {}) {
-  const {
-    centerFrequency = 22e8,
-    bandwidth = 1e7,
-    points = 256,
-    noiseFloor = -120,
-    signals = [
-      { frequency: 22e8, power: -75, bandwidth: 1e5 },
-      { frequency: 21975e5, power: -80, bandwidth: 1e4 },
-      { frequency: 22025e5, power: -95, bandwidth: 5e4 }
-    ]
-  } = config;
-  const data = [];
-  const freqMin = centerFrequency - bandwidth / 2;
-  const freqStep = bandwidth / points;
-  for (let i = 0; i < points; i++) {
-    const freq = freqMin + i * freqStep;
-    let power = noiseFloor + 3 * (Math.random() - 0.5);
-    for (const signal of signals) {
-      const distance = Math.abs(freq - signal.frequency);
-      if (distance < signal.bandwidth * 2) {
-        const attenuation = 20 * Math.log10(1 + distance / (signal.bandwidth / 2));
-        power = Math.max(power, signal.power - attenuation);
-      }
-    }
-    data.push({ frequency: freq, power: Math.round(power * 10) / 10 });
-  }
-  return data;
+	const { centerFrequency = 22e8, bandwidth = 1e7, points = 256, noiseFloor = -120, signals = [
+		{
+			frequency: 22e8,
+			power: -75,
+			bandwidth: 1e5
+		},
+		{
+			frequency: 21975e5,
+			power: -80,
+			bandwidth: 1e4
+		},
+		{
+			frequency: 22025e5,
+			power: -95,
+			bandwidth: 5e4
+		}
+	] } = config;
+	const data = [];
+	const freqMin = centerFrequency - bandwidth / 2;
+	const freqStep = bandwidth / points;
+	for (let i = 0; i < points; i++) {
+		const freq = freqMin + i * freqStep;
+		let power = noiseFloor + 3 * (Math.random() - .5);
+		for (const signal of signals) {
+			const distance = Math.abs(freq - signal.frequency);
+			if (distance < signal.bandwidth * 2) {
+				const attenuation = 20 * Math.log10(1 + distance / (signal.bandwidth / 2));
+				power = Math.max(power, signal.power - attenuation);
+			}
+		}
+		data.push({
+			frequency: freq,
+			power: Math.round(power * 10) / 10
+		});
+	}
+	return data;
 }
+/**
+* Generate eclipse timeline data
+*/
 function generateEclipseTimeline(config = {}) {
-  const {
-    orbitPeriod = 5400,
-    eclipseFraction = 0.38,
-    orbits = 5,
-    includePenumbra = true
-  } = config;
-  const data = [];
-  const now = Date.now();
-  const penumbraDuration = includePenumbra ? 60 : 0;
-  for (let orbit = 0; orbit < orbits; orbit++) {
-    const orbitStart = now + orbit * orbitPeriod * 1e3;
-    const eclipseStart = orbitStart + orbitPeriod * 0.4 * 1e3;
-    const eclipseEnd = eclipseStart + orbitPeriod * eclipseFraction * 1e3;
-    data.push({
-      start: orbitStart,
-      end: eclipseStart - penumbraDuration * 1e3,
-      type: "sunlight",
-      orbitNumber: orbit + 1
-    });
-    if (includePenumbra) {
-      data.push({
-        start: eclipseStart - penumbraDuration * 1e3,
-        end: eclipseStart,
-        type: "penumbra",
-        orbitNumber: orbit + 1
-      });
-    }
-    data.push({
-      start: eclipseStart,
-      end: eclipseEnd,
-      type: "umbra",
-      orbitNumber: orbit + 1
-    });
-    if (includePenumbra) {
-      data.push({
-        start: eclipseEnd,
-        end: eclipseEnd + penumbraDuration * 1e3,
-        type: "penumbra",
-        orbitNumber: orbit + 1
-      });
-    }
-    data.push({
-      start: eclipseEnd + penumbraDuration * 1e3,
-      end: orbitStart + orbitPeriod * 1e3,
-      type: "sunlight",
-      orbitNumber: orbit + 1
-    });
-  }
-  return data;
+	const { orbitPeriod = 5400, eclipseFraction = .38, orbits = 5, includePenumbra = true } = config;
+	const data = [];
+	const now = Date.now();
+	const penumbraDuration = includePenumbra ? 60 : 0;
+	for (let orbit = 0; orbit < orbits; orbit++) {
+		const orbitStart = now + orbit * orbitPeriod * 1e3;
+		const eclipseStart = orbitStart + orbitPeriod * .4 * 1e3;
+		const eclipseEnd = eclipseStart + orbitPeriod * eclipseFraction * 1e3;
+		data.push({
+			start: orbitStart,
+			end: eclipseStart - penumbraDuration * 1e3,
+			type: "sunlight",
+			orbitNumber: orbit + 1
+		});
+		if (includePenumbra) data.push({
+			start: eclipseStart - penumbraDuration * 1e3,
+			end: eclipseStart,
+			type: "penumbra",
+			orbitNumber: orbit + 1
+		});
+		data.push({
+			start: eclipseStart,
+			end: eclipseEnd,
+			type: "umbra",
+			orbitNumber: orbit + 1
+		});
+		if (includePenumbra) data.push({
+			start: eclipseEnd,
+			end: eclipseEnd + penumbraDuration * 1e3,
+			type: "penumbra",
+			orbitNumber: orbit + 1
+		});
+		data.push({
+			start: eclipseEnd + penumbraDuration * 1e3,
+			end: orbitStart + orbitPeriod * 1e3,
+			type: "sunlight",
+			orbitNumber: orbit + 1
+		});
+	}
+	return data;
 }
+/**
+* Generate constellation coverage grid data
+*
+* Models simplified visibility based on satellite altitude
+* and ground footprint overlap from Walker constellation geometry.
+*/
 function generateConstellationCoverage(config = {}) {
-  const {
-    latResolution = 5,
-    lonResolution = 5,
-    planes = 6,
-    satsPerPlane = 22,
-    altitude = 550,
-    inclination = 53,
-    metric = "visibility"
-  } = config;
-  const latitudes = [];
-  const longitudes = [];
-  const coverage = [];
-  for (let lat = -90; lat <= 90; lat += latResolution) latitudes.push(lat);
-  for (let lon = -180; lon < 180; lon += lonResolution) longitudes.push(lon);
-  const earthRadius = 6371;
-  const footprintAngle = Math.acos(earthRadius / (earthRadius + altitude)) * (180 / Math.PI);
-  const totalSats = planes * satsPerPlane;
-  for (let li = 0; li < latitudes.length; li++) {
-    const row = [];
-    const lat = latitudes[li];
-    for (let lj = 0; lj < longitudes.length; lj++) {
-      let value;
-      const latFactor = Math.abs(lat) <= inclination ? 1 : Math.max(0, 1 - (Math.abs(lat) - inclination) / 20);
-      const densityFactor = totalSats / 100;
-      const footprintOverlap = Math.min(1, densityFactor * (footprintAngle / 30));
-      if (metric === "visibility") {
-        value = Math.min(100, footprintOverlap * latFactor * 100);
-        if (Math.abs(lat) > 60) value = Math.min(100, value * 1.2);
-        value += (Math.random() - 0.5) * 5;
-        value = Math.max(0, Math.min(100, value));
-      } else if (metric === "revisitTime") {
-        const baseRevisit = 90 / (footprintOverlap * latFactor + 0.01);
-        value = Math.max(1, Math.min(120, baseRevisit + (Math.random() - 0.5) * 10));
-      } else {
-        const slantRange = altitude / Math.sin(Math.max(0.1, latFactor * Math.PI / 4));
-        value = slantRange / 300 + 2 + Math.random() * 2;
-      }
-      row.push(Math.round(value * 10) / 10);
-    }
-    coverage.push(row);
-  }
-  const units = { visibility: "%", revisitTime: "min", latency: "ms" };
-  return { latitudes, longitudes, coverage, unit: units[metric] || "%" };
+	const { latResolution = 5, lonResolution = 5, planes = 6, satsPerPlane = 22, altitude = 550, inclination = 53, metric = "visibility" } = config;
+	const latitudes = [];
+	const longitudes = [];
+	const coverage = [];
+	for (let lat = -90; lat <= 90; lat += latResolution) latitudes.push(lat);
+	for (let lon = -180; lon < 180; lon += lonResolution) longitudes.push(lon);
+	const earthRadius = 6371;
+	const footprintAngle = Math.acos(earthRadius / (earthRadius + altitude)) * (180 / Math.PI);
+	const totalSats = planes * satsPerPlane;
+	for (let li = 0; li < latitudes.length; li++) {
+		const row = [];
+		const lat = latitudes[li];
+		lat * Math.PI / 180;
+		for (let lj = 0; lj < longitudes.length; lj++) {
+			let value;
+			const latFactor = Math.abs(lat) <= inclination ? 1 : Math.max(0, 1 - (Math.abs(lat) - inclination) / 20);
+			const densityFactor = totalSats / 100;
+			const footprintOverlap = Math.min(1, densityFactor * (footprintAngle / 30));
+			if (metric === "visibility") {
+				value = Math.min(100, footprintOverlap * latFactor * 100);
+				if (Math.abs(lat) > 60) value = Math.min(100, value * 1.2);
+				value += (Math.random() - .5) * 5;
+				value = Math.max(0, Math.min(100, value));
+			} else if (metric === "revisitTime") {
+				const baseRevisit = 90 / (footprintOverlap * latFactor + .01);
+				value = Math.max(1, Math.min(120, baseRevisit + (Math.random() - .5) * 10));
+			} else value = altitude / Math.sin(Math.max(.1, latFactor * Math.PI / 4)) / 300 + 2 + Math.random() * 2;
+			row.push(Math.round(value * 10) / 10);
+		}
+		coverage.push(row);
+	}
+	return {
+		latitudes,
+		longitudes,
+		coverage,
+		unit: {
+			visibility: "%",
+			revisitTime: "min",
+			latency: "ms"
+		}[metric] || "%"
+	};
 }
+/**
+* Generate realistic conjunction/close approach events
+*/
 function generateConjunctionEvents(config = {}) {
-  const {
-    primaryName = "SAT-ALPHA",
-    eventCount = 12,
-    timeRangeHours = 72,
-    includeHighRisk = true
-  } = config;
-  const secondaries = [
-    "COSMOS-2251 DEB",
-    "FENGYUN-1C DEB",
-    "SL-16 R/B",
-    "IRIDIUM 33 DEB",
-    "NOAA 17 DEB",
-    "ATLAS 5 CENTAUR R/B",
-    "BREEZE-M DEB",
-    "CZ-3B R/B",
-    "UNKNOWN DEB",
-    "MICROSAT-R DEB",
-    "DELTA 2 R/B",
-    "H-2A R/B"
-  ];
-  const now = Date.now();
-  const events = [];
-  for (let i = 0; i < eventCount; i++) {
-    const tca = now + Math.random() * timeRangeHours * 36e5;
-    let missDistance;
-    if (includeHighRisk && i < 2) {
-      missDistance = 0.1 + Math.random() * 0.9;
-    } else if (i < 5) {
-      missDistance = 1 + Math.random() * 4;
-    } else {
-      missDistance = 5 + Math.random() * 15;
-    }
-    const probability = Math.pow(10, -3 - missDistance * 1.5 + Math.random());
-    const relativeVelocity = 5 + Math.random() * 12;
-    const angle = Math.random() * 2 * Math.PI;
-    const incAngle = (Math.random() - 0.5) * Math.PI;
-    const radius = 6800 + Math.random() * 600;
-    events.push({
-      id: `CDM-${String(i + 1).padStart(3, "0")}`,
-      primary: primaryName,
-      secondary: secondaries[i % secondaries.length],
-      tca,
-      missDistance: Math.round(missDistance * 1e3) / 1e3,
-      probability: Math.max(1e-10, probability),
-      relativeVelocity: Math.round(relativeVelocity * 100) / 100,
-      position: {
-        x: Math.round(radius * Math.cos(angle) * Math.cos(incAngle)),
-        y: Math.round(radius * Math.sin(angle) * Math.cos(incAngle)),
-        z: Math.round(radius * Math.sin(incAngle))
-      },
-      uncertainty: {
-        rx: 20 + Math.random() * 100,
-        ry: 50 + Math.random() * 300,
-        rz: 10 + Math.random() * 60
-      }
-    });
-  }
-  return events.sort((a, b) => a.tca - b.tca);
+	const { primaryName = "SAT-ALPHA", eventCount = 12, timeRangeHours = 72, includeHighRisk = true } = config;
+	const secondaries = [
+		"COSMOS-2251 DEB",
+		"FENGYUN-1C DEB",
+		"SL-16 R/B",
+		"IRIDIUM 33 DEB",
+		"NOAA 17 DEB",
+		"ATLAS 5 CENTAUR R/B",
+		"BREEZE-M DEB",
+		"CZ-3B R/B",
+		"UNKNOWN DEB",
+		"MICROSAT-R DEB",
+		"DELTA 2 R/B",
+		"H-2A R/B"
+	];
+	const now = Date.now();
+	const events = [];
+	for (let i = 0; i < eventCount; i++) {
+		const tca = now + Math.random() * timeRangeHours * 36e5;
+		let missDistance;
+		if (includeHighRisk && i < 2) missDistance = .1 + Math.random() * .9;
+		else if (i < 5) missDistance = 1 + Math.random() * 4;
+		else missDistance = 5 + Math.random() * 15;
+		const probability = Math.pow(10, -3 - missDistance * 1.5 + Math.random());
+		const relativeVelocity = 5 + Math.random() * 12;
+		const angle = Math.random() * 2 * Math.PI;
+		const incAngle = (Math.random() - .5) * Math.PI;
+		const radius = 6800 + Math.random() * 600;
+		events.push({
+			id: `CDM-${String(i + 1).padStart(3, "0")}`,
+			primary: primaryName,
+			secondary: secondaries[i % secondaries.length],
+			tca,
+			missDistance: Math.round(missDistance * 1e3) / 1e3,
+			probability: Math.max(1e-10, probability),
+			relativeVelocity: Math.round(relativeVelocity * 100) / 100,
+			position: {
+				x: Math.round(radius * Math.cos(angle) * Math.cos(incAngle)),
+				y: Math.round(radius * Math.sin(angle) * Math.cos(incAngle)),
+				z: Math.round(radius * Math.sin(incAngle))
+			},
+			uncertainty: {
+				rx: 20 + Math.random() * 100,
+				ry: 50 + Math.random() * 300,
+				rz: 10 + Math.random() * 60
+			}
+		});
+	}
+	return events.sort((a, b) => a.tca - b.tca);
 }
-export {
-  generateAttitudeData,
-  generateConjunctionEvents,
-  generateConstellationCoverage,
-  generateContactWindows,
-  generateDopplerData,
-  generateEclipseTimeline,
-  generateHeliocentricOrbits,
-  generatePowerData,
-  generateSpectrum,
-  generateWaterfallData
-};
-//# sourceMappingURL=generators.js.map
+//#endregion
+export { generateAttitudeData, generateConjunctionEvents, generateConstellationCoverage, generateContactWindows, generateDopplerData, generateEclipseTimeline, generateHeliocentricOrbits, generatePowerData, generateSpectrum, generateWaterfallData };
+
+//# sourceMappingURL=generators.js.map