chart2txt 0.5.2 → 0.6.0

package/dist/formatters/text/sections/signDistributions.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateElementDistributionOutput = generateElementDistributionOutput;
+exports.generateModalityDistributionOutput = generateModalityDistributionOutput;
+exports.generatePolarityOutput = generatePolarityOutput;
+const signDistributions_1 = require("../../../core/signDistributions");
+/**
+ * Generates the [ELEMENT DISTRIBUTION] section of the chart output.
+ * @param planets Array of planet points.
+ * @param chartName Optional chart name for the header.
+ * @param ascendant Optional ascendant degree to include in analysis.
+ * @returns An array of strings for the output.
+ */
+function generateElementDistributionOutput(planets, chartName, ascendant) {
+    const header = chartName
+        ? `[ELEMENT DISTRIBUTION: ${chartName}]`
+        : '[ELEMENT DISTRIBUTION]';
+    const output = [header];
+    if (planets.length === 0) {
+        output.push('No planets available for element analysis.');
+        return output;
+    }
+    const distributions = (0, signDistributions_1.analyzeSignDistributions)(planets, ascendant);
+    const formattedElements = (0, signDistributions_1.formatElementDistribution)(distributions.elements);
+    output.push(...formattedElements);
+    return output;
+}
+/**
+ * Generates the [MODALITY DISTRIBUTION] section of the chart output.
+ * @param planets Array of planet points.
+ * @param chartName Optional chart name for the header.
+ * @param ascendant Optional ascendant degree to include in analysis.
+ * @returns An array of strings for the output.
+ */
+function generateModalityDistributionOutput(planets, chartName, ascendant) {
+    const header = chartName
+        ? `[MODALITY DISTRIBUTION: ${chartName}]`
+        : '[MODALITY DISTRIBUTION]';
+    const output = [header];
+    if (planets.length === 0) {
+        output.push('No planets available for modality analysis.');
+        return output;
+    }
+    const distributions = (0, signDistributions_1.analyzeSignDistributions)(planets, ascendant);
+    const formattedModalities = (0, signDistributions_1.formatModalityDistribution)(distributions.modalities);
+    output.push(...formattedModalities);
+    return output;
+}
+/**
+ * Generates the [POLARITY] section of the chart output.
+ * @param planets Array of planet points.
+ * @param chartName Optional chart name for the header.
+ * @param ascendant Optional ascendant degree to include in analysis.
+ * @returns An array of strings for the output.
+ */
+function generatePolarityOutput(planets, chartName, ascendant) {
+    const header = chartName ? `[POLARITY: ${chartName}]` : '[POLARITY]';
+    const output = [header];
+    if (planets.length === 0) {
+        output.push('No planets available for polarity analysis.');
+        return output;
+    }
+    const distributions = (0, signDistributions_1.analyzeSignDistributions)(planets, ascendant);
+    const formattedPolarities = (0, signDistributions_1.formatPolarityDistribution)(distributions.polarities);
+    output.push(...formattedPolarities);
+    return output;
+}

package/dist/formatters/text/textFormatter.js

@@ -3,23 +3,52 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatChartToText = formatChartToText;
 const types_1 = require("../../types");
 const ChartSettings_1 = require("../../config/ChartSettings");
+const validation_1 = require("../../utils/validation");
 const aspects_1 = require("../../core/aspects");
+const aspectPatterns_1 = require("../../core/aspectPatterns");
+/**
+ * Helper function to get all points (planets + angles) from a chart for aspect calculation
+ */
+function getAllPointsFromChart(chartData) {
+    const allPoints = [...chartData.planets];
+    if (chartData.ascendant !== undefined) {
+        allPoints.push({ name: 'Ascendant', degree: chartData.ascendant });
+    }
+    if (chartData.midheaven !== undefined) {
+        allPoints.push({ name: 'Midheaven', degree: chartData.midheaven });
+    }
+    return allPoints;
+}
 const metadata_1 = require("./sections/metadata");
 const chartHeader_1 = require("./sections/chartHeader");
 const birthdata_1 = require("./sections/birthdata");
 const angles_1 = require("./sections/angles");
+const houses_1 = require("./sections/houses");
 const planets_1 = require("./sections/planets");
