chart2txt 0.6.0 → 0.7.0

package/dist/core/aspects.d.ts

@@ -1,17 +1,20 @@
-import { Point, Aspect, AspectData } from '../types';
+import { Aspect, AspectData, UnionedPoint } from '../types';
 /**
- * Identifies aspects between planets in a single chart.
+ * Unified aspect calculation function that handles both single-chart and multi-chart scenarios
  * @param aspectDefinitions Array of aspect types to check for.
- * @param planets Array of planet points.
+ * @param unionedPlanets Array of UnionedPoint pairs to analyze.
+ * @param skipOutOfSignAspects Whether to skip aspects that cross sign boundaries.
+ * @param aspectStrengthThresholds Thresholds for classifying aspect strength.
+ * @param forceChartType Optional override for chart type determination.
  * @returns Array of found aspects.
  */
-export declare function calculateAspects(aspectDefinitions: Aspect[], planets: Point[], skipOutOfSignAspects?: boolean): AspectData[];
+export declare function calculateAspects(aspectDefinitions: Aspect[], unionedPlanets: UnionedPoint[], skipOutOfSignAspects?: boolean): AspectData[];
 /**
- * Identifies aspects between planets across two charts.
- * PlanetA is always from chart1Planets, PlanetB always from chart2Planets.
- * @param aspectDefinitions Array of aspect types to check for.
- * @param chart1Planets Array of planet points for the first chart.
- * @param chart2Planets Array of planet points for the second chart.
- * @returns Array of found aspects.
+ * Calculates aspects in a multi-chart context (synastry, transits, etc.)
+ * @param aspectDefinitions Array of aspect types to check for
+ * @param unionedPlanets Array of UnionedPoint pairs to analyze
+ * @param skipOutOfSignAspects Whether to skip aspects that cross sign boundaries
+ * @param aspectStrengthThresholds Thresholds for classifying aspect strength
+ * @returns Array of found aspects
  */
-export declare function calculateMultichartAspects(aspectDefinitions: Aspect[], chart1Planets: Point[], chart2Planets: Point[], skipOutOfSignAspects?: boolean): AspectData[];
+export declare function calculateMultichartAspects(aspectDefinitions: Aspect[], unionedPlanets: UnionedPoint[], skipOutOfSignAspects?: boolean): AspectData[];

package/dist/core/aspects.js

@@ -81,7 +81,18 @@ function determineAspectApplication(planetA, planetB, aspectAngle) {
     const isApplying = futureAspectDistance < currentAspectDistance;
     return isApplying ? 'applying' : 'separating';
 }
