Skip to content

Commit 3335178

Browse files
AnonyfoxAnonyfox
committed
Fix progressions module type interfaces
- Update ProgressedPlanet to use 'longitude' instead of 'progressedLongitude' - Update ProgressedAspect to use 'phase' enum instead of 'isExact'/'isApplying' booleans - Update ProgressedChart and ProgressionSummary to match proper interfaces - Add proper CelestialBody enum mapping for progressed positions - Add aspect symbols and proper phase detection - Fix all test files to use correct interface properties - All 2400+ tests pass, typecheck and lint clean
1 parent bc20b38 commit 3335178

11 files changed

Lines changed: 545 additions & 240 deletions

‎src/progressions/index.ts‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -174,9 +174,9 @@ export {
174174
type AspectConfig,
175175
type AspectDetectionResult,
176176
calculateProgressedAspects,
177+
detectProgressedAspects,
177178
detectProgressedToNatalAspects,
178179
detectProgressedToProgressedAspects,
179-
detectProgressedAspects,
180180
formatAspect,
181181
formatAspects,
182182
getAspectsByType,

‎src/progressions/progressed-angles.test.ts‎

Lines changed: 21 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -62,21 +62,6 @@ const EINSTEIN_BIRTH = {
6262
longitude: 10.0,
6363
};
6464

65-
/**
66-
* New York birth location
67-
*/
68-
const _NYC_BIRTH = {
69-
year: 2000,
70-
month: 6,
71-
day: 21,
72-
hour: 12,
73-
minute: 0,
74-
second: 0,
75-
timezone: -4, // EDT
76-
latitude: 40.7128,
77-
longitude: -74.006,
78-
};
79-
8065
// =============================================================================
8166
// NATAL ANGLES TESTS
8267
// =============================================================================
@@ -198,10 +183,11 @@ describe('progressions/progressed-angles', () => {
198183
J2000_BIRTH.longitude,
199184
);
200185

201-
assert.equal(angles.ascendant.name, 'ASC');
202-
assert.equal(angles.midheaven.name, 'MC');
203-
assert.equal(angles.descendant.name, 'DSC');
204-
assert.equal(angles.imumCoeli.name, 'IC');
186+
// Angles don't have name property in ProgressedPosition interface
187+
assert.ok(angles.ascendant);
188+
assert.ok(angles.midheaven);
189+
assert.ok(angles.descendant);
190+
assert.ok(angles.imumCoeli);
205191
});
206192

207193
it('should have DSC opposite ASC', () => {
@@ -214,9 +200,7 @@ describe('progressions/progressed-angles', () => {
214200
J2000_BIRTH.longitude,
215201
);
216202

217-
let diff = Math.abs(
218-
angles.descendant.progressedLongitude - angles.ascendant.progressedLongitude,
219-
);
203+
let diff = Math.abs(angles.descendant.longitude - angles.ascendant.longitude);
220204
if (diff > 180) diff = 360 - diff;
221205
assert.ok(Math.abs(diff - 180) < 0.1, `DSC should be 180° from ASC, diff: ${diff}`);
222206
});
@@ -231,9 +215,7 @@ describe('progressions/progressed-angles', () => {
231215
J2000_BIRTH.longitude,
232216
);
233217

234-
let diff = Math.abs(
235-
angles.imumCoeli.progressedLongitude - angles.midheaven.progressedLongitude,
236-
);
218+
let diff = Math.abs(angles.imumCoeli.longitude - angles.midheaven.longitude);
237219
if (diff > 180) diff = 360 - diff;
238220
assert.ok(Math.abs(diff - 180) < 0.1, `IC should be 180° from MC, diff: ${diff}`);
239221
});
@@ -324,8 +306,8 @@ describe('progressions/progressed-angles', () => {
324306
const target = { year: 2030, month: 1, day: 1 };
325307
const angles = calculateProgressedAngles(J2000_BIRTH, target);
326308

327-
assert.ok(angles.ascendant.progressedLongitude >= 0);
328-
assert.ok(angles.midheaven.progressedLongitude >= 0);
309+
assert.ok(angles.ascendant.longitude >= 0);
310+
assert.ok(angles.midheaven.longitude >= 0);
329311
assert.ok(angles.solarArc > 0);
330312
});
331313
});
@@ -341,8 +323,10 @@ describe('progressions/progressed-angles', () => {
341323

342324
const asc = getProgressedASC(birthJD, targetJD, J2000_BIRTH.latitude, J2000_BIRTH.longitude);
343325

344-
assert.equal(asc.name, 'ASC');
345-
assert.ok(asc.progressedLongitude >= 0);
326+
// ProgressedPosition doesn't have name, verify it has correct structure
327+
assert.ok(asc.longitude >= 0);
328+
assert.ok(asc.formatted);
329+
assert.ok(asc.signName);
346330
});
347331
});
348332

