chart2txt 0.6.0 → 0.7.1

package/dist/index.d.ts

@@ -4,9 +4,12 @@
  *
  * This is the main entry point for the library.
  */
-export { formatChartToText as chart2txt } from './formatters/text/textFormatter';
+export { chart2txt } from './chart2txt';
+export { analyzeCharts } from './core/analysis';
+export { groupAspects } from './core/grouping';
+export { formatReportToText } from './formatters/text/textFormatter';
 export * from './types';
-export { DEFAULT_SETTINGS, DEFAULT_ASPECTS, DEFAULT_ASPECT_CATEGORIES, ZODIAC_SIGNS, } from './constants';
+export { DEFAULT_SETTINGS, DEFAULT_ASPECTS, ZODIAC_SIGNS } from './constants';
 export { ChartSettings } from './config/ChartSettings';
-import { formatChartToText } from './formatters/text/textFormatter';
-export default formatChartToText;
+import { chart2txt } from './chart2txt';
+export default chart2txt;

package/dist/index.js

@@ -20,21 +20,26 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChartSettings = exports.ZODIAC_SIGNS = exports.DEFAULT_ASPECT_CATEGORIES = exports.DEFAULT_ASPECTS = exports.DEFAULT_SETTINGS = exports.chart2txt = void 0;
-// Core formatter function
+exports.ChartSettings = exports.ZODIAC_SIGNS = exports.DEFAULT_ASPECTS = exports.DEFAULT_SETTINGS = exports.formatReportToText = exports.groupAspects = exports.analyzeCharts = exports.chart2txt = void 0;
+// Core functions
+var chart2txt_1 = require("./chart2txt");
+Object.defineProperty(exports, "chart2txt", { enumerable: true, get: function () { return chart2txt_1.chart2txt; } });
+var analysis_1 = require("./core/analysis");
+Object.defineProperty(exports, "analyzeCharts", { enumerable: true, get: function () { return analysis_1.analyzeCharts; } });
+var grouping_1 = require("./core/grouping");
+Object.defineProperty(exports, "groupAspects", { enumerable: true, get: function () { return grouping_1.groupAspects; } });
 var textFormatter_1 = require("./formatters/text/textFormatter");
-Object.defineProperty(exports, "chart2txt", { enumerable: true, get: function () { return textFormatter_1.formatChartToText; } });
+Object.defineProperty(exports, "formatReportToText", { enumerable: true, get: function () { return textFormatter_1.formatReportToText; } });
 // Export all types for library users
 __exportStar(require("./types"), exports);
 // Export constants that might be useful for users (e.g., for custom settings)
 var constants_1 = require("./constants");
 Object.defineProperty(exports, "DEFAULT_SETTINGS", { enumerable: true, get: function () { return constants_1.DEFAULT_SETTINGS; } });
 Object.defineProperty(exports, "DEFAULT_ASPECTS", { enumerable: true, get: function () { return constants_1.DEFAULT_ASPECTS; } });
-Object.defineProperty(exports, "DEFAULT_ASPECT_CATEGORIES", { enumerable: true, get: function () { return constants_1.DEFAULT_ASPECT_CATEGORIES; } });
 Object.defineProperty(exports, "ZODIAC_SIGNS", { enumerable: true, get: function () { return constants_1.ZODIAC_SIGNS; } });
 // Export ChartSettings class for advanced configuration
 var ChartSettings_1 = require("./config/ChartSettings");
 Object.defineProperty(exports, "ChartSettings", { enumerable: true, get: function () { return ChartSettings_1.ChartSettings; } });
 // Default export for convenience (e.g. UMD builds or simple script tags)
-const textFormatter_2 = require("./formatters/text/textFormatter");
-exports.default = textFormatter_2.formatChartToText;
+const chart2txt_2 = require("./chart2txt");
+exports.default = chart2txt_2.chart2txt;

package/dist/types.d.ts

@@ -17,28 +17,46 @@ export interface ChartData {
 }
 export type MultiChartData = ChartData[];
 export declare function isMultiChartData(obj: ChartData | MultiChartData): obj is MultiChartData;