+const dispositors_1 = require("./sections/dispositors");
 const aspects_2 = require("./sections/aspects");
+const aspectPatterns_2 = require("./sections/aspectPatterns");
 const houseOverlays_1 = require("./sections/houseOverlays");
+const signDistributions_1 = require("./sections/signDistributions");
 const processSingleChartOutput = (settings, chartData, chartTitlePrefix) => {
     const outputLines = [];
     outputLines.push(...(0, chartHeader_1.generateChartHeaderOutput)(chartData.name, chartTitlePrefix));
     outputLines.push(...(0, birthdata_1.generateBirthdataOutput)(chartData.location, chartData.timestamp, settings));
     outputLines.push(...(0, angles_1.generateAnglesOutput)(chartData.ascendant, chartData.midheaven));
+    outputLines.push(...(0, houses_1.generateHousesOutput)(chartData.houseCusps));
     outputLines.push(...(0, planets_1.generatePlanetsOutput)(chartData.planets, chartData.houseCusps, settings));
-    const aspects = (0, aspects_1.calculateAspects)(settings.aspectDefinitions, chartData.planets, settings.skipOutOfSignAspects);
+    outputLines.push(...(0, dispositors_1.generateDispositorsOutput)(chartData.planets));
+    outputLines.push(...(0, signDistributions_1.generateElementDistributionOutput)(chartData.planets, undefined, chartData.ascendant));
+    outputLines.push(...(0, signDistributions_1.generateModalityDistributionOutput)(chartData.planets, undefined, chartData.ascendant));
+    outputLines.push(...(0, signDistributions_1.generatePolarityOutput)(chartData.planets, undefined, chartData.ascendant));
+    const aspects = (0, aspects_1.calculateAspects)(settings.aspectDefinitions, getAllPointsFromChart(chartData), settings.skipOutOfSignAspects);
     // For single chart, p1ChartName and p2ChartName are not needed for aspect string generation
     outputLines.push(...(0, aspects_2.generateAspectsOutput)('[ASPECTS]', aspects, settings));
+    // Detect and display aspect patterns (if enabled)
+    if (settings.includeAspectPatterns) {
+        const aspectPatterns = (0, aspectPatterns_1.detectAspectPatterns)(chartData.planets, chartData.houseCusps);
+        outputLines.push(...(0, aspectPatterns_2.generateAspectPatternsOutput)(aspectPatterns));
+    }
     outputLines.push('');
     return outputLines;
 };
