klio 1.4.9 → 1.5.1

package/src/astrology/astrologyServiceWeb.js

@@ -0,0 +1,369 @@
+// WebContainer-compatible Astrology Service
+// This provides real astrological calculations without native dependencies
+
+const { planets, signs } = require('./astrologyConstants');
+
+// Pure JavaScript implementation of basic astrological calculations
+class AstrologyServiceWeb {
+  constructor() {
+    // Current date for calculations
+    this.now = new Date();
+  }
+
+  // Calculate Julian Day Number (simplified version)
+  calculateJulianDay(date = null) {
+    const d = date || this.now;
+    const year = d.getFullYear();
+    const month = d.getMonth() + 1;
+    const day = d.getDate();
+    const hour = d.getHours();
+    const minute = d.getMinutes();
+    
+    // Simplified Julian Day calculation (not astronomically precise but works for demo)
+    const a = Math.floor((14 - month) / 12);
+    const y = year + 4800 - a;
+    const m = month + 12 * a - 3;
+    
+    const jdn = day + Math.floor((153 * m + 2) / 5) + 365 * y + Math.floor(y / 4) - Math.floor(y / 100) + Math.floor(y / 400) - 32045;
+    
+    // Add time of day
+    const timeFraction = (hour - 12) / 24 + minute / 1440;
+    
+    return jdn + timeFraction;
+  }
+
+  // Calculate mean planet positions (simplified ephemeris)
+  // Note: This is a simplified model, not astronomically precise
+  calculateMeanPlanetPosition(planetName, julianDay) {
+    const planet = planetName.toLowerCase();
+    
+    // Base positions (epoch 2000.0)
+    const epochPositions = {
+      sun: { longitude: 280.460, dailyMotion: 0.985647 },
+      moon: { longitude: 318.351, dailyMotion: 13.176396 },
+      mercury: { longitude: 252.251, dailyMotion: 4.092334 },
+      venus: { longitude: 181.979, dailyMotion: 1.602130 },
+      mars: { longitude: 355.433, dailyMotion: 0.524020 },
+      jupiter: { longitude: 34.353, dailyMotion: 0.083085 },
+      saturn: { longitude: 50.077, dailyMotion: 0.033449 },
+      uranus: { longitude: 314.328, dailyMotion: 0.011725 },
+      neptune: { longitude: 304.348, dailyMotion: 0.005981 },
+      pluto: { longitude: 238.950, dailyMotion: 0.003967 }
+    };
+    
+    if (!epochPositions[planet]) {
+      throw new Error("Unknown planet: " + planet);
+    }
+    
+    // Days since epoch (simplified)
+    const daysSinceEpoch = julianDay - 2451545; // 2000.0 epoch
+    
+    // Calculate mean longitude
+    let longitude = epochPositions[planet].longitude + epochPositions[planet].dailyMotion * daysSinceEpoch;
+    
+    // Normalize to 0-360 range
+    longitude = longitude % 360;
+    if (longitude < 0) longitude += 360;
+    
+    return longitude;
+  }
+
+  // Convert longitude to sign and degree
+  longitudeToSignDegree(longitude) {
+    // Normalize longitude
+    longitude = longitude % 360;
+    if (longitude < 0) longitude += 360;
+    
+    // Calculate sign (0-11)
+    const signIndex = Math.floor(longitude / 30);
+    const sign = signs[signIndex];
+    
+    // Calculate degree within sign
+    const degree = longitude % 30;
+    
+    return { sign, degree };
+  }
+
+  // Get astrological data for a planet
+  getAstrologicalData(planetName, date = null) {
+    const planet = planetName.toLowerCase();
+    
+    if (!planets[planet]) {
+      throw new Error("Unknown planet: " + planet);
+    }
+    
+    // Calculate Julian Day
+    const julianDay = this.calculateJulianDay(date);
+    
+    // Calculate planet position
+    const longitude = this.calculateMeanPlanetPosition(planet, julianDay);
+    const { sign, degree } = this.longitudeToSignDegree(longitude);
+    
+    // Determine dignity (simplified)
+    const dignity = this._getDignity(planet, sign);
+    
+    // Determine element
+    const element = this._getElement(sign);
+    
+    // Determine decan
+    const decan = this._getDecan(sign, degree);
+    
+    return {
+      planet: planetName,
+      sign,
+      degreeInSign: degree.toFixed(1),
+      dignity,
+      element,
+      decan,
+      longitude: longitude.toFixed(2)
+    };
+  }
+
+  // Get dignity for planet in sign
+  _getDignity(planet, sign) {
+    // Essential dignities (simplified)
+    const rulerships = {
+      sun: 'Leo',
+      moon: 'Cancer',
+      mercury: ['Gemini', 'Virgo'],
+      venus: ['Taurus', 'Libra'],
+      mars: ['Aries', 'Scorpio'],
+      jupiter: ['Sagittarius', 'Pisces'],
+      saturn: ['Capricorn', 'Aquarius'],
+      uranus: 'Aquarius',
+      neptune: 'Pisces',
+      pluto: 'Scorpio'
+    };
+    
+    const exaltations = {
+      sun: 'Aries',
+      moon: 'Taurus',
+      mercury: 'Virgo',
+      venus: 'Pisces',
+      mars: 'Capricorn',
+      jupiter: 'Cancer',
+      saturn: 'Libra'
+    };
+    
+    const detriments = {
+      sun: 'Aquarius',
+      moon: 'Capricorn',
+      mercury: ['Sagittarius', 'Pisces'],
+      venus: ['Aries', 'Scorpio'],
+      mars: ['Taurus', 'Libra'],
+      jupiter: ['Gemini', 'Virgo'],
+      saturn: ['Cancer', 'Leo']
+    };
+    
+    const falls = {
+      sun: 'Libra',
+      moon: 'Scorpio',
+      mercury: 'Pisces',
+      venus: 'Virgo',
+      mars: 'Cancer',
+      jupiter: 'Capricorn',
+      saturn: 'Aries'
+    };
+    
+    // Check rulership
+    if (Array.isArray(rulerships[planet])) {
+      if (rulerships[planet].includes(sign)) {
+        return 'Rulership';
+      }
+    } else if (rulerships[planet] === sign) {
+      return 'Rulership';
+    }
+    
+    // Check exaltation
+    if (exaltations[planet] === sign) {
+      return 'Exaltation';
+    }
+    
+    // Check detriment
+    if (Array.isArray(detriments[planet])) {
+      if (detriments[planet].includes(sign)) {
+        return 'Detriment';
+      }
+    } else if (detriments[planet] === sign) {
+      return 'Detriment';
+    }
+    
+    // Check fall
+    if (falls[planet] === sign) {
+      return 'Fall';
+    }
+    
+    return 'Neutral';
+  }
+
+  // Get element for sign
+  _getElement(sign) {
+    const fireSigns = ['Aries', 'Leo', 'Sagittarius'];
+    const earthSigns = ['Taurus', 'Virgo', 'Capricorn'];
+    const airSigns = ['Gemini', 'Libra', 'Aquarius'];
+    const waterSigns = ['Cancer', 'Scorpio', 'Pisces'];
+    
+    if (fireSigns.includes(sign)) return 'Fire';
+    if (earthSigns.includes(sign)) return 'Earth';
+    if (airSigns.includes(sign)) return 'Air';
+    if (waterSigns.includes(sign)) return 'Water';
+    
+    return 'Unknown';
+  }
+
+  // Get decan for sign and degree
+  _getDecan(sign, degree) {
+    return Math.floor(degree / 10) + 1;
+  }
+
+  // Get critical planets (planets at critical degrees)
+  getCriticalPlanets(date = null) {
+    const criticalPlanets = [];
+    const criticalDegrees = [0, 15, 19, 29]; // Anaretic, midpoint, Via Combusta
+    
+    for (const [planetName, planetId] of Object.entries(planets)) {
+      const data = this.getAstrologicalData(planetName, date);
+      const degree = parseFloat(data.degreeInSign);
+      
+      // Check if degree is critical (within 1 degree orb)
+      for (const criticalDegree of criticalDegrees) {
+        if (Math.abs(degree - criticalDegree) < 1) {
+          let criticalType;
+          let interpretation;
+          
+          switch (criticalDegree) {
+            case 0:
+            case 29:
+              criticalType = 'Anaretic Degree';
+              interpretation = 'Critical transition point - decisions and endings';
+              break;
+            case 15:
+              criticalType = 'Midpoint';
+              interpretation = 'Balanced energy - harmony and integration';
+              break;
+            case 19:
+              criticalType = 'Via Combusta';
+              interpretation = 'Challenging degree - intensity and transformation';
+              break;
+          }
+          
+          criticalPlanets.push({
+            name: planetName,
+            sign: data.sign,
+            degree: data.degreeInSign,
+            criticalType,
+            interpretation
+          });
+          break; // Only add once per planet
+        }
+      }
+    }
+    
+    return criticalPlanets;
+  }
+
+  // Get retrograde planets (simplified - uses fixed dates for demo)
+  getRetrogradePlanets(date = null) {
+    const d = date || this.now;
+    const year = d.getFullYear();
+    const month = d.getMonth() + 1;
+    const day = d.getDate();
+    
+    // Simplified retrograde periods (not astronomically precise)
+    const retrogradePeriods = {
+      mercury: [
+        { start: { month: 2, day: 16 }, end: { month: 3, day: 9 } },
+        { start: { month: 6, day: 18 }, end: { month: 7, day: 12 } },
+        { start: { month: 10, day: 21 }, end: { month: 11, day: 10 } }
+      ],
+      venus: [
+        { start: { month: 12, day: 19 }, end: { month: 1, day: 29 } }
+      ],
+      mars: [
+        { start: { month: 10, day: 30 }, end: { month: 1, day: 12 } }
+      ],
+      jupiter: [
+        { start: { month: 7, day: 28 }, end: { month: 11, day: 23 } }
+      ],
+      saturn: [
+        { start: { month: 6, day: 17 }, end: { month: 11, day: 4 } }
+      ],
+      uranus: [
+        { start: { month: 8, day: 24 }, end: { month: 1, day: 22 } }
+      ],
+      neptune: [
+        { start: { month: 6, day: 25 }, end: { month: 12, day: 1 } }
+      ],
+      pluto: [
+        { start: { month: 4, day: 27 }, end: { month: 10, day: 6 } }
+      ]
+    };
+    
+    const retrogradePlanets = [];
+    
+    for (const [planet, periods] of Object.entries(retrogradePeriods)) {
+      for (const period of periods) {
+        // Check if current date is within retrograde period
+        const startDate = new Date(year, period.start.month - 1, period.start.day);
+        const endDate = new Date(year, period.end.month - 1, period.end.day);
+        
+        // Handle year wrap-around
+        if (period.end.month < period.start.month) {
+          if (month > period.start.month || month < period.end.month) {
+            retrogradePlanets.push({
+              name: planet,
+              status: 'retrograde'
+            });
+            break;
+          }
+        } else if (d >= startDate && d <= endDate) {
+          retrogradePlanets.push({
+            name: planet,
+            status: 'retrograde'
+          });
+          break;
+        }
+      }
+    }
+    
+    // Add stationary points (when planets change direction)
+    // For simplicity, we'll add a few stationary planets
+    if (month === 3 && day >= 8 && day <= 10) {
+      retrogradePlanets.push({ name: 'mercury', status: 'stationary' });
+    }
+    if (month === 7 && day >= 11 && day <= 13) {
+      retrogradePlanets.push({ name: 'mercury', status: 'stationary' });
+    }
+    
+    return retrogradePlanets;
+  }
+
+  // Analyze element distribution
+  analyzeElementDistribution(date = null, useBirthData = false) {
+    const elementCounts = { Fire: 0, Earth: 0, Air: 0, Water: 0 };
+    
+    for (const [planetName] of Object.entries(planets)) {
+      const data = this.getAstrologicalData(planetName, date);
+      const element = data.element;
+      
+      if (elementCounts[element] !== undefined) {
+        elementCounts[element]++;
+      }
+    }
+    
+    return { elementCounts };
+  }
+
+  // Get all planet positions
+  getAllPlanetPositions(date = null) {
+    const positions = {};
+    
+    for (const [planetName] of Object.entries(planets)) {
+      positions[planetName] = this.getAstrologicalData(planetName, date);
+    }
+    
+    return positions;
+  }
+}
+
+module.exports = new AstrologyServiceWeb();