+export type UnionedPoint = [Point, string];
+export declare enum AspectClassification {
+    Major = "major",
+    Minor = "minor",
+    Esoteric = "esoteric"
+}
+export declare enum PlanetCategory {
+    Luminaries = "luminaries",
+    Personal = "personal",
+    Social = "social",
+    Outer = "outer",
+    Angles = "angles"
+}
 export interface Aspect {
     name: string;
     angle: number;
     orb: number;
+    classification?: AspectClassification;
+}
+export type AspectStrength = 'tight' | 'moderate' | 'wide';
+export interface AspectStrengthThresholds {
+    tight: number;
+    moderate: number;
 }
 export interface AspectData {
     planetA: string;
     planetB: string;
+    p1ChartName?: string;
+    p2ChartName?: string;
     aspectType: string;
     orb: number;
     application?: 'applying' | 'separating' | 'exact';
 }
-export interface AspectCategory {
-    name: string;
-    minOrb?: number;
-    maxOrb: number;
-}
 export interface PlanetPosition {
     name: string;
     degree: number;
     sign: string;
+    speed?: number;
     house?: number;
+    chartName?: string;
 }
 export interface TSquare {
     type: 'T-Square';
@@ -93,15 +111,84 @@ export interface Kite {
     averageOrb: number;
 }
 export type AspectPattern = TSquare | GrandTrine | Stellium | GrandCross | Yod | MysticRectangle | Kite;
-export interface Settings {
-    includeSignDegree: boolean;
-    includeAscendant: boolean;
-    houseSystemName: string;
-    includeHouseDegree: boolean;
-    aspectDefinitions: Aspect[];
-    aspectCategories: AspectCategory[];
-    skipOutOfSignAspects: boolean;
-    includeAspectPatterns: boolean;
-    dateFormat: string;
+export interface ChartAnalysis {
+    chart: ChartData;
+    placements: {
+        planets: PlanetPosition[];
+        [key: string]: any;
+    };
+    aspects: AspectData[];
+    groupedAspects?: Map<string, AspectData[]>;
+    patterns: AspectPattern[];
+    stelliums: Stellium[];
+    signDistributions: {
+        elements: {
+            [key: string]: string[];
+        };
+        modalities: {
+            [key: string]: number;
+        };
+        polarities: {
+            [key: string]: number;
+        };
+    };
+    dispositors: {
+        [key: string]: string;
+    };
+}
+export interface PairwiseAnalysis {
+    chart1: ChartData;
+    chart2: ChartData;
+    synastryAspects: AspectData[];
+    groupedSynastryAspects?: Map<string, AspectData[]>;
+    compositePatterns: AspectPattern[];
+    houseOverlays: {
+        chart1InChart2Houses: {
+            [key: string]: number;
+        };
+        chart2InChart1Houses: {
+            [key: string]: number;
+        };
+    };
+}
+export interface GlobalAnalysis {
+    charts: ChartData[];
+    patterns: AspectPattern[];
+}
+export interface TransitAnalysis {
+    natalChart: ChartData;
+    transitChart: ChartData;
+    aspects: AspectData[];
+    groupedAspects?: Map<string, AspectData[]>;
+    patterns: AspectPattern[];
+}
+export interface AstrologicalReport {
+    settings: Settings;
+    chartAnalyses: ChartAnalysis[];
+    pairwiseAnalyses: PairwiseAnalysis[];
+    globalAnalysis?: GlobalAnalysis;
+    transitAnalyses: TransitAnalysis[];
+    globalTransitAnalysis?: GlobalAnalysis;
+}
+export interface AnalysisSettings {
+    aspectDefinitions?: Aspect[] | 'traditional' | 'modern' | 'tight' | 'wide';
+    skipOutOfSignAspects?: boolean;
+    includeAspectPatterns?: boolean;
+    includeSignDistributions?: boolean;
+    includeDispositors?: boolean | 'finals';
+    includeHouseOverlays?: boolean;
+}
+export interface GroupingSettings {
+    aspectStrengthThresholds?: AspectStrengthThresholds;
+}
+export interface FormattingSettings {
+    dateFormat?: string;
+    houseSystemName?: string;
+}
+export interface Settings extends AnalysisSettings, GroupingSettings, FormattingSettings {
 }
 export type PartialSettings = Partial<Settings>;
+export type ChartDataWithInfo = {
+    data: ChartData;
+    index: number;
+};

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.1",
   "description": "Convert astrological chart data to human-readable text",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",