@@ -31,7 +60,7 @@ const processChartPairOutput = (settings, chart1, chart2) => {
             ? 'NATAL_EVENT'
             : 'SYNASTRY';
     outputLines.push(...(0, chartHeader_1.generateChartHeaderOutput)(`${chart1.name}-${chart2.name}`, header));
-    const synastryAspects = (0, aspects_1.calculateMultichartAspects)(settings.aspectDefinitions, chart1.planets, chart2.planets, settings.skipOutOfSignAspects);
+    const synastryAspects = (0, aspects_1.calculateMultichartAspects)(settings.aspectDefinitions, getAllPointsFromChart(chart1), getAllPointsFromChart(chart2), settings.skipOutOfSignAspects);
     outputLines.push(...(0, aspects_2.generateAspectsOutput)('[PLANET-PLANET ASPECTS]', synastryAspects, settings, chart1.name, chart2.name));
     outputLines.push('');
     outputLines.push(...(0, houseOverlays_1.generateHouseOverlaysOutput)(chart1, chart2, settings));
@@ -107,6 +136,11 @@ const determineChartType = (data) => {
  * @returns A string representing the full chart report.
  */
 function formatChartToText(data, partialSettings = {}) {
+    // Validate input data
+    const validationError = (0, validation_1.validateInputData)(data);
+    if (validationError) {
+        throw new Error(`Invalid chart data: ${validationError}`);
+    }
     const settings = new ChartSettings_1.ChartSettings(partialSettings);
     const houseSystemName = settings.houseSystemName;
     const outputLines = [];
@@ -142,7 +176,7 @@ function formatChartToText(data, partialSettings = {}) {
         outputLines.push(...processTransitChartInfoOutput(settings, transitChart));
         for (const chart of nonTransitCharts) {
             // Transit Aspects to Chart 1
-            const transitAspectsC1 = (0, aspects_1.calculateMultichartAspects)(settings.aspectDefinitions, chart.planets, transitChart.planets, settings.skipOutOfSignAspects);
+            const transitAspectsC1 = (0, aspects_1.calculateMultichartAspects)(settings.aspectDefinitions, getAllPointsFromChart(chart), getAllPointsFromChart(transitChart), settings.skipOutOfSignAspects);
             outputLines.push(...(0, aspects_2.generateAspectsOutput)(`[TRANSIT ASPECTS: ${chart.name}]`, transitAspectsC1, settings, chart.name, transitChart.name, true));
             outputLines.push('');
         }

package/dist/types.d.ts

@@ -27,12 +27,72 @@ export interface AspectData {
     planetB: 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;
+    house?: number;
+}
+export interface TSquare {
+    type: 'T-Square';
+    apex: PlanetPosition;
+    opposition: [PlanetPosition, PlanetPosition];
+    mode: 'Cardinal' | 'Fixed' | 'Mutable';
+    averageOrb: number;
+}
+export interface GrandTrine {
+    type: 'Grand Trine';
+    planets: [PlanetPosition, PlanetPosition, PlanetPosition];
+    element: 'Fire' | 'Earth' | 'Air' | 'Water';
+    averageOrb: number;
+}
+export interface Stellium {
+    type: 'Stellium';
+    planets: PlanetPosition[];
+    sign?: string;
+    houses: number[];
+    span: number;
+}
+export interface GrandCross {
+    type: 'Grand Cross';
+    planets: [PlanetPosition, PlanetPosition, PlanetPosition, PlanetPosition];
+    mode: 'Cardinal' | 'Fixed' | 'Mutable';
+    averageOrb: number;
+}
+export interface Yod {
+    type: 'Yod';
+    apex: PlanetPosition;
+    base: [PlanetPosition, PlanetPosition];
+    averageOrb: number;
+}
+export interface MysticRectangle {
+    type: 'Mystic Rectangle';
+    oppositions: [
+        [
+            PlanetPosition,
+            PlanetPosition
+        ],
+        [
+            PlanetPosition,
+            PlanetPosition
+        ]
+    ];
+    averageOrb: number;
+}
+export interface Kite {
+    type: 'Kite';
+    grandTrine: [PlanetPosition, PlanetPosition, PlanetPosition];
+    opposition: PlanetPosition;
+    averageOrb: number;
+}
+export type AspectPattern = TSquare | GrandTrine | Stellium | GrandCross | Yod | MysticRectangle | Kite;
 export interface Settings {
     includeSignDegree: boolean;
     includeAscendant: boolean;
@@ -41,6 +101,7 @@ export interface Settings {
     aspectDefinitions: Aspect[];
     aspectCategories: AspectCategory[];
     skipOutOfSignAspects: boolean;
+    includeAspectPatterns: boolean;
     dateFormat: string;
 }
 export type PartialSettings = Partial<Settings>;

package/dist/utils/formatting.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 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;

package/dist/utils/formatting.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrdinal = getOrdinal;
+/**
+ * Converts a number to its ordinal form (1st, 2nd, 3rd, etc.)
+ * @param num The number to convert
+ * @returns The ordinal string
+ */
+function getOrdinal(num) {
+    const suffix = ['th', 'st', 'nd', 'rd'];
+    const v = num % 100;
+    return num + (suffix[(v - 20) % 10] || suffix[v] || suffix[0]);
+}

package/dist/utils/houseCalculations.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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;

package/dist/utils/houseCalculations.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateHouseCusps = validateHouseCusps;
+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;
+        }
+    }
+    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;
+            }
+        }
+    }
+    // This should never happen if cusps properly cover 360 degrees
+    console.warn(`Point at ${normalizedPoint}° does not fall in any house`);
+    return null;
+}

