kaabalah 6.10.0 → 6.12.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/{chunk-GHHOLWAG.js → chunk-LUHQNKKJ.js} +255 -262
- package/dist/chunk-LUHQNKKJ.js.map +1 -0
- package/dist/{chunk-PPIKM3QA.mjs → chunk-SLB2NLWI.mjs} +257 -263
- package/dist/chunk-SLB2NLWI.mjs.map +1 -0
- package/dist/cli.js +290 -335
- package/dist/cli.js.map +1 -1
- package/dist/index.d.mts +1 -1
- package/dist/index.d.ts +1 -1
- package/dist/index.js +42 -46
- package/dist/index.mjs +1 -1
- package/dist/visual/index.d.mts +3 -101
- package/dist/visual/index.d.ts +3 -101
- package/dist/visual/index.js +42 -46
- package/dist/visual/index.mjs +1 -1
- package/package.json +2 -1
- package/dist/chunk-GHHOLWAG.js.map +0 -1
- package/dist/chunk-PPIKM3QA.mjs.map +0 -1
|
@@ -1346,7 +1346,7 @@ function generateAstroGlyphSvg(keyOrGlyph, options = {}) {
|
|
|
1346
1346
|
const svg = generateGlyphSvg(glyph.primitives, options);
|
|
1347
1347
|
return svg.replace("<svg ", `<svg data-astro-glyph="${escapeAttr2(glyph.key)}" data-astro-glyph-category="${glyph.category}" `);
|
|
1348
1348
|
}
|
|
1349
|
-
function
|
|
1349
|
+
function buildAstroWheelSvgModel(chart, options = {}) {
|
|
1350
1350
|
const viewBox = normalizeViewBox2(options.viewBox);
|
|
1351
1351
|
const palette = resolvePalette2(options.palette, options.background ?? "transparent");
|
|
1352
1352
|
const excludedBodies = resolveExcludedBodies(options.excludeBodies);
|
|
@@ -1354,7 +1354,7 @@ function getAstroWheelRenderModel(chart, options = {}) {
|
|
|
1354
1354
|
viewBox.width / ASTRO_WHEEL_DEFAULT_VIEWBOX.width,
|
|
1355
1355
|
viewBox.height / ASTRO_WHEEL_DEFAULT_VIEWBOX.height
|
|
1356
1356
|
);
|
|
1357
|
-
const padding = options.padding ?? round2(18 * scale + getExternalPointPadding(
|
|
1357
|
+
const padding = options.padding ?? round2(18 * scale + getExternalPointPadding());
|
|
1358
1358
|
const center = {
|
|
1359
1359
|
x: round2(viewBox.minX + viewBox.width / 2),
|
|
1360
1360
|
y: round2(viewBox.minY + viewBox.height / 2)
|
|
@@ -1383,7 +1383,7 @@ function getAstroWheelRenderModel(chart, options = {}) {
|
|
|
1383
1383
|
rings,
|
|
1384
1384
|
scale
|
|
1385
1385
|
}) : [];
|
|
1386
|
-
const
|
|
1386
|
+
const basePointGroup = buildPointGroup({
|
|
1387
1387
|
layer: {
|
|
1388
1388
|
id: "birth",
|
|
1389
1389
|
label: "Birth",
|
|
@@ -1405,27 +1405,12 @@ function getAstroWheelRenderModel(chart, options = {}) {
|
|
|
1405
1405
|
maxDisplacementDegrees: maxPointDisplacementDegrees,
|
|
1406
1406
|
railVisibility
|
|
1407
1407
|
});
|
|
1408
|
-
const
|
|
1409
|
-
|
|
1410
|
-
layer,
|
|
1411
|
-
center,
|
|
1412
|
-
angleOf: angleOf2,
|
|
1413
|
-
rings,
|
|
1414
|
-
scale,
|
|
1415
|
-
palette,
|
|
1416
|
-
excludedBodies,
|
|
1417
|
-
pointConnectorMode,
|
|
1418
|
-
maxDisplacementDegrees: maxPointDisplacementDegrees,
|
|
1419
|
-
railVisibility
|
|
1420
|
-
})
|
|
1421
|
-
);
|
|
1422
|
-
const pointLayers = [
|
|
1423
|
-
...resolvedPoints.enabled ? [basePointLayer] : [],
|
|
1424
|
-
...extraPointLayers
|
|
1408
|
+
const pointGroups = [
|
|
1409
|
+
...resolvedPoints.enabled ? [basePointGroup] : []
|
|
1425
1410
|
];
|
|
1426
|
-
const points =
|
|
1411
|
+
const points = pointGroups.flatMap((layer) => [...layer.points]);
|
|
1427
1412
|
const pointByKey = Object.fromEntries(points.map((point) => [point.key, point]));
|
|
1428
|
-
const
|
|
1413
|
+
const baseAspectGroup = resolvedAspects.enabled ? buildAspectGroup({
|
|
1429
1414
|
layer: {
|
|
1430
1415
|
id: "birth",
|
|
1431
1416
|
label: "Birth aspects",
|
|
@@ -1441,25 +1426,11 @@ function getAstroWheelRenderModel(chart, options = {}) {
|
|
|
1441
1426
|
palette,
|
|
1442
1427
|
excludedBodies
|
|
1443
1428
|
}) : null;
|
|
1444
|
-
const
|
|
1445
|
-
|
|
1446
|
-
layer,
|
|
1447
|
-
chart: layer.chart ?? chart,
|
|
1448
|
-
pointByKey,
|
|
1449
|
-
center,
|
|
1450
|
-
angleOf: angleOf2,
|
|
1451
|
-
rings,
|
|
1452
|
-
palette,
|
|
1453
|
-
excludedBodies
|
|
1454
|
-
})
|
|
1455
|
-
);
|
|
1456
|
-
const aspectLayers = [
|
|
1457
|
-
...baseAspectLayer ? [baseAspectLayer] : [],
|
|
1458
|
-
...extraAspectLayers
|
|
1429
|
+
const aspectGroups = [
|
|
1430
|
+
...baseAspectGroup ? [baseAspectGroup] : []
|
|
1459
1431
|
];
|
|
1460
|
-
const aspectLines =
|
|
1461
|
-
const positionRails =
|
|
1462
|
-
const boundaryNotches = pointLayers.flatMap((layer) => [...layer.notches]);
|
|
1432
|
+
const aspectLines = aspectGroups.flatMap((layer) => [...layer.aspectLines]);
|
|
1433
|
+
const positionRails = basePointGroup.rails;
|
|
1463
1434
|
return {
|
|
1464
1435
|
viewBox,
|
|
1465
1436
|
center,
|
|
@@ -1473,15 +1444,14 @@ function getAstroWheelRenderModel(chart, options = {}) {
|
|
|
1473
1444
|
points,
|
|
1474
1445
|
pointByKey,
|
|
1475
1446
|
aspectLines,
|
|
1476
|
-
|
|
1477
|
-
|
|
1447
|
+
pointGroups,
|
|
1448
|
+
aspectGroups,
|
|
1478
1449
|
positionRails,
|
|
1479
|
-
boundaryNotches,
|
|
1480
1450
|
palette
|
|
1481
1451
|
};
|
|
1482
1452
|
}
|
|
1483
1453
|
function generateAstroWheelSvg(chart, options = {}) {
|
|
1484
|
-
const model =
|
|
1454
|
+
const model = buildAstroWheelSvgModel(chart, options);
|
|
1485
1455
|
const viewBox = model.viewBox;
|
|
1486
1456
|
const zodiacOptions = resolveZodiacOptions(options.zodiac);
|
|
1487
1457
|
const houseOptions = resolveHouseOptions(options.houses);
|
|
@@ -1536,15 +1506,15 @@ function renderSvgDefs(push, model) {
|
|
|
1536
1506
|
push(`</defs>`);
|
|
1537
1507
|
}
|
|
1538
1508
|
function renderAspects(push, model) {
|
|
1539
|
-
if (model.
|
|
1509
|
+
if (model.aspectGroups.length === 0) {
|
|
1540
1510
|
return;
|
|
1541
1511
|
}
|
|
1542
1512
|
push(`<g id="astro-wheel-aspects" aria-label="aspects">`);
|
|
1543
|
-
for (const layer of model.
|
|
1544
|
-
push(`<g class="astro-wheel-aspect-
|
|
1513
|
+
for (const layer of model.aspectGroups) {
|
|
1514
|
+
push(`<g class="astro-wheel-aspect-group" data-aspect-group="${escapeAttr2(layer.id)}"${layer.label ? ` aria-label="${escapeAttr2(layer.label)}"` : ""}>`);
|
|
1545
1515
|
for (const aspect of layer.aspectLines) {
|
|
1546
1516
|
push(
|
|
1547
|
-
`<line data-aspect-
|
|
1517
|
+
`<line data-aspect-group="${escapeAttr2(aspect.groupId)}" data-aspect="${escapeAttr2(aspect.aspect)}" data-planet-a="${escapeAttr2(aspect.planetA)}" data-planet-b="${escapeAttr2(aspect.planetB)}" x1="${fmt2(aspect.line.x1)}" y1="${fmt2(aspect.line.y1)}" x2="${fmt2(aspect.line.x2)}" y2="${fmt2(aspect.line.y2)}" stroke="${escapeAttr2(aspect.color)}" stroke-opacity="${fmt2(aspect.opacity)}" stroke-width="${fmt2(aspect.strokeWidth * model.scale)}" stroke-linecap="round"/>`
|
|
1548
1518
|
);
|
|
1549
1519
|
}
|
|
1550
1520
|
push(`</g>`);
|
|
@@ -1634,23 +1604,18 @@ function renderHouses(push, model, options) {
|
|
|
1634
1604
|
push(`</g>`);
|
|
1635
1605
|
}
|
|
1636
1606
|
function renderPlanets(push, model) {
|
|
1637
|
-
if (model.
|
|
1607
|
+
if (model.pointGroups.length === 0) {
|
|
1638
1608
|
return;
|
|
1639
1609
|
}
|
|
1640
1610
|
push(`<g id="astro-wheel-planets" aria-label="planets">`);
|
|
1641
|
-
for (const layer of model.
|
|
1642
|
-
|
|
1643
|
-
}
|
|
1644
|
-
for (const notch of model.boundaryNotches) {
|
|
1645
|
-
push(
|
|
1646
|
-
`<path class="astro-wheel-boundary-notch" data-point-layer="${escapeAttr2(notch.layerId)}" data-point-key="${escapeAttr2(notch.pointKey)}" data-house="${notch.house}" data-cusp-house="${notch.cuspHouse}" d="${escapeAttr2(notch.path)}" fill="none" stroke="${escapeAttr2(model.palette.houseLine)}" stroke-opacity="0.6" stroke-width="${fmt2(1.1 * model.scale)}" stroke-linejoin="round" stroke-linecap="round"/>`
|
|
1647
|
-
);
|
|
1611
|
+
for (const layer of model.pointGroups) {
|
|
1612
|
+
renderPointGroupGuide(push, layer, model);
|
|
1648
1613
|
}
|
|
1649
|
-
for (const layer of model.
|
|
1650
|
-
push(`<g class="astro-wheel-point-
|
|
1614
|
+
for (const layer of model.pointGroups) {
|
|
1615
|
+
push(`<g class="astro-wheel-point-group" data-point-group="${escapeAttr2(layer.id)}"${layer.label ? ` aria-label="${escapeAttr2(layer.label)}"` : ""}>`);
|
|
1651
1616
|
for (const point of layer.points) {
|
|
1652
1617
|
push(
|
|
1653
|
-
`<g class="astro-wheel-point" data-point-
|
|
1618
|
+
`<g class="astro-wheel-point" data-point-group="${escapeAttr2(point.groupId)}" data-point-key="${escapeAttr2(point.key)}" data-point-name="${escapeAttr2(point.name)}" data-point-kind="${point.kind}" data-longitude="${fmt2(point.longitude)}">`
|
|
1654
1619
|
);
|
|
1655
1620
|
push(`<title>${escapeText2(point.name)} ${fmt2(point.longitude)}\xB0</title>`);
|
|
1656
1621
|
push(
|
|
@@ -1671,17 +1636,17 @@ function renderPlanets(push, model) {
|
|
|
1671
1636
|
}
|
|
1672
1637
|
push(`</g>`);
|
|
1673
1638
|
}
|
|
1674
|
-
function
|
|
1639
|
+
function renderPointGroupGuide(push, layer, model) {
|
|
1675
1640
|
const isExternal = layer.radius > model.rings.houses.r2 + model.scale;
|
|
1676
1641
|
if (!isExternal) {
|
|
1677
1642
|
return;
|
|
1678
1643
|
}
|
|
1679
1644
|
push(
|
|
1680
|
-
`<circle class="astro-wheel-external-point-ring" data-point-
|
|
1645
|
+
`<circle class="astro-wheel-external-point-ring" data-point-group="${escapeAttr2(layer.id)}" cx="${fmt2(model.center.x)}" cy="${fmt2(model.center.y)}" r="${fmt2(layer.radius)}" fill="none" stroke="${escapeAttr2(layer.tickColor)}" stroke-opacity="0.32" stroke-width="${fmt2(1.15 * model.scale)}"/>`
|
|
1681
1646
|
);
|
|
1682
1647
|
}
|
|
1683
1648
|
function renderGlyphOverlay(push, model) {
|
|
1684
|
-
if (model.angleMarkers.length === 0 && model.
|
|
1649
|
+
if (model.angleMarkers.length === 0 && model.pointGroups.length === 0) {
|
|
1685
1650
|
return;
|
|
1686
1651
|
}
|
|
1687
1652
|
push(`<g id="astro-wheel-glyph-layer" aria-label="chart glyphs">`);
|
|
@@ -1692,10 +1657,10 @@ function renderGlyphOverlay(push, model) {
|
|
|
1692
1657
|
}
|
|
1693
1658
|
push(`</g>`);
|
|
1694
1659
|
}
|
|
1695
|
-
if (model.
|
|
1660
|
+
if (model.pointGroups.length > 0) {
|
|
1696
1661
|
push(`<g id="astro-wheel-point-glyphs" aria-label="planet glyphs">`);
|
|
1697
|
-
for (const layer of model.
|
|
1698
|
-
push(`<g class="astro-wheel-point-glyph-layer" data-point-
|
|
1662
|
+
for (const layer of model.pointGroups) {
|
|
1663
|
+
push(`<g class="astro-wheel-point-glyph-layer" data-point-group="${escapeAttr2(layer.id)}"${layer.label ? ` aria-label="${escapeAttr2(layer.label)} glyphs"` : ""}>`);
|
|
1699
1664
|
for (const point of layer.points) {
|
|
1700
1665
|
renderPointLabelGroup(push, point, model);
|
|
1701
1666
|
}
|
|
@@ -1737,7 +1702,7 @@ function angleDisplayLabel(key) {
|
|
|
1737
1702
|
}
|
|
1738
1703
|
function renderPointLabelGroup(push, point, model) {
|
|
1739
1704
|
push(
|
|
1740
|
-
`<g class="astro-wheel-point-label" data-point-
|
|
1705
|
+
`<g class="astro-wheel-point-label" data-point-group="${escapeAttr2(point.groupId)}" data-point-key="${escapeAttr2(point.key)}" data-point-name="${escapeAttr2(point.name)}" data-point-kind="${point.kind}" data-longitude="${fmt2(point.longitude)}" data-display-longitude="${fmt2(point.displayLongitude)}" data-house="${point.house ?? ""}" transform="translate(${fmt2(point.glyphPosition.x)} ${fmt2(point.glyphPosition.y)})" filter="url(#${GLYPH_OUTLINE_FILTER_ID})">`
|
|
1741
1706
|
);
|
|
1742
1707
|
push(`<title>${escapeText2(pointLabelTitle(point))}</title>`);
|
|
1743
1708
|
renderPointGlyph(push, point, 0, 0, point.glyphScale, model.palette.glyphHalo);
|
|
@@ -1746,7 +1711,7 @@ function renderPointLabelGroup(push, point, model) {
|
|
|
1746
1711
|
if (!label.visible)
|
|
1747
1712
|
continue;
|
|
1748
1713
|
push(
|
|
1749
|
-
`<g class="astro-wheel-position-rail-label" data-point-
|
|
1714
|
+
`<g class="astro-wheel-position-rail-label" data-point-group="${escapeAttr2(point.groupId)}" data-point-key="${escapeAttr2(point.key)}" data-point-name="${escapeAttr2(point.name)}" data-position-rail="${label.railId}" transform="translate(${fmt2(label.position.x)} ${fmt2(label.position.y)})" filter="url(#${GLYPH_OUTLINE_FILTER_ID})">`
|
|
1750
1715
|
);
|
|
1751
1716
|
if (label.railId === "sign" && label.sign) {
|
|
1752
1717
|
renderInlineSignGlyph(push, label.sign, 0, 0, label.glyphScale ?? label.fontSize, point.color);
|
|
@@ -1864,13 +1829,7 @@ function resolvePointGlyph(name) {
|
|
|
1864
1829
|
return PLANET_GLYPHS[resolved] ?? ANGLE_GLYPHS[resolved] ?? null;
|
|
1865
1830
|
}
|
|
1866
1831
|
function getExternalPointPadding(options, scale) {
|
|
1867
|
-
|
|
1868
|
-
if (externalLayers.length === 0) {
|
|
1869
|
-
return 0;
|
|
1870
|
-
}
|
|
1871
|
-
return Math.max(
|
|
1872
|
-
...externalLayers.map((layer) => (layer.radiusOffset ?? 18) + 36 * scale)
|
|
1873
|
-
);
|
|
1832
|
+
return 0;
|
|
1874
1833
|
}
|
|
1875
1834
|
function buildZodiacSegments(params) {
|
|
1876
1835
|
const { center, angleOf: angleOf2, rings, scale, palette } = params;
|
|
@@ -1965,7 +1924,7 @@ function buildAngleMarkers(params) {
|
|
|
1965
1924
|
};
|
|
1966
1925
|
});
|
|
1967
1926
|
}
|
|
1968
|
-
function
|
|
1927
|
+
function buildPointGroup(params) {
|
|
1969
1928
|
const {
|
|
1970
1929
|
layer,
|
|
1971
1930
|
center,
|
|
@@ -1979,7 +1938,7 @@ function buildPointLayer(params) {
|
|
|
1979
1938
|
railVisibility
|
|
1980
1939
|
} = params;
|
|
1981
1940
|
const ring = rings.planets;
|
|
1982
|
-
const requestedRadius =
|
|
1941
|
+
const requestedRadius = resolvePointGroupRadius(layer, rings);
|
|
1983
1942
|
const requestedExternalLayer = requestedRadius > rings.houses.r2 + scale;
|
|
1984
1943
|
const thickness = ring.r2 - ring.r1;
|
|
1985
1944
|
const glyphFontSize = clamp(thickness * 0.68, 14 * scale, 30 * scale) * (layer.glyphScale ?? 1);
|
|
@@ -2119,15 +2078,6 @@ function buildPointLayer(params) {
|
|
|
2119
2078
|
connector
|
|
2120
2079
|
};
|
|
2121
2080
|
});
|
|
2122
|
-
const notches = buildBoundaryNotches({
|
|
2123
|
-
layerId: layer.id,
|
|
2124
|
-
points,
|
|
2125
|
-
houses: layer.chart?.houses.houses ?? [],
|
|
2126
|
-
center,
|
|
2127
|
-
radius,
|
|
2128
|
-
ring,
|
|
2129
|
-
scale
|
|
2130
|
-
});
|
|
2131
2081
|
return {
|
|
2132
2082
|
id: layer.id,
|
|
2133
2083
|
label: layer.label,
|
|
@@ -2135,7 +2085,6 @@ function buildPointLayer(params) {
|
|
|
2135
2085
|
tickColor,
|
|
2136
2086
|
radius,
|
|
2137
2087
|
rails,
|
|
2138
|
-
notches,
|
|
2139
2088
|
points
|
|
2140
2089
|
};
|
|
2141
2090
|
}
|
|
@@ -2166,7 +2115,7 @@ function makeAstroWheelPoint(params) {
|
|
|
2166
2115
|
});
|
|
2167
2116
|
const glyphScale = glyphFontSize * 0.66;
|
|
2168
2117
|
return {
|
|
2169
|
-
|
|
2118
|
+
groupId: layer.id,
|
|
2170
2119
|
key: seed.key,
|
|
2171
2120
|
name: seed.name,
|
|
2172
2121
|
kind: seed.kind,
|
|
@@ -2201,13 +2150,13 @@ function makeAstroWheelPoint(params) {
|
|
|
2201
2150
|
};
|
|
2202
2151
|
}
|
|
2203
2152
|
function resolveRailVisibility(input) {
|
|
2204
|
-
if (input === "glyph-only") {
|
|
2153
|
+
if (!input || input === "glyph-only") {
|
|
2205
2154
|
return { degree: false, sign: false, minutes: false, retrograde: false };
|
|
2206
2155
|
}
|
|
2207
2156
|
if (input === "compact") {
|
|
2208
2157
|
return { degree: true, sign: true, minutes: false, retrograde: true };
|
|
2209
2158
|
}
|
|
2210
|
-
if (
|
|
2159
|
+
if (input === "full") {
|
|
2211
2160
|
return { degree: true, sign: true, minutes: true, retrograde: true };
|
|
2212
2161
|
}
|
|
2213
2162
|
return {
|
|
@@ -2326,83 +2275,19 @@ function buildPointLineConnector(params) {
|
|
|
2326
2275
|
y2: params.glyphPosition.y
|
|
2327
2276
|
};
|
|
2328
2277
|
}
|
|
2329
|
-
function
|
|
2330
|
-
if (params.houses.length === 0)
|
|
2331
|
-
return [];
|
|
2332
|
-
const { center, ring, radius, scale } = params;
|
|
2333
|
-
return params.points.flatMap((point) => {
|
|
2334
|
-
if (!point.nearestCuspHouse || point.nearestCuspDistanceDegrees === void 0)
|
|
2335
|
-
return [];
|
|
2336
|
-
const displaced = circularAngleDistance(point.trueAngle, point.displayAngle) > deg2rad2(0.35);
|
|
2337
|
-
if (!displaced)
|
|
2338
|
-
return [];
|
|
2339
|
-
const cusp = params.houses[point.nearestCuspHouse - 1];
|
|
2340
|
-
const cuspAngle = point.trueAngle + deg2rad2(shortestLongitudeDistance(point.longitude, cusp.longitude));
|
|
2341
|
-
const trueDelta = signedAngleDelta(cuspAngle, point.trueAngle);
|
|
2342
|
-
const displayDelta = signedAngleDelta(cuspAngle, point.displayAngle);
|
|
2343
|
-
const crossed = Math.sign(trueDelta) !== Math.sign(displayDelta) && displayDelta !== 0;
|
|
2344
|
-
const crowds = point.nearestCuspDistanceDegrees <= 2;
|
|
2345
|
-
if (!crossed && !crowds)
|
|
2346
|
-
return [];
|
|
2347
|
-
const glyphHalfAngle = Math.max(point.glyphScale * 0.62, 4 * scale) / Math.max(radius, 1);
|
|
2348
|
-
const directed = displayDelta === 0 ? trueDelta : displayDelta;
|
|
2349
|
-
const direction = directed >= 0 ? 1 : -1;
|
|
2350
|
-
const endAngle = cuspAngle + directed + direction * glyphHalfAngle;
|
|
2351
|
-
const halfThickness = Math.max(point.glyphScale * 0.9, 7 * scale);
|
|
2352
|
-
const innerRadius = clamp(radius - halfThickness, ring.r1, ring.r2);
|
|
2353
|
-
const outerRadius = clamp(radius + halfThickness, ring.r1, ring.r2);
|
|
2354
|
-
return [{
|
|
2355
|
-
id: `${params.layerId}-${point.key}-notch`,
|
|
2356
|
-
layerId: params.layerId,
|
|
2357
|
-
pointKey: point.key,
|
|
2358
|
-
house: point.house ?? 0,
|
|
2359
|
-
cuspHouse: point.nearestCuspHouse,
|
|
2360
|
-
cuspLongitude: normalizeAngle(cusp.longitude),
|
|
2361
|
-
radius: outerRadius,
|
|
2362
|
-
innerRadius,
|
|
2363
|
-
outerRadius,
|
|
2364
|
-
startAngle: cuspAngle,
|
|
2365
|
-
endAngle,
|
|
2366
|
-
path: boundaryNotchPath(center, innerRadius, outerRadius, cuspAngle, endAngle)
|
|
2367
|
-
}];
|
|
2368
|
-
});
|
|
2369
|
-
}
|
|
2370
|
-
function boundaryNotchPath(center, innerRadius, outerRadius, cuspAngle, endAngle) {
|
|
2371
|
-
const outerCusp = polarToXY2(center.x, center.y, outerRadius, cuspAngle);
|
|
2372
|
-
const outerEnd = polarToXY2(center.x, center.y, outerRadius, endAngle);
|
|
2373
|
-
const innerEnd = polarToXY2(center.x, center.y, innerRadius, endAngle);
|
|
2374
|
-
const innerCusp = polarToXY2(center.x, center.y, innerRadius, cuspAngle);
|
|
2375
|
-
const delta = signedAngleDelta(cuspAngle, endAngle);
|
|
2376
|
-
const sweepOuter = delta >= 0 ? 1 : 0;
|
|
2377
|
-
const sweepInner = delta >= 0 ? 0 : 1;
|
|
2378
|
-
return [
|
|
2379
|
-
`M ${fmt2(outerCusp.x)} ${fmt2(outerCusp.y)}`,
|
|
2380
|
-
`A ${fmt2(outerRadius)} ${fmt2(outerRadius)} 0 0 ${sweepOuter} ${fmt2(outerEnd.x)} ${fmt2(outerEnd.y)}`,
|
|
2381
|
-
`L ${fmt2(innerEnd.x)} ${fmt2(innerEnd.y)}`,
|
|
2382
|
-
`A ${fmt2(innerRadius)} ${fmt2(innerRadius)} 0 0 ${sweepInner} ${fmt2(innerCusp.x)} ${fmt2(innerCusp.y)}`,
|
|
2383
|
-
"Z"
|
|
2384
|
-
].join(" ");
|
|
2385
|
-
}
|
|
2386
|
-
function buildAspectLayer(params) {
|
|
2278
|
+
function buildAspectGroup(params) {
|
|
2387
2279
|
const { layer, chart, pointByKey, center, angleOf: angleOf2, rings, palette, excludedBodies } = params;
|
|
2388
|
-
const sourceEdges = layer.edges ? layer.edges :
|
|
2389
|
-
chart.planets,
|
|
2390
|
-
layer.chartB.planets,
|
|
2391
|
-
layer.aspectSpecs ?? ASTRO_WHEEL_DEFAULT_ASPECT_SPECS
|
|
2392
|
-
) : getSourceAspectEdges(chart, {
|
|
2280
|
+
const sourceEdges = layer.edges ? layer.edges : getSourceAspectEdges(chart, {
|
|
2393
2281
|
edges: layer.edges,
|
|
2394
2282
|
aspectSpecs: layer.aspectSpecs
|
|
2395
2283
|
});
|
|
2396
2284
|
const aspectRadius = layer.radius ?? rings.aspects.r2 * (layer.radiusScale ?? 0.96);
|
|
2397
|
-
const layerPointPrefix = pointKeyPrefix(layer.pointLayerId);
|
|
2398
|
-
const layerPointPrefixA = layer.pointLayerIdA ? pointKeyPrefix(layer.pointLayerIdA) : layerPointPrefix;
|
|
2399
|
-
const layerPointPrefixB = layer.pointLayerIdB ? pointKeyPrefix(layer.pointLayerIdB) : layerPointPrefix;
|
|
2400
2285
|
const aspectLines = sourceEdges.flatMap((edge) => {
|
|
2401
2286
|
if (isExcludedBody(edge.planetA, excludedBodies) || isExcludedBody(edge.planetB, excludedBodies)) {
|
|
2402
2287
|
return [];
|
|
2403
2288
|
}
|
|
2404
|
-
const planetAKey =
|
|
2405
|
-
const planetBKey =
|
|
2289
|
+
const planetAKey = normalizePointKey(edge.planetA);
|
|
2290
|
+
const planetBKey = normalizePointKey(edge.planetB);
|
|
2406
2291
|
const planetA = pointByKey[planetAKey];
|
|
2407
2292
|
const planetB = pointByKey[planetBKey];
|
|
2408
2293
|
if (!planetA || !planetB) {
|
|
@@ -2414,7 +2299,7 @@ function buildAspectLayer(params) {
|
|
|
2414
2299
|
const a = layer.radius || layer.radiusScale ? polarToXY2(center.x, center.y, aspectRadius, angleOf2(planetA.longitude)) : planetA.trueAnchor;
|
|
2415
2300
|
const b = layer.radius || layer.radiusScale ? polarToXY2(center.x, center.y, aspectRadius, angleOf2(planetB.longitude)) : planetB.trueAnchor;
|
|
2416
2301
|
return [{
|
|
2417
|
-
|
|
2302
|
+
groupId: layer.id,
|
|
2418
2303
|
planetA: planetA.name,
|
|
2419
2304
|
planetB: planetB.name,
|
|
2420
2305
|
planetAKey,
|
|
@@ -2473,9 +2358,9 @@ function getPointSeeds(layer, excludedBodies) {
|
|
|
2473
2358
|
}
|
|
2474
2359
|
return seeds.filter((seed) => !isExcludedBody(seed.name, excludedBodies)).sort((a, b) => normalizeAngle(a.longitude) - normalizeAngle(b.longitude));
|
|
2475
2360
|
}
|
|
2476
|
-
function planetSeed(key, planet,
|
|
2361
|
+
function planetSeed(key, planet, groupId) {
|
|
2477
2362
|
return {
|
|
2478
|
-
key: layerPointKey(
|
|
2363
|
+
key: layerPointKey(groupId, key || planet.name),
|
|
2479
2364
|
name: planet.name,
|
|
2480
2365
|
kind: "planet",
|
|
2481
2366
|
glyph: pointGlyph(planet.name),
|
|
@@ -2485,9 +2370,9 @@ function planetSeed(key, planet, layerId) {
|
|
|
2485
2370
|
zodiacPosition: planet.zodiacPosition
|
|
2486
2371
|
};
|
|
2487
2372
|
}
|
|
2488
|
-
function nodeSeed(key, node,
|
|
2373
|
+
function nodeSeed(key, node, groupId) {
|
|
2489
2374
|
return {
|
|
2490
|
-
key: layerPointKey(
|
|
2375
|
+
key: layerPointKey(groupId, node.name || key),
|
|
2491
2376
|
name: node.name,
|
|
2492
2377
|
kind: "node",
|
|
2493
2378
|
glyph: pointGlyph(node.name),
|
|
@@ -2496,9 +2381,9 @@ function nodeSeed(key, node, layerId) {
|
|
|
2496
2381
|
zodiacPosition: node
|
|
2497
2382
|
};
|
|
2498
2383
|
}
|
|
2499
|
-
function pointSeed(point,
|
|
2384
|
+
function pointSeed(point, groupId) {
|
|
2500
2385
|
return {
|
|
2501
|
-
key: layerPointKey(
|
|
2386
|
+
key: layerPointKey(groupId, point.key ?? point.name),
|
|
2502
2387
|
name: point.name,
|
|
2503
2388
|
kind: point.kind ?? "planet",
|
|
2504
2389
|
glyph: point.glyph ?? pointGlyph(point.name),
|
|
@@ -2513,7 +2398,7 @@ function solveCircularLabelAngles(items, options) {
|
|
|
2513
2398
|
if (items.length === 0) {
|
|
2514
2399
|
return [];
|
|
2515
2400
|
}
|
|
2516
|
-
const normalized = items.map((item) => ({
|
|
2401
|
+
const normalized = seedExactAngleClusters(items, { paddingPx, maxDisplacementRad }).map((item) => ({
|
|
2517
2402
|
...item,
|
|
2518
2403
|
idealAngle: clampRad(item.idealAngle)
|
|
2519
2404
|
})).sort((a, b) => a.idealAngle - b.idealAngle);
|
|
@@ -2552,8 +2437,8 @@ function solveCircularLabelAngles(items, options) {
|
|
|
2552
2437
|
}
|
|
2553
2438
|
const solved = linear.map((item) => ({
|
|
2554
2439
|
...item,
|
|
2555
|
-
visualAngle: item.idealAngle
|
|
2556
|
-
}));
|
|
2440
|
+
visualAngle: item.visualAngleSeed ?? item.idealAngle
|
|
2441
|
+
})).sort((a, b) => a.visualAngle - b.visualAngle);
|
|
2557
2442
|
for (let iteration = 0; iteration < 50; iteration++) {
|
|
2558
2443
|
const forces = new Array(solved.length).fill(0);
|
|
2559
2444
|
let maxForce = 0;
|
|
@@ -2596,6 +2481,38 @@ function solveCircularLabelAngles(items, options) {
|
|
|
2596
2481
|
visualAngle: clampRad(item.visualAngle)
|
|
2597
2482
|
}));
|
|
2598
2483
|
}
|
|
2484
|
+
function seedExactAngleClusters(items, options) {
|
|
2485
|
+
const seeded = items.map((item) => ({
|
|
2486
|
+
...item,
|
|
2487
|
+
idealAngle: clampRad(item.idealAngle)
|
|
2488
|
+
}));
|
|
2489
|
+
const groups = /* @__PURE__ */ new Map();
|
|
2490
|
+
for (const item of seeded) {
|
|
2491
|
+
const key = item.idealAngle.toFixed(6);
|
|
2492
|
+
const group = groups.get(key);
|
|
2493
|
+
if (group) {
|
|
2494
|
+
group.push(item);
|
|
2495
|
+
} else {
|
|
2496
|
+
groups.set(key, [item]);
|
|
2497
|
+
}
|
|
2498
|
+
}
|
|
2499
|
+
for (const group of groups.values()) {
|
|
2500
|
+
if (group.length < 2) {
|
|
2501
|
+
continue;
|
|
2502
|
+
}
|
|
2503
|
+
const center = group[0].idealAngle;
|
|
2504
|
+
const largestDemand = Math.max(
|
|
2505
|
+
...group.map((item) => labelAngularHalfDemand(item, options.paddingPx) * 2)
|
|
2506
|
+
);
|
|
2507
|
+
const maxStep = group.length > 1 ? options.maxDisplacementRad * 2 / (group.length - 1) : largestDemand;
|
|
2508
|
+
const step = Math.min(largestDemand, maxStep);
|
|
2509
|
+
const midpoint2 = (group.length - 1) / 2;
|
|
2510
|
+
group.forEach((item, index) => {
|
|
2511
|
+
item.visualAngleSeed = center + (index - midpoint2) * step;
|
|
2512
|
+
});
|
|
2513
|
+
}
|
|
2514
|
+
return seeded;
|
|
2515
|
+
}
|
|
2599
2516
|
function clampAngleAroundIdeal(value, ideal, maxDistance) {
|
|
2600
2517
|
if (!Number.isFinite(maxDistance) || maxDistance >= Math.PI) {
|
|
2601
2518
|
return value;
|
|
@@ -2679,32 +2596,6 @@ function computeAspectEdges(planets, specs) {
|
|
|
2679
2596
|
}
|
|
2680
2597
|
return edges;
|
|
2681
2598
|
}
|
|
2682
|
-
function computeCrossAspectEdges(planetsA, planetsB, specs) {
|
|
2683
|
-
const keysA = Object.keys(planetsA);
|
|
2684
|
-
const keysB = Object.keys(planetsB);
|
|
2685
|
-
const edges = [];
|
|
2686
|
-
for (const keyA of keysA) {
|
|
2687
|
-
for (const keyB of keysB) {
|
|
2688
|
-
const planetA = planetsA[keyA];
|
|
2689
|
-
const planetB = planetsB[keyB];
|
|
2690
|
-
const match = getAspectMatch(planetA.longitude, planetB.longitude, specs);
|
|
2691
|
-
if (!match) {
|
|
2692
|
-
continue;
|
|
2693
|
-
}
|
|
2694
|
-
edges.push({
|
|
2695
|
-
planetA: keyA,
|
|
2696
|
-
planetB: keyB,
|
|
2697
|
-
longitudeA: normalizeAngle(planetA.longitude),
|
|
2698
|
-
longitudeB: normalizeAngle(planetB.longitude),
|
|
2699
|
-
aspect: match.spec.name,
|
|
2700
|
-
aspectAngle: match.spec.angle,
|
|
2701
|
-
delta: match.delta,
|
|
2702
|
-
orb: match.orb
|
|
2703
|
-
});
|
|
2704
|
-
}
|
|
2705
|
-
}
|
|
2706
|
-
return edges;
|
|
2707
|
-
}
|
|
2708
2599
|
function getAspectMatch(lonA, lonB, specs) {
|
|
2709
2600
|
const delta = Math.min(
|
|
2710
2601
|
normalizeAngle(lonB - lonA),
|
|
@@ -2853,7 +2744,7 @@ function resolveAspectOptions(options) {
|
|
|
2853
2744
|
aspectSpecs: options.aspectSpecs
|
|
2854
2745
|
};
|
|
2855
2746
|
}
|
|
2856
|
-
function
|
|
2747
|
+
function resolvePointGroupRadius(layer, rings) {
|
|
2857
2748
|
const ring = rings.planets;
|
|
2858
2749
|
if (layer.radius === "external") {
|
|
2859
2750
|
return rings.houses.r2 + (layer.radiusOffset ?? 18);
|
|
@@ -2886,12 +2777,9 @@ function isExcludedBody(name, excludedBodies) {
|
|
|
2886
2777
|
function normalizePointKey(value) {
|
|
2887
2778
|
return value.trim().toLocaleLowerCase().replace(/[_-]+/g, " ").replace(/\s+/g, " ");
|
|
2888
2779
|
}
|
|
2889
|
-
function layerPointKey(
|
|
2780
|
+
function layerPointKey(groupId, value) {
|
|
2890
2781
|
const key = normalizePointKey(value);
|
|
2891
|
-
return
|
|
2892
|
-
}
|
|
2893
|
-
function pointKeyPrefix(layerId) {
|
|
2894
|
-
return !layerId || layerId === "birth" ? "" : `${layerId}:`;
|
|
2782
|
+
return groupId === "birth" ? key : `${groupId}:${key}`;
|
|
2895
2783
|
}
|
|
2896
2784
|
function renderGlyphPrimitives(push, primitives, options) {
|
|
2897
2785
|
for (const p of primitives) {
|
|
@@ -3057,7 +2945,42 @@ var DEFAULT_PATH_HIGHLIGHT_WIDTH = 8;
|
|
|
3057
2945
|
var DEFAULT_SPHERE_HIT_RADIUS = DEFAULT_SPHERE_RADIUS + 8;
|
|
3058
2946
|
var DEFAULT_PATH_HIT_STROKE_WIDTH = DEFAULT_PATH_EDGE_WIDTH + 8;
|
|
3059
2947
|
var MUTED_TARGET_COLOR = "#AAA";
|
|
2948
|
+
var INNER_BORDER_SPHERE_NAMES = /* @__PURE__ */ new Set(["Tiphareth"]);
|
|
2949
|
+
var NAZAR_NACRE = "__nacre__";
|
|
2950
|
+
var NAZAR_IRIS = "#33a6dd";
|
|
2951
|
+
var NAZAR_PUPIL = "#0b0b12";
|
|
3060
2952
|
var sphereId = (name) => chunkQ7YAKPBH_js.id("sphere" /* SPHERE */, name);
|
|
2953
|
+
var pathId = (value) => chunkQ7YAKPBH_js.id("path" /* PATH */, value);
|
|
2954
|
+
var SPLIT_GRADIENT_PATH_IDS = new Set(
|
|
2955
|
+
Array.from({ length: 22 }, (_, index) => pathId(String(index + 1)))
|
|
2956
|
+
);
|
|
2957
|
+
var SPLIT_GRADIENT_BLEND = 34;
|
|
2958
|
+
var SPECIAL_SPHERE_PATH_COLORS = {
|
|
2959
|
+
Kether: "#cfe0f2",
|
|
2960
|
+
Chokhmah: "#e6d6ef",
|
|
2961
|
+
Malkuth: "#8a6a52"
|
|
2962
|
+
};
|
|
2963
|
+
var CHOKHMAH_SWEEP_SPAN = 0.42;
|
|
2964
|
+
var CHOKHMAH_SWEEP_SAMPLES = 12;
|
|
2965
|
+
function iridescentColorAt(t) {
|
|
2966
|
+
const frac = (t % 1 + 1) % 1;
|
|
2967
|
+
return interpolateColorStops(IRIDESCENT_STOPS, frac);
|
|
2968
|
+
}
|
|
2969
|
+
function iridescentContactT(center, toward) {
|
|
2970
|
+
const degrees = Math.atan2(toward.y - center.y, toward.x - center.x) * 180 / Math.PI;
|
|
2971
|
+
return ((degrees + 90) / 360 % 1 + 1) % 1;
|
|
2972
|
+
}
|
|
2973
|
+
function edgeAnchoredVector(from, to, radius) {
|
|
2974
|
+
const length = Math.hypot(to.x - from.x, to.y - from.y) || 1;
|
|
2975
|
+
const ux = (to.x - from.x) / length;
|
|
2976
|
+
const uy = (to.y - from.y) / length;
|
|
2977
|
+
return {
|
|
2978
|
+
x1: round3(from.x + ux * radius),
|
|
2979
|
+
y1: round3(from.y + uy * radius),
|
|
2980
|
+
x2: round3(to.x - ux * radius),
|
|
2981
|
+
y2: round3(to.y - uy * radius)
|
|
2982
|
+
};
|
|
2983
|
+
}
|
|
3061
2984
|
var TREE_SPHERE_IDS = [...chunk47BAJUYW_js.TREE_TOPOLOGY_SPHERE_IDS];
|
|
3062
2985
|
var TREE_PATH_IDS = [...chunk47BAJUYW_js.TREE_TOPOLOGY_PATH_IDS];
|
|
3063
2986
|
var CANONICAL_SPHERE_PERCENTAGES = {
|
|
@@ -3309,21 +3232,44 @@ function generateTreeSvg(options = {}) {
|
|
|
3309
3232
|
`<clipPath id="clip-${slug}"><circle cx="${point.x}" cy="${point.y}" r="${radius}"/></clipPath>`
|
|
3310
3233
|
);
|
|
3311
3234
|
}
|
|
3312
|
-
|
|
3313
|
-
|
|
3314
|
-
|
|
3315
|
-
|
|
3316
|
-
|
|
3317
|
-
|
|
3318
|
-
|
|
3319
|
-
|
|
3320
|
-
|
|
3321
|
-
|
|
3322
|
-
|
|
3323
|
-
|
|
3324
|
-
|
|
3325
|
-
|
|
3326
|
-
|
|
3235
|
+
if (palette.mode === "color") {
|
|
3236
|
+
for (const splitPathId of SPLIT_GRADIENT_PATH_IDS) {
|
|
3237
|
+
const splitPath = layout.paths[splitPathId];
|
|
3238
|
+
if (!splitPath || highlights.pathColors[splitPathId] !== void 0 || activationMap.get(splitPathId) !== void 0) {
|
|
3239
|
+
continue;
|
|
3240
|
+
}
|
|
3241
|
+
const fromColor = resolveSplitEndpointColor({
|
|
3242
|
+
palette,
|
|
3243
|
+
sphereId: splitPath.fromId,
|
|
3244
|
+
tree
|
|
3245
|
+
});
|
|
3246
|
+
const toColor = resolveSplitEndpointColor({
|
|
3247
|
+
palette,
|
|
3248
|
+
sphereId: splitPath.toId,
|
|
3249
|
+
tree
|
|
3250
|
+
});
|
|
3251
|
+
const blendStart = round3(50 - SPLIT_GRADIENT_BLEND / 2);
|
|
3252
|
+
const blendEnd = round3(50 + SPLIT_GRADIENT_BLEND / 2);
|
|
3253
|
+
const fromName = chunkQ7YAKPBH_js.parseId(splitPath.fromId);
|
|
3254
|
+
const toName = chunkQ7YAKPBH_js.parseId(splitPath.toId);
|
|
3255
|
+
const contactT = toName === "Chokhmah" ? iridescentContactT(splitPath.to, splitPath.from) : fromName === "Chokhmah" ? iridescentContactT(splitPath.from, splitPath.to) : null;
|
|
3256
|
+
const stops = buildSplitGradientStops({
|
|
3257
|
+
fromName,
|
|
3258
|
+
toName,
|
|
3259
|
+
fromColor,
|
|
3260
|
+
toColor,
|
|
3261
|
+
blendStart,
|
|
3262
|
+
blendEnd,
|
|
3263
|
+
contactT
|
|
3264
|
+
});
|
|
3265
|
+
const edge = edgeAnchoredVector(splitPath.from, splitPath.to, radius);
|
|
3266
|
+
push(
|
|
3267
|
+
`<linearGradient id="path-grad-${chunkQ7YAKPBH_js.parseId(splitPathId)}" gradientUnits="userSpaceOnUse" x1="${edge.x1}" y1="${edge.y1}" x2="${edge.x2}" y2="${edge.y2}">
|
|
3268
|
+
${stops}
|
|
3269
|
+
</linearGradient>`
|
|
3270
|
+
);
|
|
3271
|
+
}
|
|
3272
|
+
}
|
|
3327
3273
|
push(`</defs>`);
|
|
3328
3274
|
const background = options.background ?? "white";
|
|
3329
3275
|
if (background !== "transparent") {
|
|
@@ -3369,22 +3315,31 @@ function generateTreeSvg(options = {}) {
|
|
|
3369
3315
|
activation: activationMap.get(currentPathId),
|
|
3370
3316
|
canonicalColor
|
|
3371
3317
|
});
|
|
3372
|
-
const
|
|
3373
|
-
|
|
3374
|
-
|
|
3375
|
-
}) :
|
|
3376
|
-
const
|
|
3377
|
-
|
|
3378
|
-
|
|
3379
|
-
|
|
3318
|
+
const useSplitGradient = palette.mode === "color" && !activation && highlights.pathColors[currentPathId] === void 0 && SPLIT_GRADIENT_PATH_IDS.has(currentPathId);
|
|
3319
|
+
const solidColor = activation ? resolvePathDisplayColor({ canonicalColor, activation }) : baseColor;
|
|
3320
|
+
const solidEdgeColor = resolvePathEdgeColor({ palette, pathColor: solidColor });
|
|
3321
|
+
const gradientRef = useSplitGradient ? `url(#path-grad-${chunkQ7YAKPBH_js.parseId(currentPathId)})` : null;
|
|
3322
|
+
const color = gradientRef ?? solidColor;
|
|
3323
|
+
const edgeColor = gradientRef ?? solidEdgeColor;
|
|
3324
|
+
const edgeFilter = palette.pathEdgeUseFilter ? ` filter="url(#pathDarken)"` : "";
|
|
3325
|
+
if (gradientRef) {
|
|
3326
|
+
push(
|
|
3327
|
+
`<line x1="${path.from.x}" y1="${path.from.y}" x2="${path.to.x}" y2="${path.to.y}" stroke="${escapeAttr3(solidEdgeColor)}" stroke-width="${pathEdgeWidth}" stroke-linecap="round"${edgeFilter}/>`
|
|
3328
|
+
);
|
|
3329
|
+
}
|
|
3380
3330
|
push(
|
|
3381
|
-
`<line x1="${path.from.x}" y1="${path.from.y}" x2="${path.to.x}" y2="${path.to.y}" stroke="${escapeAttr3(edgeColor)}" stroke-width="${pathEdgeWidth}" stroke-linecap="round"${
|
|
3331
|
+
`<line x1="${path.from.x}" y1="${path.from.y}" x2="${path.to.x}" y2="${path.to.y}" stroke="${escapeAttr3(edgeColor)}" stroke-width="${pathEdgeWidth}" stroke-linecap="round"${edgeFilter}/>`
|
|
3382
3332
|
);
|
|
3383
3333
|
if (activation?.visible && activation.emphasis > 0) {
|
|
3384
3334
|
push(
|
|
3385
3335
|
`<line x1="${path.from.x}" y1="${path.from.y}" x2="${path.to.x}" y2="${path.to.y}" stroke="${escapeAttr3(color)}" stroke-opacity="${round3(0.18 + activation.emphasis * 0.28)}" stroke-width="${round3(pathEdgeWidth + activation.emphasis * 10)}" stroke-linecap="round"/>`
|
|
3386
3336
|
);
|
|
3387
3337
|
}
|
|
3338
|
+
if (gradientRef) {
|
|
3339
|
+
push(
|
|
3340
|
+
`<line x1="${path.from.x}" y1="${path.from.y}" x2="${path.to.x}" y2="${path.to.y}" stroke="${escapeAttr3(solidColor)}" stroke-width="${pathMainWidth}" stroke-linecap="round"/>`
|
|
3341
|
+
);
|
|
3342
|
+
}
|
|
3388
3343
|
push(
|
|
3389
3344
|
`<line x1="${path.from.x}" y1="${path.from.y}" x2="${path.to.x}" y2="${path.to.y}" stroke="${escapeAttr3(color)}" stroke-width="${pathMainWidth}" stroke-linecap="round"/>`
|
|
3390
3345
|
);
|
|
@@ -3499,6 +3454,16 @@ function renderSphere(push, params) {
|
|
|
3499
3454
|
push(
|
|
3500
3455
|
`<circle cx="${point.x}" cy="${point.y}" r="${params.radius}" fill="none" stroke="${escapeAttr3(params.palette.sphereStrokeColor)}" stroke-width="${params.sphereStrokeWidth}"/>`
|
|
3501
3456
|
);
|
|
3457
|
+
} else if (INNER_BORDER_SPHERE_NAMES.has(params.sphereName)) {
|
|
3458
|
+
const borderWidth = round3(params.radius * 0.05);
|
|
3459
|
+
const borderColor = interpolateColor(
|
|
3460
|
+
toPrimaryFill(activeFill, params.palette.defaultSphereFill),
|
|
3461
|
+
"#000000",
|
|
3462
|
+
0.2
|
|
3463
|
+
);
|
|
3464
|
+
push(
|
|
3465
|
+
`<circle cx="${point.x}" cy="${point.y}" r="${round3(params.radius - borderWidth / 2)}" fill="none" stroke="${escapeAttr3(borderColor)}" stroke-width="${borderWidth}"/>`
|
|
3466
|
+
);
|
|
3502
3467
|
}
|
|
3503
3468
|
}
|
|
3504
3469
|
function buildLayoutMap(tree, spherePositions) {
|
|
@@ -3585,6 +3550,40 @@ function resolveTargetActivation(params) {
|
|
|
3585
3550
|
emphasis: state === "selected" ? clamp01(Math.max(strength, 0.9)) : state === "hovered" ? clamp01(Math.max(strength, 0.72)) : state === "active" ? clamp01(Math.max(strength, 0.56)) : 0
|
|
3586
3551
|
};
|
|
3587
3552
|
}
|
|
3553
|
+
function resolveSplitEndpointColor(params) {
|
|
3554
|
+
const name = chunkQ7YAKPBH_js.parseId(params.sphereId);
|
|
3555
|
+
return SPECIAL_SPHERE_PATH_COLORS[name] ?? resolveSphereCanonicalColor(params);
|
|
3556
|
+
}
|
|
3557
|
+
function buildSplitGradientStops(params) {
|
|
3558
|
+
const { fromName, toName, fromColor, toColor, blendStart, blendEnd, contactT } = params;
|
|
3559
|
+
const stop = (offset, color) => ` <stop offset="${round3(offset)}%" stop-color="${escapeAttr3(color)}"/>`;
|
|
3560
|
+
const sweep = (start, end, t0, sphereAtEnd) => Array.from({ length: CHOKHMAH_SWEEP_SAMPLES }, (_, index) => {
|
|
3561
|
+
const f = index / (CHOKHMAH_SWEEP_SAMPLES - 1);
|
|
3562
|
+
const offset = start + f * (end - start);
|
|
3563
|
+
const along = sphereAtEnd ? 1 - f : f;
|
|
3564
|
+
return stop(offset, iridescentColorAt(t0 + along * CHOKHMAH_SWEEP_SPAN));
|
|
3565
|
+
});
|
|
3566
|
+
if (toName === "Chokhmah" && contactT !== null) {
|
|
3567
|
+
return [
|
|
3568
|
+
stop(0, fromColor),
|
|
3569
|
+
stop(blendStart, fromColor),
|
|
3570
|
+
...sweep(blendEnd, 100, contactT, true)
|
|
3571
|
+
].join("\n");
|
|
3572
|
+
}
|
|
3573
|
+
if (fromName === "Chokhmah" && contactT !== null) {
|
|
3574
|
+
return [
|
|
3575
|
+
...sweep(0, blendStart, contactT, false),
|
|
3576
|
+
stop(blendEnd, toColor),
|
|
3577
|
+
stop(100, toColor)
|
|
3578
|
+
].join("\n");
|
|
3579
|
+
}
|
|
3580
|
+
return [
|
|
3581
|
+
stop(0, fromColor),
|
|
3582
|
+
stop(blendStart, fromColor),
|
|
3583
|
+
stop(blendEnd, toColor),
|
|
3584
|
+
stop(100, toColor)
|
|
3585
|
+
].join("\n");
|
|
3586
|
+
}
|
|
3588
3587
|
function resolveSphereCanonicalColor(params) {
|
|
3589
3588
|
const override = params.palette.sphereFills[params.sphereId];
|
|
3590
3589
|
if (override) {
|
|
@@ -3832,33 +3831,18 @@ function arcPath2(cx, cy, radius, startDegrees, endDegrees) {
|
|
|
3832
3831
|
const largeArc = endDegrees - startDegrees <= 180 ? 0 : 1;
|
|
3833
3832
|
return `M ${cx} ${cy} L ${start.x} ${start.y} A ${radius} ${radius} 0 ${largeArc} 1 ${end.x} ${end.y} Z`;
|
|
3834
3833
|
}
|
|
3835
|
-
function renderKether(push, point, radius, baseFill =
|
|
3834
|
+
function renderKether(push, point, radius, baseFill = NAZAR_NACRE) {
|
|
3835
|
+
const { x, y } = point;
|
|
3836
|
+
renderIridescent(push, point, radius, NACRE_STOPS);
|
|
3837
|
+
if (baseFill !== NAZAR_NACRE) {
|
|
3838
|
+
renderSphereTintOverlay(push, point, radius, baseFill, 0.5);
|
|
3839
|
+
}
|
|
3836
3840
|
push(
|
|
3837
|
-
`<circle cx="${
|
|
3841
|
+
`<circle cx="${x}" cy="${y}" r="${round3(radius * 0.42)}" fill="${escapeAttr3(NAZAR_IRIS)}"/>`
|
|
3842
|
+
);
|
|
3843
|
+
push(
|
|
3844
|
+
`<circle cx="${x}" cy="${y}" r="${round3(radius * 0.2)}" fill="${escapeAttr3(NAZAR_PUPIL)}"/>`
|
|
3838
3845
|
);
|
|
3839
|
-
push(`<circle cx="${point.x}" cy="${point.y}" r="${radius}" fill="url(#kether-glow)"/>`);
|
|
3840
|
-
const spokes = 16;
|
|
3841
|
-
const innerRadius = round3(radius * 0.18);
|
|
3842
|
-
const outerRadius = round3(radius * 0.92);
|
|
3843
|
-
const innerWidth = round3(radius * 0.04);
|
|
3844
|
-
const angleStep = 360 / spokes;
|
|
3845
|
-
push(`<g opacity="0.85">`);
|
|
3846
|
-
for (let index = 0; index < spokes; index++) {
|
|
3847
|
-
const angle = index * angleStep;
|
|
3848
|
-
push(`<g transform="rotate(${angle} ${point.x} ${point.y})">`);
|
|
3849
|
-
const x0 = round3(point.x - innerWidth);
|
|
3850
|
-
const y0 = round3(point.y - innerRadius);
|
|
3851
|
-
const x1 = point.x;
|
|
3852
|
-
const y1 = round3(point.y - outerRadius);
|
|
3853
|
-
const x2 = round3(point.x + innerWidth);
|
|
3854
|
-
const y2 = round3(point.y - innerRadius);
|
|
3855
|
-
push(
|
|
3856
|
-
`<polygon points="${x0},${y0} ${x1},${y1} ${x2},${y2} ${point.x},${point.y}" fill="url(#kether-facet)"/>`
|
|
3857
|
-
);
|
|
3858
|
-
push(`</g>`);
|
|
3859
|
-
}
|
|
3860
|
-
push(`</g>`);
|
|
3861
|
-
push(`<circle cx="${point.x}" cy="${point.y}" r="${radius}" fill="url(#kether-rim)"/>`);
|
|
3862
3846
|
}
|
|
3863
3847
|
function renderSlicedSphere(push, point, radius, colors, startAngle) {
|
|
3864
3848
|
const segmentCount = colors.length;
|
|
@@ -3870,18 +3854,28 @@ function renderSlicedSphere(push, point, radius, colors, startAngle) {
|
|
|
3870
3854
|
currentAngle += step;
|
|
3871
3855
|
}
|
|
3872
3856
|
}
|
|
3873
|
-
|
|
3874
|
-
|
|
3875
|
-
|
|
3876
|
-
|
|
3877
|
-
|
|
3878
|
-
|
|
3879
|
-
|
|
3880
|
-
|
|
3881
|
-
|
|
3882
|
-
|
|
3883
|
-
|
|
3884
|
-
|
|
3857
|
+
var IRIDESCENT_STOPS = [
|
|
3858
|
+
[0, "#F0E8EE"],
|
|
3859
|
+
[0.1, "#ffa3e6"],
|
|
3860
|
+
[0.22, "#a7e0ff"],
|
|
3861
|
+
[0.34, "#baff9a"],
|
|
3862
|
+
[0.46, "#ffe28a"],
|
|
3863
|
+
[0.58, "#c6a4ff"],
|
|
3864
|
+
[0.7, "#9ad6ff"],
|
|
3865
|
+
[0.82, "#ffa3e6"],
|
|
3866
|
+
[1, "#F0E8EE"]
|
|
3867
|
+
];
|
|
3868
|
+
var NACRE_STOPS = [
|
|
3869
|
+
[0, "#eaf6f6"],
|
|
3870
|
+
[0.12, "#a8d6ec"],
|
|
3871
|
+
[0.25, "#c3b6ec"],
|
|
3872
|
+
[0.4, "#a6ecec"],
|
|
3873
|
+
[0.55, "#dfe6fb"],
|
|
3874
|
+
[0.7, "#a6cdf0"],
|
|
3875
|
+
[0.82, "#cbb4ec"],
|
|
3876
|
+
[1, "#eaf6f6"]
|
|
3877
|
+
];
|
|
3878
|
+
function renderIridescent(push, point, radius, stops = IRIDESCENT_STOPS) {
|
|
3885
3879
|
const slices = 72;
|
|
3886
3880
|
const sphereRadius = round3(radius * 0.96);
|
|
3887
3881
|
for (let index = 0; index < slices; index++) {
|
|
@@ -3996,10 +3990,9 @@ exports.generateGlyphSvg = generateGlyphSvg;
|
|
|
3996
3990
|
exports.generateTreeSvg = generateTreeSvg;
|
|
3997
3991
|
exports.getArcheometerRenderModel = getArcheometerRenderModel;
|
|
3998
3992
|
exports.getAstroGlyph = getAstroGlyph;
|
|
3999
|
-
exports.getAstroWheelRenderModel = getAstroWheelRenderModel;
|
|
4000
3993
|
exports.getRouteActivations = getRouteActivations;
|
|
4001
3994
|
exports.getTreeLayout = getTreeLayout;
|
|
4002
3995
|
exports.getTreeRenderModel = getTreeRenderModel;
|
|
4003
3996
|
exports.listAstroGlyphs = listAstroGlyphs;
|
|
4004
3997
|
//# sourceMappingURL=out.js.map
|
|
4005
|
-
//# sourceMappingURL=chunk-
|
|
3998
|
+
//# sourceMappingURL=chunk-LUHQNKKJ.js.map
|