chart2txt 0.6.0 → 0.7.0

package/dist/types.js

@@ -1,6 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlanetCategory = exports.AspectClassification = void 0;
 exports.isMultiChartData = isMultiChartData;
 function isMultiChartData(obj) {
     return Array.isArray(obj);
 }
+var AspectClassification;
+(function (AspectClassification) {
+    AspectClassification["Major"] = "major";
+    AspectClassification["Minor"] = "minor";
+    AspectClassification["Esoteric"] = "esoteric";
+})(AspectClassification || (exports.AspectClassification = AspectClassification = {}));
+var PlanetCategory;
+(function (PlanetCategory) {
+    PlanetCategory["Luminaries"] = "luminaries";
+    PlanetCategory["Personal"] = "personal";
+    PlanetCategory["Social"] = "social";
+    PlanetCategory["Outer"] = "outer";
+    PlanetCategory["Angles"] = "angles";
+})(PlanetCategory || (exports.PlanetCategory = PlanetCategory = {}));

package/dist/utils/formatting.d.ts

@@ -1,6 +1,10 @@
+import { Point, PlanetPosition } from '../types';
 /**
  * Converts a number to its ordinal form (1st, 2nd, 3rd, etc.)
  * @param num The number to convert
  * @returns The ordinal string
  */
 export declare function getOrdinal(num: number): string;
+export declare function getSign(degree: number): string;
+export declare function getHouse(degree: number, houseCusps: number[]): number;
+export declare function getPlanetPositions(planets: Point[], houseCusps?: number[]): PlanetPosition[];

package/dist/utils/formatting.js

@@ -1,6 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getOrdinal = getOrdinal;
+exports.getSign = getSign;
+exports.getHouse = getHouse;
+exports.getPlanetPositions = getPlanetPositions;
+const constants_1 = require("../constants");
+function normalizeDegree(degree) {
+    return ((degree % 360) + 360) % 360;
+}
 /**
  * Converts a number to its ordinal form (1st, 2nd, 3rd, etc.)
  * @param num The number to convert
@@ -11,3 +18,39 @@ function getOrdinal(num) {
     const v = num % 100;
     return num + (suffix[(v - 20) % 10] || suffix[v] || suffix[0]);
 }
+function getSign(degree) {
+    const signIndex = Math.floor(degree / 30);
+    return constants_1.ZODIAC_SIGNS[signIndex];
+}
+function getHouse(degree, houseCusps) {
+    for (let i = 0; i < 12; i++) {
+        const cusp1 = houseCusps[i];
+        const cusp2 = houseCusps[(i + 1) % 12];
+        if (cusp1 < cusp2) {
+            if (degree >= cusp1 && degree < cusp2) {
+                return i + 1;
+            }
+        }
+        else {
+            if (degree >= cusp1 || degree < cusp2) {
+                return i + 1;
+            }
+        }
+    }
+    return -1; // Should not happen
+}
+function getPlanetPositions(planets, houseCusps) {
+    return planets.map((planet) => {
+        const normalizedDegree = normalizeDegree(planet.degree);
+        const position = {
+            name: planet.name,
+            degree: normalizedDegree,
+            sign: getSign(normalizedDegree),
+            speed: planet.speed,
+        };
+        if (houseCusps) {
+            position.house = getHouse(normalizedDegree, houseCusps);
+        }
+        return position;
+    });
+}

package/dist/utils/houseCalculations.d.ts

@@ -1,13 +1,10 @@
-/**
- * Validates house cusps array for correctness
- * @param houseCusps Array of 12 house cusp degrees
- * @returns True if valid, false otherwise
- */
-export declare function validateHouseCusps(houseCusps: number[] | undefined): boolean;
-/**
- * Determines which house a point falls into based on house cusps
- * @param pointDegree The degree of the point (will be normalized)
- * @param houseCusps Array of 12 house cusp degrees
- * @returns House number (1-12) or null if calculation fails
- */
-export declare function getHouseForPoint(pointDegree: number, houseCusps: number[] | undefined): number | null;
+import { ChartData } from '../types';
+export declare function calculateHouseOverlays(chart1: ChartData, chart2: ChartData): {
+    chart1InChart2Houses: {
+        [key: string]: number;
+    };
+    chart2InChart1Houses: {
+        [key: string]: number;
+    };
+};
+export declare function getHouseForPoint(degree: number, houseCusps: number[]): number;