package/dist/utils/precision.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Floating point precision utilities for astrological calculations
+ */
+export declare const DEFAULT_EPSILON = 0.0001;
+/**
+ * Compares two floating-point numbers with epsilon tolerance
+ * @param a First number
+ * @param b Second number
+ * @param epsilon Tolerance value (default: DEFAULT_EPSILON)
+ * @returns True if numbers are equal within tolerance
+ */
+export declare function floatEquals(a: number, b: number, epsilon?: number): boolean;
+/**
+ * Checks if a number is close to zero within epsilon tolerance
+ * @param value The number to check
+ * @param epsilon Tolerance value (default: DEFAULT_EPSILON)
+ * @returns True if number is close to zero
+ */
+export declare function isNearZero(value: number, epsilon?: number): boolean;
+/**
+ * Rounds a degree value to a reasonable precision (4 decimal places)
+ * This prevents accumulation of floating-point errors in calculations
+ * @param degrees The degree value to round
+ * @returns Rounded degree value
+ */
+export declare function roundDegrees(degrees: number): number;
+/**
+ * Compares two degree values with appropriate epsilon for astrological calculations
+ * @param deg1 First degree value
+ * @param deg2 Second degree value
+ * @param epsilon Tolerance in degrees (default: 0.0001°)
+ * @returns True if degrees are equal within tolerance
+ */
+export declare function degreeEquals(deg1: number, deg2: number, epsilon?: number): boolean;
+/**
+ * Checks if a planet is exactly on a house cusp within floating-point precision
+ * @param planetDegree Planet's degree position
+ * @param cuspDegree House cusp degree
+ * @param epsilon Tolerance in degrees (default: 0.001° = about 3.6 arc-seconds)
+ * @returns True if planet is on the cusp within tolerance
+ */
+export declare function isOnCusp(planetDegree: number, cuspDegree: number, epsilon?: number): boolean;
+/**
+ * Checks if an aspect is exact within floating-point precision
+ * @param actualOrb The actual orb of the aspect
+ * @param epsilon Tolerance in degrees (default: 0.1° = 6 arc-minutes)
+ * @returns True if aspect is exact within tolerance
+ */
+export declare function isExactAspect(actualOrb: number, epsilon?: number): boolean;

package/dist/utils/precision.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * Floating point precision utilities for astrological calculations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_EPSILON = void 0;
+exports.floatEquals = floatEquals;
+exports.isNearZero = isNearZero;
+exports.roundDegrees = roundDegrees;
+exports.degreeEquals = degreeEquals;
+exports.isOnCusp = isOnCusp;
+exports.isExactAspect = isExactAspect;
+// Default epsilon for floating-point comparisons (about 0.0036 arc-minutes)
+exports.DEFAULT_EPSILON = 1e-4;
+/**
+ * Compares two floating-point numbers with epsilon tolerance
+ * @param a First number
+ * @param b Second number
+ * @param epsilon Tolerance value (default: DEFAULT_EPSILON)
+ * @returns True if numbers are equal within tolerance
+ */
+function floatEquals(a, b, epsilon = exports.DEFAULT_EPSILON) {
+    return Math.abs(a - b) < epsilon;
+}
+/**
+ * Checks if a number is close to zero within epsilon tolerance
+ * @param value The number to check
+ * @param epsilon Tolerance value (default: DEFAULT_EPSILON)
+ * @returns True if number is close to zero
+ */
+function isNearZero(value, epsilon = exports.DEFAULT_EPSILON) {
+    return Math.abs(value) < epsilon;
+}
+/**
+ * Rounds a degree value to a reasonable precision (4 decimal places)
+ * This prevents accumulation of floating-point errors in calculations
+ * @param degrees The degree value to round
+ * @returns Rounded degree value
+ */
+function roundDegrees(degrees) {
+    return Math.round(degrees * 10000) / 10000;
+}
+/**
+ * Compares two degree values with appropriate epsilon for astrological calculations
+ * @param deg1 First degree value
+ * @param deg2 Second degree value
+ * @param epsilon Tolerance in degrees (default: 0.0001°)
+ * @returns True if degrees are equal within tolerance
+ */
+function degreeEquals(deg1, deg2, epsilon = exports.DEFAULT_EPSILON) {
+    return floatEquals(deg1, deg2, epsilon);
+}
+/**
+ * Checks if a planet is exactly on a house cusp within floating-point precision
+ * @param planetDegree Planet's degree position
+ * @param cuspDegree House cusp degree
+ * @param epsilon Tolerance in degrees (default: 0.001° = about 3.6 arc-seconds)
+ * @returns True if planet is on the cusp within tolerance
+ */
+function isOnCusp(planetDegree, cuspDegree, epsilon = 0.001) {
+    return degreeEquals(planetDegree, cuspDegree, epsilon);
+}
+/**
+ * Checks if an aspect is exact within floating-point precision
+ * @param actualOrb The actual orb of the aspect
+ * @param epsilon Tolerance in degrees (default: 0.1° = 6 arc-minutes)
+ * @returns True if aspect is exact within tolerance
+ */
+function isExactAspect(actualOrb, epsilon = 0.1) {
+    return isNearZero(actualOrb, epsilon);
+}