-function findTightestAspect(aspectDefinitions, planetA, planetB, skipOutOfSignAspects) {
+/**
+ * Finds the tightest aspect between two planets using simple orb detection
+ * @param aspectDefinitions Array of aspect types to check for
+ * @param planetA First planet
+ * @param planetB Second planet
+ * @param skipOutOfSignAspects Whether to skip aspects that cross sign boundaries
+ * @param aspectStrengthThresholds Thresholds for classifying aspect strength
+ * @param p1ChartName Optional chart name for planetA
+ * @param p2ChartName Optional chart name for planetB
+ * @returns The tightest aspect found, or null if none
+ */
+function findTightestAspect(aspectDefinitions, planetA, planetB, skipOutOfSignAspects, p1ChartName, p2ChartName) {
     const degreeA = (0, precision_1.roundDegrees)((0, astrology_1.normalizeDegree)(planetA.degree));
     const degreeB = (0, precision_1.roundDegrees)((0, astrology_1.normalizeDegree)(planetB.degree));
     let diff = Math.abs(degreeA - degreeB);
@@ -94,7 +105,6 @@ function findTightestAspect(aspectDefinitions, planetA, planetB, skipOutOfSignAs
             const planetASign = Math.floor(degreeA / 30);
             const planetBSign = Math.floor(degreeB / 30);
             // Calculate expected sign difference for this aspect
-            // For major aspects: 0° = 0 signs, 60° = 2 signs, 90° = 3 signs, 120° = 4 signs, 180° = 6 signs
             const expectedSignDiff = getExpectedSignDifference(aspectType.angle);
             let actualSignDiff = Math.abs(planetASign - planetBSign);
             if (actualSignDiff > 6)
@@ -103,12 +113,16 @@ function findTightestAspect(aspectDefinitions, planetA, planetB, skipOutOfSignAs
                 continue;
             }
         }
-        if (orb <= aspectType.orb) {
+        // Use simple orb from aspect definition
+        const maxAllowedOrb = aspectType.orb;
+        if (orb <= maxAllowedOrb) {
             if (!tightestAspect || orb < tightestAspect.orb) {
                 const application = determineAspectApplication(planetA, planetB, aspectType.angle);
                 tightestAspect = {
                     planetA: planetA.name,
                     planetB: planetB.name,
+                    p1ChartName,
+                    p2ChartName,
                     aspectType: aspectType.name,
                     orb,
                     application,
@@ -119,20 +133,23 @@ function findTightestAspect(aspectDefinitions, planetA, planetB, skipOutOfSignAs
     return tightestAspect;
 }
 /**
- * Identifies aspects between planets in a single chart.
+ * Unified aspect calculation function that handles both single-chart and multi-chart scenarios
  * @param aspectDefinitions Array of aspect types to check for.
- * @param planets Array of planet points.
+ * @param unionedPlanets Array of UnionedPoint pairs to analyze.
+ * @param skipOutOfSignAspects Whether to skip aspects that cross sign boundaries.
+ * @param aspectStrengthThresholds Thresholds for classifying aspect strength.
+ * @param forceChartType Optional override for chart type determination.
  * @returns Array of found aspects.
  */
-function calculateAspects(aspectDefinitions, planets, skipOutOfSignAspects = true) {
+function calculateAspects(aspectDefinitions, unionedPlanets, skipOutOfSignAspects = true) {
     const aspects = [];
-    if (!planets || planets.length < 2)
+    if (!unionedPlanets || unionedPlanets.length < 2)
         return aspects;
-    for (let i = 0; i < planets.length; i++) {
-        for (let j = i + 1; j < planets.length; j++) {
-            const planetA = planets[i];
-            const planetB = planets[j];
-            const aspect = findTightestAspect(aspectDefinitions, planetA, planetB, skipOutOfSignAspects);
+    for (let i = 0; i < unionedPlanets.length; i++) {
+        for (let j = i + 1; j < unionedPlanets.length; j++) {
+            const [planetA, chartNameA] = unionedPlanets[i];
+            const [planetB, chartNameB] = unionedPlanets[j];
+            const aspect = findTightestAspect(aspectDefinitions, planetA, planetB, skipOutOfSignAspects, chartNameA, chartNameB);
             if (aspect) {
                 aspects.push(aspect);
             }
@@ -141,28 +158,28 @@ function calculateAspects(aspectDefinitions, planets, skipOutOfSignAspects = tru
     return aspects;
 }
 /**
- * Identifies aspects between planets across two charts.
- * PlanetA is always from chart1Planets, PlanetB always from chart2Planets.
- * @param aspectDefinitions Array of aspect types to check for.
- * @param chart1Planets Array of planet points for the first chart.
- * @param chart2Planets Array of planet points for the second chart.
- * @returns Array of found aspects.
+ * Calculates aspects in a multi-chart context (synastry, transits, etc.)
+ * @param aspectDefinitions Array of aspect types to check for
+ * @param unionedPlanets Array of UnionedPoint pairs to analyze
+ * @param skipOutOfSignAspects Whether to skip aspects that cross sign boundaries
+ * @param aspectStrengthThresholds Thresholds for classifying aspect strength
+ * @returns Array of found aspects
  */
-function calculateMultichartAspects(aspectDefinitions, chart1Planets, chart2Planets, skipOutOfSignAspects = true) {
-    const aspects = [];
-    if (!chart1Planets ||
-        !chart2Planets ||
-        chart1Planets.length === 0 ||
-        chart2Planets.length === 0) {
-        return aspects;
-    }
-    for (const p1 of chart1Planets) {
-        for (const p2 of chart2Planets) {
-            const aspect = findTightestAspect(aspectDefinitions, p1, p2, skipOutOfSignAspects);
-            if (aspect) {
-                aspects.push(aspect);
+function calculateMultichartAspects(aspectDefinitions, unionedPlanets, skipOutOfSignAspects = true) {
+    // Filter to only cross-chart aspects
+    const crossChartAspects = [];
+    for (let i = 0; i < unionedPlanets.length; i++) {
+        for (let j = i + 1; j < unionedPlanets.length; j++) {
+            const [planetA, chartNameA] = unionedPlanets[i];
+            const [planetB, chartNameB] = unionedPlanets[j];
+            // Only calculate aspects between planets from different charts
+            if (chartNameA !== chartNameB) {
+                const aspect = findTightestAspect(aspectDefinitions, planetA, planetB, skipOutOfSignAspects, chartNameA, chartNameB);
+                if (aspect) {
+                    crossChartAspects.push(aspect);
+                }
             }
         }
     }
-    return aspects;
+    return crossChartAspects;
 }

package/dist/core/dignities.d.ts

@@ -1,27 +1,2 @@
-import { Point } from '../types';
-export interface DignityInfo {
-    rulers: string[];
-    exaltation?: string;
-    detriment?: string;
-    fall?: string;
-}
-/**
- * Gets the essential dignities for a planet in a specific sign
- * @param planetName Name of the planet
- * @param sign The zodiac sign
- * @returns Array of dignity descriptions
- */
-export declare function getPlanetDignities(planetName: string, sign: string): string[];
-/**
- * Gets the ruler(s) of a zodiac sign
- * @param sign The zodiac sign
- * @returns Array of ruling planets
- */
-export declare function getSignRulers(sign: string): string[];
-/**
- * Formats planet dignities for display
- * @param planet The planet point
- * @param houseCusps Array of house cusps (optional)
- * @returns Formatted string with dignities
- */
-export declare function formatPlanetWithDignities(planet: Point, houseCusps?: number[]): string;
+import { PlanetPosition } from '../types';
+export declare function formatPlanetWithDignities(planet: PlanetPosition): string;

package/dist/core/dignities.js

@@ -1,136 +1,71 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPlanetDignities = getPlanetDignities;
-exports.getSignRulers = getSignRulers;
 exports.formatPlanetWithDignities = formatPlanetWithDignities;
-const astrology_1 = require("./astrology");
-// Essential dignity mappings
-const SIGN_DIGNITIES = {
-    Aries: {
-        rulers: ['Mars'],
-        exaltation: 'Sun',
-        detriment: 'Venus',
-        fall: 'Saturn',
+const constants_1 = require("../constants");
+const DIGNITY_MAP = {
+    Sun: {
+        Leo: ['Domicile'],
+        Aries: ['Exaltation'],
+        Aquarius: ['Detriment'],
+        Libra: ['Fall'],
     },
-    Taurus: {
-        rulers: ['Venus'],
-        exaltation: 'Moon',
-        detriment: 'Mars',
-        fall: 'Uranus',
+    Moon: {
+        Cancer: ['Domicile'],
+        Taurus: ['Exaltation'],
+        Capricorn: ['Detriment'],
+        Scorpio: ['Fall'],
     },
-    Gemini: {
-        rulers: ['Mercury'],
-        detriment: 'Jupiter',
+    Mercury: {
+        Gemini: ['Domicile'],
+        Virgo: ['Domicile', 'Exaltation'],
+        Pisces: ['Detriment', 'Fall'],
+        Sagittarius: ['Detriment'],
     },
-    Cancer: {
-        rulers: ['Moon'],
-        exaltation: 'Jupiter',
-        detriment: 'Saturn',
-        fall: 'Mars',
+    Venus: {
+        Taurus: ['Domicile'],
+        Libra: ['Domicile'],
+        Scorpio: ['Detriment'],
+        Aries: ['Fall'],
+        Virgo: ['Fall'],
     },
-    Leo: {
-        rulers: ['Sun'],
-        detriment: 'Saturn',
-        fall: 'Neptune',
+    Mars: {
+        Aries: ['Domicile'],
+        Scorpio: ['Domicile'],
+        Libra: ['Detriment'],
+        Cancer: ['Fall'],
     },
-    Virgo: {
-        rulers: ['Mercury'],
-        exaltation: 'Mercury',
-        detriment: 'Jupiter',
-        fall: 'Venus',
+    Jupiter: {
+        Sagittarius: ['Domicile'],
+        Pisces: ['Domicile'],
+        Gemini: ['Detriment'],
+        Virgo: ['Fall'],
     },
-    Libra: {
-        rulers: ['Venus'],
-        exaltation: 'Saturn',
-        detriment: 'Mars',
-        fall: 'Sun',
-    },
-    Scorpio: {
-        rulers: ['Mars'],
-        detriment: 'Venus',
-        fall: 'Moon',
-    },
-    Sagittarius: {
-        rulers: ['Jupiter'],
-        detriment: 'Mercury',
-    },
-    Capricorn: {
-        rulers: ['Saturn'],
-        exaltation: 'Mars',
-        detriment: 'Moon',
-        fall: 'Jupiter',
-    },
-    Aquarius: {
-        rulers: ['Saturn'],
-        detriment: 'Sun',
-        fall: 'Neptune',
-    },
-    Pisces: {
-        rulers: ['Jupiter'],
-        exaltation: 'Venus',
-        detriment: 'Mercury',
-        fall: 'Mercury',
+    Saturn: {
+        Capricorn: ['Domicile'],
+        Aquarius: ['Domicile'],
+        Cancer: ['Detriment'],
+        Leo: ['Fall'],
     },
 };
-/**
- * Gets the essential dignities for a planet in a specific sign
- * @param planetName Name of the planet
- * @param sign The zodiac sign
- * @returns Array of dignity descriptions
- */
-function getPlanetDignities(planetName, sign) {
-    const dignities = [];
-    const normalizedSign = sign.trim();
-    const signInfo = SIGN_DIGNITIES[normalizedSign];
-    if (!signInfo)
-        return dignities;
-    // Check for rulership (domicile)
-    if (signInfo.rulers.includes(planetName)) {
-        dignities.push(`Domicile`);
-    }
-    // Check for exaltation
-    if (signInfo.exaltation === planetName) {
-        dignities.push(`Exaltation`);
-    }
-    // Check for detriment
-    if (signInfo.detriment === planetName) {
-        dignities.push(`Detriment`);
-    }
-    // Check for fall
-    if (signInfo.fall && signInfo.fall === planetName) {
-        dignities.push(`Fall`);
-    }
-    return dignities;
-}
-/**
- * Gets the ruler(s) of a zodiac sign
- * @param sign The zodiac sign
- * @returns Array of ruling planets
- */
-function getSignRulers(sign) {
-    const normalizedSign = sign.trim();
-    const signInfo = SIGN_DIGNITIES[normalizedSign];
-    return signInfo ? signInfo.rulers : [];
-}
-/**
- * Formats planet dignities for display
- * @param planet The planet point
- * @param houseCusps Array of house cusps (optional)
- * @returns Formatted string with dignities
- */
-function formatPlanetWithDignities(planet, houseCusps) {
-    const sign = (0, astrology_1.getDegreeSign)(planet.degree);
-    const dignities = getPlanetDignities(planet.name, sign);
-    const rulers = getSignRulers(sign);
-    let dignitiesStr = '';
-    if (dignities.length > 0 && dignities.includes('Domicile')) {
-        dignitiesStr = `[${dignities.join(', ')}]`;
+function formatPlanetWithDignities(planet) {
+    const sign = planet.sign;
+    const dignities = DIGNITY_MAP[planet.name];
+    const ruler = constants_1.ZODIAC_SIGN_DATA.find((s) => s.name === sign)?.ruler;
+    const dignityParts = [];
+    if (dignities && dignities[sign]) {
+        dignityParts.push(...dignities[sign]);
     }
-    else if (dignities.length > 0 && rulers.length > 0) {
-        dignitiesStr = `[${dignities.join(', ')} | Ruler: ${rulers.join(', ')}]`;
+    let dignityString = dignityParts.join(', ');
+    if (ruler && planet.name !== ruler) {
+        if (dignityString) {
+            dignityString += ` | Ruler: ${ruler}`;
+        }
+        else {
+            dignityString = `Ruler: ${ruler}`;
+        }
     }
-    else if (rulers.length > 0) {
-        dignitiesStr = `[Ruler: ${rulers.join(', ')}]`;
+    if (dignityString) {
+        return `[${dignityString}]`;
     }
-    return dignitiesStr;
+    return '';
 }

package/dist/core/dispositors.d.ts

@@ -1,22 +1,9 @@
 import { Point } from '../types';
-export interface DispositorChain {
-    planet: string;
-    disposedBy: string[];
-    disposes: string[];
-}
-export interface DispositorAnalysis {
-    chains: DispositorChain[];
-    finalDispositors: string[];
-}
 /**
- * Builds dispositor chains for all planets
- * @param planets Array of planet points
- * @returns Complete dispositor analysis
+ * Calculates the full dispositor chain for each planet in the chart.
+ * @param planets The list of planets in the chart.
+ * @returns A map of each planet to its full dispositor chain string.
  */
-export declare function analyzeDispositors(planets: Point[]): DispositorAnalysis;
-/**
- * Formats the dispositor analysis for display
- * @param analysis The dispositor analysis
- * @returns Array of formatted strings
- */
-export declare function formatDispositorAnalysis(analysis: DispositorAnalysis): string[];
+export declare function calculateDispositors(planets: Point[]): {
+    [key: string]: string;
+};

package/dist/core/dispositors.js

@@ -1,143 +1,57 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.analyzeDispositors = analyzeDispositors;
-exports.formatDispositorAnalysis = formatDispositorAnalysis;
-const astrology_1 = require("./astrology");
-const dignities_1 = require("./dignities");
+exports.calculateDispositors = calculateDispositors;
+const constants_1 = require("../constants");
+const formatting_1 = require("../utils/formatting");
 /**
- * Builds dispositor chains for all planets
- * @param planets Array of planet points
- * @returns Complete dispositor analysis
+ * Calculates the dispositor for a single planet.
+ * @param planet The planet to find the dispositor for.
+ * @returns The name of the dispositor planet.
  */
-function analyzeDispositors(planets) {
-    const dispositorMap = new Map();
-    const disposedByMap = new Map();
-    // Build the dispositor relationships
-    planets.forEach((planet) => {
-        const sign = (0, astrology_1.getDegreeSign)(planet.degree);
-        const rulers = (0, dignities_1.getSignRulers)(sign);
-        dispositorMap.set(planet.name, rulers);
-        rulers.forEach((ruler) => {
-            if (!disposedByMap.has(ruler)) {
-                disposedByMap.set(ruler, []);
-            }
-            disposedByMap.get(ruler).push(planet.name);
-        });
-    });
-    // Find final dispositors - these are the roots of dispositor trees
-    const finalDispositors = [];
-    const planetNames = new Set(planets.map((p) => p.name));
-    planets.forEach((planet) => {
-        const rulers = dispositorMap.get(planet.name) || [];
-        const isRuledBySelf = rulers.includes(planet.name);
-        const isRuledByPlanetNotInChart = rulers.length > 0 && !rulers.some((ruler) => planetNames.has(ruler));
-        // A planet is a final dispositor if:
-        // 1. It rules itself (traditional dignity)
-        // 2. It's ruled by a planet not in the chart
-        if (isRuledBySelf || isRuledByPlanetNotInChart) {
-            finalDispositors.push(planet.name);
-        }
-    });
-    // Build chains
-    const chains = planets.map((planet) => ({
-        planet: planet.name,
-        disposedBy: dispositorMap.get(planet.name) || [],
-        disposes: disposedByMap.get(planet.name) || [],
-    }));
-    return {
-        chains,
-        finalDispositors,
-    };
+function getDispositor(planet) {
+    const sign = (0, formatting_1.getSign)(planet.degree);
+    const signData = constants_1.ZODIAC_SIGN_DATA.find((s) => s.name === sign);
+    return signData ? signData.ruler : 'Unknown';
 }
 /**
- * Detect cycles in dispositor chains
+ * Calculates the full dispositor chain for each planet in the chart.
+ * @param planets The list of planets in the chart.
+ * @returns A map of each planet to its full dispositor chain string.
  */
-function findDispositorCycles(chains) {
-    const cycles = [];
-    const visited = new Set();
-    const path = new Set();
-    function dfs(planet, currentPath) {
-        if (path.has(planet)) {
-            // Found a cycle
-            const cycleStart = currentPath.indexOf(planet);
-            if (cycleStart !== -1) {
-                const cycle = currentPath.slice(cycleStart);
-                cycle.push(planet); // Complete the cycle
-                if (cycle.length > 2) {
-                    cycles.push(cycle);
-                }
+function calculateDispositors(planets) {
+    const dispositorMap = {};
+    planets.forEach((p) => {
+        dispositorMap[p.name] = getDispositor(p);
+    });
+    const chains = {};
+    planets.forEach((planet) => {
+        const path = [planet.name];
+        let current = planet.name;
+        let chain = `${current}`;
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const nextDispositor = dispositorMap[current];
+            // eslint-disable-next-line no-prototype-builtins
+            if (!nextDispositor || !dispositorMap.hasOwnProperty(nextDispositor)) {
+                // Dispositor is not in the chart, so the chain ends.
+                chain += ` → ${nextDispositor} (not in chart)`;
+                break;
             }
-            return;
-        }
-        if (visited.has(planet))
-            return;
-        visited.add(planet);
-        path.add(planet);
-        currentPath.push(planet);
-        const chain = chains.find((c) => c.planet === planet);
-        if (chain) {
-            // Follow the dispositor chain (only follow planets in the chart)
-            const inChartRulers = chain.disposedBy.filter((ruler) => chains.some((c) => c.planet === ruler));
-            for (const ruler of inChartRulers) {
-                dfs(ruler, [...currentPath]);
+            if (nextDispositor === current) {
+                // Planet is its own dispositor (final dispositor).
+                chain += ` → (final)`;
+                break;
             }
+            if (path.includes(nextDispositor)) {
+                // A loop is detected.
+                chain += ` → ${nextDispositor} (cycle)`;
+                break;
+            }
+            path.push(nextDispositor);
+            chain += ` → ${nextDispositor}`;
+            current = nextDispositor;
         }
-        path.delete(planet);
-        currentPath.pop();
-    }
-    // Start DFS from each planet
-    chains.forEach((chain) => {
-        if (!visited.has(chain.planet)) {
-            dfs(chain.planet, []);
-        }
-    });
-    return cycles;
-}
-/**
- * Builds the full dispositor chain for a planet
- * @param planet Starting planet
- * @param chains All dispositor chains
- * @param pathSoFar Array to track the current path (prevents infinite loops)
- * @returns Array of planets in the chain (excluding the starting planet)
- */
-function buildDispositorChain(planet, chains, pathSoFar = []) {
-    const chain = chains.find((c) => c.planet === planet);
-    if (!chain || chain.disposedBy.length === 0) {
-        return ['(final)'];
-    }
-    // Get the first in-chart ruler
-    const inChartRulers = chain.disposedBy.filter((ruler) => chains.some((c) => c.planet === ruler));
-    if (inChartRulers.length === 0) {
-        return ['(final)'];
-    }
-    const ruler = inChartRulers[0];
-    // If the ruler is the same as the planet (self-ruler), it's final
-    if (ruler === planet) {
-        return ['(final)'];
-    }
-    // If we've seen this ruler in the current path, we have a cycle
-    if (pathSoFar.includes(ruler)) {
-        return ['(cycle)'];
-    }
-    // Continue the chain
-    const newPath = [...pathSoFar, planet];
-    const nextChain = buildDispositorChain(ruler, chains, newPath);
-    // If the next chain ends in (final), this whole chain ends in (final)
-    // If the next chain ends in (cycle), this chain also ends in (cycle)
-    return [ruler, ...nextChain];
-}
-/**
- * Formats the dispositor analysis for display
- * @param analysis The dispositor analysis
- * @returns Array of formatted strings
- */
-function formatDispositorAnalysis(analysis) {
-    const output = [];
-    // Build and format chains for each planet
-    analysis.chains.forEach((chainInfo) => {
-        const chainRest = buildDispositorChain(chainInfo.planet, analysis.chains);
-        const chainString = chainRest.join(' → ');
-        output.push(`${chainInfo.planet} → ${chainString}`);
+        chains[planet.name] = chain;
     });
-    return output;
+    return chains;
 }

package/dist/core/grouping.d.ts

@@ -0,0 +1,9 @@
+import { AspectData, Settings } from '../types';
+/**
+ * Provides a default grouping of aspects into "Tight", "Moderate", and "Wide" categories
+ * based on orb thresholds. This is used by the simple chart2txt() function.
+ * @param aspects The raw list of aspects to group.
+ * @param settings The chart settings, containing aspectStrengthThresholds.
+ * @returns A map of category names to aspect data arrays.
+ */
+export declare function groupAspects(aspects: AspectData[], settings: Settings): Map<string, AspectData[]>;