package/dist/utils/houseCalculations.js

@@ -1,65 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateHouseCusps = validateHouseCusps;
+exports.calculateHouseOverlays = calculateHouseOverlays;
 exports.getHouseForPoint = getHouseForPoint;
-const astrology_1 = require("../core/astrology");
-const precision_1 = require("./precision");
-/**
- * Validates house cusps array for correctness
- * @param houseCusps Array of 12 house cusp degrees
- * @returns True if valid, false otherwise
- */
-function validateHouseCusps(houseCusps) {
-    if (!houseCusps || houseCusps.length !== 12) {
-        return false;
-    }
-    // Check that all cusp values are finite numbers
-    for (const cusp of houseCusps) {
-        if (!isFinite(cusp)) {
-            return false;
-        }
-    }
-    return true;
-}
-/**
- * Determines which house a point falls into based on house cusps
- * @param pointDegree The degree of the point (will be normalized)
- * @param houseCusps Array of 12 house cusp degrees
- * @returns House number (1-12) or null if calculation fails
- */
-function getHouseForPoint(pointDegree, houseCusps) {
-    if (!validateHouseCusps(houseCusps)) {
-        return null;
-    }
-    if (!isFinite(pointDegree)) {
-        return null;
-    }
-    const normalizedPoint = (0, precision_1.roundDegrees)((0, astrology_1.normalizeDegree)(pointDegree));
-    const normalizedCusps = houseCusps.map((cusp) => (0, precision_1.roundDegrees)((0, astrology_1.normalizeDegree)(cusp)));
-    // Check if point is exactly on any cusp (within precision tolerance)
-    for (let i = 0; i < 12; i++) {
-        if ((0, precision_1.isOnCusp)(normalizedPoint, normalizedCusps[i])) {
-            // Point is exactly on cusp - assign to the house that starts at this cusp
-            return i + 1;
+const formatting_1 = require("./formatting");
+function calculateHouseOverlays(chart1, chart2) {
+    const chart1InChart2Houses = {};
+    if (chart2.houseCusps) {
+        for (const planet of chart1.planets) {
+            chart1InChart2Houses[planet.name] = (0, formatting_1.getHouse)(planet.degree, chart2.houseCusps);
         }
     }
-    for (let i = 0; i < 12; i++) {
-        const cuspStart = normalizedCusps[i];
-        const cuspEnd = normalizedCusps[(i + 1) % 12];
-        if (cuspStart < cuspEnd) {
-            // Normal case: cusp doesn't cross 0° boundary
-            if (normalizedPoint > cuspStart && normalizedPoint < cuspEnd) {
-                return i + 1;
-            }
-        }
-        else {
-            // Wraparound case: cusp crosses 0°/360° boundary
-            if (normalizedPoint > cuspStart || normalizedPoint < cuspEnd) {
-                return i + 1;
-            }
+    const chart2InChart1Houses = {};
+    if (chart1.houseCusps) {
+        for (const planet of chart2.planets) {
+            chart2InChart1Houses[planet.name] = (0, formatting_1.getHouse)(planet.degree, chart1.houseCusps);
         }
     }
-    // This should never happen if cusps properly cover 360 degrees
-    console.warn(`Point at ${normalizedPoint}° does not fall in any house`);
-    return null;
+    return { chart1InChart2Houses, chart2InChart1Houses };
+}
+function getHouseForPoint(degree, houseCusps) {
+    return (0, formatting_1.getHouse)(degree, houseCusps);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chart2txt",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Convert astrological chart data to human-readable text",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",