package/dist/utils/validation.d.ts

@@ -0,0 +1,37 @@
+import { ChartData, Point, MultiChartData } from '../types';
+/**
+ * Validates a Point object
+ * @param point The point to validate
+ * @returns Error message if invalid, null if valid
+ */
+export declare function validatePoint(point: Point): string | null;
+/**
+ * Validates an array of Points
+ * @param points The points array to validate
+ * @returns Error message if invalid, null if valid
+ */
+export declare function validatePoints(points: Point[]): string | null;
+/**
+ * Validates house cusps array
+ * @param houseCusps The house cusps to validate
+ * @returns Error message if invalid, null if valid
+ */
+export declare function validateHouseCusps(houseCusps: number[] | undefined): string | null;
+/**
+ * Validates a ChartData object
+ * @param chartData The chart data to validate
+ * @returns Error message if invalid, null if valid
+ */
+export declare function validateChartData(chartData: ChartData): string | null;
+/**
+ * Validates MultiChartData
+ * @param multiChartData The multi-chart data to validate
+ * @returns Error message if invalid, null if valid
+ */
+export declare function validateMultiChartData(multiChartData: MultiChartData): string | null;
+/**
+ * Validates chart data (single or multi-chart)
+ * @param data The data to validate
+ * @returns Error message if invalid, null if valid
+ */
+export declare function validateInputData(data: ChartData | MultiChartData): string | null;