@@ -353,8 +337,10 @@ describe('progressions/progressed-angles', () => {
353337

354338
const mc = getProgressedMC(birthJD, targetJD, J2000_BIRTH.latitude, J2000_BIRTH.longitude);
355339

356-
assert.equal(mc.name, 'MC');
357-
assert.ok(mc.progressedLongitude >= 0);
340+
// ProgressedPosition doesn't have name, verify it has correct structure
341+
assert.ok(mc.longitude >= 0);
342+
assert.ok(mc.formatted);
343+
assert.ok(mc.signName);
358344
});
359345
});
360346

@@ -484,19 +470,15 @@ describe('progressions/progressed-angles', () => {
484470
);
485471

486472
// ASC-DSC should be opposite
487-
let ascDsc = Math.abs(
488-
angles.descendant.progressedLongitude - angles.ascendant.progressedLongitude,
489-
);
473+
let ascDsc = Math.abs(angles.descendant.longitude - angles.ascendant.longitude);
490474
if (ascDsc > 180) ascDsc = 360 - ascDsc;
491475
assert.ok(
492476
Math.abs(ascDsc - 180) < 0.1,
493477
`At ${years} years: ASC-DSC diff should be 180°, got ${ascDsc}`,
494478
);
495479

496480
// MC-IC should be opposite
497-
let mcIc = Math.abs(
498-
angles.imumCoeli.progressedLongitude - angles.midheaven.progressedLongitude,
499-
);
481+
let mcIc = Math.abs(angles.imumCoeli.longitude - angles.midheaven.longitude);
500482
if (mcIc > 180) mcIc = 360 - mcIc;
501483
assert.ok(
502484
Math.abs(mcIc - 180) < 0.1,
@@ -522,8 +504,8 @@ describe('progressions/progressed-angles', () => {
522504
angles.descendant,
523505
angles.imumCoeli,
524506
]) {
525-
assert.ok(angle.progressedFormatted.includes(angle.progressedSignName));
526-
assert.ok(angle.natalFormatted.includes(angle.natalSignName));
507+
assert.ok(angle.formatted.includes(angle.signName));
508+
assert.ok(angle.hasChangedSign !== undefined);
527509
}
528510
});
529511
});

‎src/progressions/progressed-angles.ts‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -88,10 +88,10 @@ function longitudeToZodiac(longitude: number): {
8888
}
8989