package/src/astrology/swephWasmLoader.js

@@ -0,0 +1,106 @@
+const fs = require('fs');
+const path = require('path');
+const vm = require('vm');
+
+let modulePromise = null;
+
+function ensureFileExists(filePath) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Sweph WASM asset not found: ${filePath}`);
+  }
+}
+
+function ensureFileSize(filePath, minimumBytes) {
+  const stat = fs.statSync(filePath);
+  if (!stat || stat.size < minimumBytes) {
+    throw new Error(`Sweph WASM asset too small (${stat ? stat.size : 0} bytes): ${filePath}`);
+  }
+}
+
+function resolveSwephBaseDir() {
+  const candidates = [
+    path.resolve(__dirname, '..', 'gui', 'public', 'sweph'),
+    path.resolve(process.cwd(), 'src', 'gui', 'public', 'sweph'),
+    '/src/gui/public/sweph'
+  ];
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  return candidates[0];
+}
+
+function createSandbox(moduleConfig) {
+  const atobFallback = (value) => Buffer.from(value, 'base64').toString('binary');
+  const btoaFallback = (value) => Buffer.from(value, 'binary').toString('base64');
+
+  const sandbox = {
+    Module: moduleConfig,
+    require,
+    process,
+    console,
+    Buffer,
+    setTimeout,
+    clearTimeout,
+    setInterval,
+    clearInterval,
+    TextDecoder,
+    TextEncoder,
+    URL,
+    atob: globalThis.atob || atobFallback,
+    btoa: globalThis.btoa || btoaFallback
+  };
+
+  sandbox.globalThis = sandbox;
+  return sandbox;
+}
+
+function loadSwephWasmModule() {
+  if (modulePromise) {
+    return modulePromise;
+  }
+
+  modulePromise = new Promise((resolve, reject) => {
+    const baseDir = resolveSwephBaseDir();
+    const astroJsPath = path.join(baseDir, 'astro.js');
+    const wasmPath = path.join(baseDir, 'astro.wasm');
+    const dataPath = path.join(baseDir, 'astro.data');
+
+    try {
+      ensureFileExists(astroJsPath);
+      ensureFileExists(wasmPath);
+      ensureFileExists(dataPath);
+      ensureFileSize(wasmPath, 500000);
+      ensureFileSize(dataPath, 500000);
+    } catch (error) {
+      reject(error);
+      return;
+    }
+
+    const moduleConfig = {
+      locateFile: (filename) => path.join(baseDir, filename),
+      print: () => {},
+      printErr: () => {},
+      onRuntimeInitialized: () => resolve(moduleConfig),
+      onAbort: (reason) => reject(new Error(reason || 'Sweph WASM aborted'))
+    };
+
+    const sandbox = createSandbox(moduleConfig);
+
+    try {
+      const code = fs.readFileSync(astroJsPath, 'utf8');
+      vm.runInNewContext(code, sandbox, { filename: astroJsPath });
+    } catch (error) {
+      reject(error);
+    }
+  });
+
+  return modulePromise;
+}
+
+module.exports = {
+  loadSwephWasmModule
+};