package/dist/utils/validation.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePoint = validatePoint;
+exports.validatePoints = validatePoints;
+exports.validateHouseCusps = validateHouseCusps;
+exports.validateChartData = validateChartData;
+exports.validateMultiChartData = validateMultiChartData;
+exports.validateInputData = validateInputData;
+/**
+ * Validates a Point object
+ * @param point The point to validate
+ * @returns Error message if invalid, null if valid
+ */
+function validatePoint(point) {
+    if (!point || typeof point !== 'object') {
+        return 'Point must be an object';
+    }
+    if (typeof point.name !== 'string' || point.name.trim() === '') {
+        return 'Point name must be a non-empty string';
+    }
+    if (typeof point.degree !== 'number' || !isFinite(point.degree)) {
+        return `Point ${point.name} has invalid degree value: ${point.degree}`;
+    }
+    if (point.speed !== undefined &&
+        (typeof point.speed !== 'number' || !isFinite(point.speed))) {
+        return `Point ${point.name} has invalid speed value: ${point.speed}`;
+    }
+    return null;
+}
+/**
+ * Validates an array of Points
+ * @param points The points array to validate
+ * @returns Error message if invalid, null if valid
+ */
+function validatePoints(points) {
+    if (!Array.isArray(points)) {
+        return 'Points must be an array';
+    }
+    for (let i = 0; i < points.length; i++) {
+        const error = validatePoint(points[i]);
+        if (error) {
+            return `Point at index ${i}: ${error}`;
+        }
+    }
+    // Check for duplicate point names
+    const names = points.map((p) => p.name);
+    const duplicates = names.filter((name, index) => names.indexOf(name) !== index);
+    if (duplicates.length > 0) {
+        return `Duplicate point names found: ${duplicates.join(', ')}`;
+    }
+    return null;
+}
+/**
+ * Validates house cusps array
+ * @param houseCusps The house cusps to validate
+ * @returns Error message if invalid, null if valid
+ */
+function validateHouseCusps(houseCusps) {
+    if (houseCusps === undefined) {
+        return null; // Optional field
+    }
+    if (!Array.isArray(houseCusps)) {
+        return 'House cusps must be an array';
+    }
+    if (houseCusps.length !== 12) {
+        return `House cusps must contain exactly 12 values, got ${houseCusps.length}`;
+    }
+    for (let i = 0; i < houseCusps.length; i++) {
+        if (typeof houseCusps[i] !== 'number' || !isFinite(houseCusps[i])) {
+            return `House cusp ${i + 1} has invalid value: ${houseCusps[i]}`;
+        }
+    }
+    return null;
+}
+/**
+ * Validates a ChartData object
+ * @param chartData The chart data to validate
+ * @returns Error message if invalid, null if valid
+ */
+function validateChartData(chartData) {
+    if (!chartData || typeof chartData !== 'object') {
+        return 'Chart data must be an object';
+    }
+    if (typeof chartData.name !== 'string' || chartData.name.trim() === '') {
+        return 'Chart name must be a non-empty string';
+    }
+    const pointsError = validatePoints(chartData.planets);
+    if (pointsError) {
+        return `Planets validation failed: ${pointsError}`;
+    }
+    if (chartData.ascendant !== undefined) {
+        if (typeof chartData.ascendant !== 'number' ||
+            !isFinite(chartData.ascendant)) {
+            return `Ascendant has invalid value: ${chartData.ascendant}`;
+        }
+    }
+    if (chartData.midheaven !== undefined) {
+        if (typeof chartData.midheaven !== 'number' ||
+            !isFinite(chartData.midheaven)) {
+            return `Midheaven has invalid value: ${chartData.midheaven}`;
+        }
+    }
+    const houseCuspsError = validateHouseCusps(chartData.houseCusps);
+    if (houseCuspsError) {
+        return `House cusps validation failed: ${houseCuspsError}`;
+    }
+    if (chartData.points !== undefined) {
+        const pointsError = validatePoints(chartData.points);
+        if (pointsError) {
+            return `Additional points validation failed: ${pointsError}`;
+        }
+    }
+    if (chartData.timestamp !== undefined) {
+        if (!(chartData.timestamp instanceof Date) ||
+            isNaN(chartData.timestamp.getTime())) {
+            return 'Timestamp must be a valid Date object';
+        }
+    }
+    if (chartData.location !== undefined) {
+        if (typeof chartData.location !== 'string') {
+            return 'Location must be a string';
+        }
+    }
+    if (chartData.chartType !== undefined) {
+        const validTypes = ['natal', 'event', 'transit'];
+        if (!validTypes.includes(chartData.chartType)) {
+            return `Chart type must be one of: ${validTypes.join(', ')}`;
+        }
+    }
+    return null;
+}
+/**
+ * Validates MultiChartData
+ * @param multiChartData The multi-chart data to validate
+ * @returns Error message if invalid, null if valid
+ */
+function validateMultiChartData(multiChartData) {
+    if (!Array.isArray(multiChartData)) {
+        return 'Multi-chart data must be an array';
+    }
+    if (multiChartData.length === 0) {
+        return 'Multi-chart data must contain at least one chart';
+    }
+    if (multiChartData.length > 10) {
+        return 'Multi-chart data cannot contain more than 10 charts';
+    }
+    for (let i = 0; i < multiChartData.length; i++) {
+        const error = validateChartData(multiChartData[i]);
+        if (error) {
+            return `Chart at index ${i} (${multiChartData[i]?.name || 'unnamed'}): ${error}`;
+        }
+    }
+    // Check for duplicate chart names
+    const names = multiChartData.map((chart) => chart.name);
+    const duplicates = names.filter((name, index) => names.indexOf(name) !== index);
+    if (duplicates.length > 0) {
+        return `Duplicate chart names found: ${duplicates.join(', ')}`;
+    }
+    // Validate transit charts
+    const transitCharts = multiChartData.filter((chart) => chart.chartType === 'transit');
+    if (transitCharts.length > 1) {
+        return 'Cannot have more than one transit chart';
+    }
+    return null;
+}
+/**
+ * Validates chart data (single or multi-chart)
+ * @param data The data to validate
+ * @returns Error message if invalid, null if valid
+ */
+function validateInputData(data) {
+    if (!data) {
+        return 'Data is required';
+    }
+    if (Array.isArray(data)) {
+        return validateMultiChartData(data);
+    }
+    else {
+        return validateChartData(data);
+    }
+}