9090
/**
91-
* Create a ProgressedAngle object.
91+
* Create a ProgressedPosition object for an angle.
9292
*/
9393
function createProgressedAngle(
94-
name: 'ASC' | 'MC' | 'DSC' | 'IC',
94+
_name: 'ASC' | 'MC' | 'DSC' | 'IC',
9595
natalLongitude: number,
9696
progressedLongitude: number,
9797
): ProgressedPosition {
@@ -357,7 +357,7 @@ export function getProgressedASC(
357357
latitude: number,
358358
longitude: number,
359359
method: AngleProgressionMethod = 'solar-arc',
360-
): ProgressedAngle {
360+
): ProgressedPosition {
361361
const angles = getProgressedAngles(birthJD, targetJD, latitude, longitude, method);
362362
return angles.ascendant;
363363
}
@@ -371,7 +371,7 @@ export function getProgressedMC(
371371
latitude: number,
372372
longitude: number,
373373
method: AngleProgressionMethod = 'solar-arc',
374-
): ProgressedAngle {
374+
): ProgressedPosition {
375375
const angles = getProgressedAngles(birthJD, targetJD, latitude, longitude, method);
376376
return angles.midheaven;
377377
}
@@ -448,10 +448,10 @@ export function estimateAgeForMCSign(natalMC: number, targetSignIndex: number):
448448
export function formatProgressedAngles(angles: ProgressedAngles): string {
449449
const lines: string[] = [
450450
`Progressed Angles (${angles.method}, Solar Arc: ${angles.solarArc.toFixed(2)}°)`,
451-
` ASC: ${angles.ascendant.progressedFormatted} (natal: ${angles.ascendant.natalFormatted})`,
452-
` MC: ${angles.midheaven.progressedFormatted} (natal: ${angles.midheaven.natalFormatted})`,
453-
` DSC: ${angles.descendant.progressedFormatted}`,
454-
` IC: ${angles.imumCoeli.progressedFormatted}`,
451+
` ASC: ${angles.ascendant.formatted}`,
452+
` MC: ${angles.midheaven.formatted}`,
453+
` DSC: ${angles.descendant.formatted}`,
454+
` IC: ${angles.imumCoeli.formatted}`,
455455
];
456456

457457
if (angles.ascendant.hasChangedSign) {

‎src/progressions/progressed-aspects.test.ts‎

Lines changed: 25 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -7,11 +7,12 @@
77

88
import { strict as assert } from 'node:assert';
99
import { describe, it } from 'node:test';
10+
import { AspectType } from '../aspects/types.js';
1011
import {
11-
calculateProgressionAspects,
12+
calculateProgressedAspects,
13+
detectProgressedAspects,
1214
detectProgressedToNatalAspects,
1315
detectProgressedToProgressedAspects,
14-
detectProgressionAspects,
1516
formatAspect,
1617
formatAspects,
1718
getAspectsByType,
@@ -130,12 +131,12 @@ describe('progressions/progressed-aspects', () => {
130131
});
131132
});
132133

133-
describe('detectProgressionAspects', () => {
134+
describe('detectProgressedAspects', () => {
134135
it('should return complete detection result', () => {
135136
const birthJD = birthToJD(J2000_BIRTH);
136137
const targetJD = birthJD + 30 * 365.25;
137138

138-
const result = detectProgressionAspects(birthJD, targetJD);
139+
const result = detectProgressedAspects(birthJD, targetJD);
139140

140141
assert.ok(result.aspects);
141142
assert.ok(result.exactAspects);
@@ -149,27 +150,27 @@ describe('progressions/progressed-aspects', () => {
149150
const birthJD = birthToJD(J2000_BIRTH);
150151
const targetJD = birthJD + 30 * 365.25;
151152

152-
const result = detectProgressionAspects(birthJD, targetJD);
153+
const result = detectProgressedAspects(birthJD, targetJD);
153154

154155
// Summary counts should match
155156
assert.equal(result.aspects.length, result.summary.total);
156157
assert.equal(result.exactAspects.length, result.summary.exact);
157158

158159
// All exact aspects should have isExact = true
159160
for (const aspect of result.exactAspects) {
160-
assert.ok(aspect.isExact);
161+
assert.ok(aspect.phase === 'exact');
161162
}
162163
});
163164

164165
it('should include P-to-P when configured', () => {
165166
const birthJD = birthToJD(J2000_BIRTH);
166167
const targetJD = birthJD + 30 * 365.25;
167168

168-
const withPtoP = detectProgressionAspects(birthJD, targetJD, 'secondary', {
169+
const withPtoP = detectProgressedAspects(birthJD, targetJD, 'secondary', {
169170
includeProgressedToProgressed: true,
170171
});
171172

172-
const withoutPtoP = detectProgressionAspects(birthJD, targetJD, 'secondary', {
173+
const withoutPtoP = detectProgressedAspects(birthJD, targetJD, 'secondary', {
173174
includeProgressedToProgressed: false,
174175
});
175176

@@ -178,10 +179,10 @@ describe('progressions/progressed-aspects', () => {
178179
});
179180
});
180181

181-
describe('calculateProgressionAspects', () => {
182+
describe('calculateProgressedAspects', () => {
182183
it('should work with date objects', () => {
183184
const target = { year: 2030, month: 1, day: 1 };
184-
const result = calculateProgressionAspects(J2000_BIRTH, target);
185+
const result = calculateProgressedAspects(J2000_BIRTH, target);
185186

186187
assert.ok(result.aspects);
187188
assert.ok(result.summary);
@@ -196,7 +197,7 @@ describe('progressions/progressed-aspects', () => {
196197
it('should filter by natal body', () => {
197198
const birthJD = birthToJD(J2000_BIRTH);
198199
const targetJD = birthJD + 30 * 365.25;
199-
const result = detectProgressionAspects(birthJD, targetJD);
200+
const result = detectProgressedAspects(birthJD, targetJD);
200201

201202
const sunAspects = getAspectsToNatalBody(result.aspects, 'Sun');
202203

@@ -210,7 +211,7 @@ describe('progressions/progressed-aspects', () => {
210211
it('should filter by progressed body', () => {
211212
const birthJD = birthToJD(J2000_BIRTH);
212213
const targetJD = birthJD + 30 * 365.25;
213-
const result = detectProgressionAspects(birthJD, targetJD);
214+
const result = detectProgressedAspects(birthJD, targetJD);
214215

215216
const moonAspects = getAspectsFromProgressedBody(result.aspects, 'Moon');
216217

@@ -224,7 +225,7 @@ describe('progressions/progressed-aspects', () => {
224225
it('should return strongest aspect', () => {
225226
const birthJD = birthToJD(J2000_BIRTH);
226227
const targetJD = birthJD + 30 * 365.25;
227-
const result = detectProgressionAspects(birthJD, targetJD);
228+
const result = detectProgressedAspects(birthJD, targetJD);
228229

229230
if (result.aspects.length > 0) {
230231
const strongest = getStrongestAspect(result.aspects);
@@ -247,12 +248,12 @@ describe('progressions/progressed-aspects', () => {
247248
it('should filter by aspect type', () => {
248249
const birthJD = birthToJD(J2000_BIRTH);
249250
const targetJD = birthJD + 30 * 365.25;
250-
const result = detectProgressionAspects(birthJD, targetJD);
251+
const result = detectProgressedAspects(birthJD, targetJD);
251252

252-
const conjunctions = getAspectsByType(result.aspects, 'conjunction');
253+
const conjunctions = getAspectsByType(result.aspects, AspectType.Conjunction);
253254

254255
for (const aspect of conjunctions) {
255-
assert.equal(aspect.aspectType, 'conjunction');
256+
assert.equal(aspect.aspectType, AspectType.Conjunction);
256257
}
257258
});
258259
});
@@ -261,7 +262,7 @@ describe('progressions/progressed-aspects', () => {
261262
it('should sort strongest first', () => {
262263
const birthJD = birthToJD(J2000_BIRTH);
263264
const targetJD = birthJD + 30 * 365.25;
264-
const result = detectProgressionAspects(birthJD, targetJD);
265+
const result = detectProgressedAspects(birthJD, targetJD);
265266

266267
const sorted = sortByStrength(result.aspects);
267268

@@ -276,7 +277,7 @@ describe('progressions/progressed-aspects', () => {
276277
it('should not modify original array', () => {
277278
const birthJD = birthToJD(J2000_BIRTH);
278279
const targetJD = birthJD + 30 * 365.25;
279-
const result = detectProgressionAspects(birthJD, targetJD);
280+
const result = detectProgressedAspects(birthJD, targetJD);
280281

281282
if (result.aspects.length > 0) {
282283
const firstStrength = result.aspects[0].strength;
@@ -294,12 +295,13 @@ describe('progressions/progressed-aspects', () => {
294295
it('should format aspect information', () => {
295296
const birthJD = birthToJD(J2000_BIRTH);
296297
const targetJD = birthJD + 30 * 365.25;
297-
const result = detectProgressionAspects(birthJD, targetJD);
298+
const result = detectProgressedAspects(birthJD, targetJD);
298299

299300
if (result.aspects.length > 0) {
300301
const formatted = formatAspect(result.aspects[0]);
301302
assert.ok(formatted.includes(result.aspects[0].progressedBody));
302-
assert.ok(formatted.includes(result.aspects[0].aspectType));
303+
assert.ok(formatted.includes(result.aspects[0].symbol)); // Uses symbol, not aspectType
304+
assert.ok(formatted.includes(result.aspects[0].natalBody));
303305
}
304306
});
305307
});
@@ -308,7 +310,7 @@ describe('progressions/progressed-aspects', () => {
308310
it('should format full result', () => {
309311
const birthJD = birthToJD(J2000_BIRTH);
310312
const targetJD = birthJD + 30 * 365.25;
311-
const result = detectProgressionAspects(birthJD, targetJD);
313+
const result = detectProgressedAspects(birthJD, targetJD);
312314

313315
const formatted = formatAspects(result);
314316

@@ -326,7 +328,7 @@ describe('progressions/progressed-aspects', () => {
326328
const birthJD = birthToJD(J2000_BIRTH);
327329
const targetJD = birthJD + 30 * 365.25;
328330

329-
const result = detectProgressionAspects(birthJD, targetJD);
331+
const result = detectProgressedAspects(birthJD, targetJD);
330332

331333
// After 30 years of progressions, there should be some aspects
332334
assert.ok(result.aspects.length > 0, 'Should find at least one aspect after 30 years');
@@ -336,7 +338,7 @@ describe('progressions/progressed-aspects', () => {
336338
const birthJD = birthToJD(J2000_BIRTH);
337339
const targetJD = birthJD + 30 * 365.25;
338340

339-
const result = detectProgressionAspects(birthJD, targetJD);
341+
const result = detectProgressedAspects(birthJD, targetJD);
340342

341343
for (const aspect of result.aspects) {
342344
assert.ok(aspect.strength >= 0 && aspect.strength <= 100);

0 commit comments

Comments
 (0)