@gracefullight/saju 0.1.1 → 0.3.0

package/dist/core/relations.js

@@ -0,0 +1,305 @@
+import { getStemElement, getBranchElement } from "./ten-gods";
+export const STEM_COMBINATIONS = [
+    { stems: ["甲", "己"], resultElement: "earth" },
+    { stems: ["乙", "庚"], resultElement: "metal" },
+    { stems: ["丙", "辛"], resultElement: "water" },
+    { stems: ["丁", "壬"], resultElement: "wood" },
+    { stems: ["戊", "癸"], resultElement: "fire" },
+];
+export const BRANCH_SIX_COMBINATIONS = [
+    { branches: ["子", "丑"], resultElement: "earth" },
+    { branches: ["寅", "亥"], resultElement: "wood" },
+    { branches: ["卯", "戌"], resultElement: "fire" },
+    { branches: ["辰", "酉"], resultElement: "metal" },
+    { branches: ["巳", "申"], resultElement: "water" },
+    { branches: ["午", "未"], resultElement: "earth" },
+];
+export const BRANCH_TRIPLE_COMBINATIONS = [
+    { branches: ["寅", "午", "戌"], resultElement: "fire" },
+    { branches: ["申", "子", "辰"], resultElement: "water" },
+    { branches: ["亥", "卯", "未"], resultElement: "wood" },
+    { branches: ["巳", "酉", "丑"], resultElement: "metal" },
+];
+export const BRANCH_DIRECTIONAL_COMBINATIONS = [
+    { branches: ["寅", "卯", "辰"], resultElement: "wood" },
+    { branches: ["巳", "午", "未"], resultElement: "fire" },
+    { branches: ["申", "酉", "戌"], resultElement: "metal" },
+    { branches: ["亥", "子", "丑"], resultElement: "water" },
+];
+export const BRANCH_CLASHES = [
+    ["子", "午"],
+    ["丑", "未"],
+    ["寅", "申"],
+    ["卯", "酉"],
+    ["辰", "戌"],
+    ["巳", "亥"],
+];
+export const BRANCH_HARMS = [
+    ["子", "未"],
+    ["丑", "午"],
+    ["寅", "巳"],
+    ["卯", "辰"],
+    ["申", "亥"],
+    ["酉", "戌"],
+];
+export const BRANCH_PUNISHMENTS = [
+    { branches: ["寅", "巳", "申"], type: "무은지형" },
+    { branches: ["丑", "戌", "未"], type: "시세지형" },
+    { branches: ["子", "卯"], type: "무례지형" },
+    { branches: ["辰", "辰"], type: "자형" },
+    { branches: ["午", "午"], type: "자형" },
+    { branches: ["酉", "酉"], type: "자형" },
+    { branches: ["亥", "亥"], type: "자형" },
+];
+export const BRANCH_DESTRUCTIONS = [
+    ["子", "酉"],
+    ["丑", "辰"],
+    ["寅", "亥"],
+    ["卯", "午"],
+    ["巳", "申"],
+    ["未", "戌"],
+];
+const MONTH_BRANCH_ELEMENT_SUPPORT = {
+    寅: ["wood"],
+    卯: ["wood"],
+    辰: ["wood", "earth", "water"],
+    巳: ["fire"],
+    午: ["fire"],
+    未: ["fire", "earth"],
+    申: ["metal"],
+    酉: ["metal"],
+    戌: ["metal", "earth", "fire"],
+    亥: ["water"],
+    子: ["water"],
+    丑: ["water", "earth", "metal"],
+};
+function checkTransformationCondition(resultElement, monthBranch, allBranches, isComplete) {
+    const supportedElements = MONTH_BRANCH_ELEMENT_SUPPORT[monthBranch] || [];
+    const hasMonthSupport = supportedElements.includes(resultElement);
+    const branchElements = allBranches.map((b) => getBranchElement(b));
+    const resultElementCount = branchElements.filter((e) => e === resultElement).length;
+    const hasStrengthSupport = resultElementCount >= 2;
+    if (!isComplete) {
+        return { status: "반합", reason: "불완전 합 - 일부 지지 부재" };
+    }
+    if (hasMonthSupport) {
+        return { status: "화", reason: `월령(${monthBranch})이 ${resultElement}을(를) 지지` };
+    }
+    if (hasStrengthSupport) {
+        return { status: "화", reason: `${resultElement} 기세 충분(${resultElementCount}개)` };
+    }
+    return { status: "불화", reason: "월령 및 기세 미충족으로 화 불성립" };
+}
+function checkStemTransformationCondition(resultElement, monthBranch, allStems) {
+    const supportedElements = MONTH_BRANCH_ELEMENT_SUPPORT[monthBranch] || [];
+    const hasMonthSupport = supportedElements.includes(resultElement);
+    const stemElements = allStems.map((s) => getStemElement(s));
+    const resultElementCount = stemElements.filter((e) => e === resultElement).length;
+    const hasStrengthSupport = resultElementCount >= 2;
+    if (hasMonthSupport) {
+        return { status: "화", reason: `월령(${monthBranch})이 ${resultElement}을(를) 지지` };
+    }
+    if (hasStrengthSupport) {
+        return { status: "화", reason: `${resultElement} 기세 충분(${resultElementCount}개)` };
+    }
+    return { status: "불화", reason: "월령 및 기세 미충족으로 화 불성립" };
+}
+export function analyzeRelations(yearPillar, monthPillar, dayPillar, hourPillar) {
+    const monthBranch = monthPillar[1];
+    const stems = [
+        { char: yearPillar[0], position: "year" },
+        { char: monthPillar[0], position: "month" },
+        { char: dayPillar[0], position: "day" },
+        { char: hourPillar[0], position: "hour" },
+    ];
+    const branches = [
+        { char: yearPillar[1], position: "year" },
+        { char: monthPillar[1], position: "month" },
+        { char: dayPillar[1], position: "day" },
+        { char: hourPillar[1], position: "hour" },
+    ];
+    const allStemChars = stems.map((s) => s.char);
+    const allBranchChars = branches.map((b) => b.char);
+    const combinations = [];
+    const clashes = [];
+    const harms = [];
+    const punishments = [];
+    const destructions = [];
+    for (let i = 0; i < stems.length; i++) {
+        for (let j = i + 1; j < stems.length; j++) {
+            const s1 = stems[i];
+            const s2 = stems[j];
+            for (const combo of STEM_COMBINATIONS) {
+                if ((s1.char === combo.stems[0] && s2.char === combo.stems[1]) ||
+                    (s1.char === combo.stems[1] && s2.char === combo.stems[0])) {
+                    const transform = checkStemTransformationCondition(combo.resultElement, monthBranch, allStemChars);
+                    combinations.push({
+                        type: "천간합",
+                        pair: [s1.char, s2.char],
+                        positions: [s1.position, s2.position],
+                        resultElement: combo.resultElement,
+                        transformStatus: transform.status,
+                        transformReason: transform.reason,
+                    });
+                }
+            }
+        }
+    }
+    for (let i = 0; i < branches.length; i++) {
+        for (let j = i + 1; j < branches.length; j++) {
+            const b1 = branches[i];
+            const b2 = branches[j];
+            for (const combo of BRANCH_SIX_COMBINATIONS) {
+                if ((b1.char === combo.branches[0] && b2.char === combo.branches[1]) ||
+                    (b1.char === combo.branches[1] && b2.char === combo.branches[0])) {
+                    const transform = checkTransformationCondition(combo.resultElement, monthBranch, allBranchChars, true);
+                    combinations.push({
+                        type: "육합",
+                        pair: [b1.char, b2.char],
+                        positions: [b1.position, b2.position],
+                        resultElement: combo.resultElement,
+                        transformStatus: transform.status,
+                        transformReason: transform.reason,
+                    });
+                }
+            }
+            for (const clash of BRANCH_CLASHES) {
+                if ((b1.char === clash[0] && b2.char === clash[1]) ||
+                    (b1.char === clash[1] && b2.char === clash[0])) {
+                    clashes.push({
+                        type: "충",
+                        pair: [b1.char, b2.char],
+                        positions: [b1.position, b2.position],
+                    });
+                }
+            }
+            for (const harm of BRANCH_HARMS) {
+                if ((b1.char === harm[0] && b2.char === harm[1]) ||
+                    (b1.char === harm[1] && b2.char === harm[0])) {
+                    harms.push({
+                        type: "해",
+                        pair: [b1.char, b2.char],
+                        positions: [b1.position, b2.position],
+                    });
+                }
+            }
+            for (const dest of BRANCH_DESTRUCTIONS) {
+                if ((b1.char === dest[0] && b2.char === dest[1]) ||
+                    (b1.char === dest[1] && b2.char === dest[0])) {
+                    destructions.push({
+                        type: "파",
+                        pair: [b1.char, b2.char],
+                        positions: [b1.position, b2.position],
+                    });
+                }
+            }
+        }
+    }
+    const branchChars = branches.map((b) => b.char);
+    for (const combo of BRANCH_TRIPLE_COMBINATIONS) {
+        const matched = combo.branches.filter((b) => branchChars.includes(b));
+        if (matched.length >= 2) {
+            const positions = matched.map((m) => branches.find((b) => b.char === m).position);
+            const isComplete = matched.length === 3;
+            const transform = checkTransformationCondition(combo.resultElement, monthBranch, allBranchChars, isComplete);
+            combinations.push({
+                type: "삼합",
+                branches: matched,
+                positions,
+                resultElement: combo.resultElement,
+                isComplete,
+                transformStatus: transform.status,
+                transformReason: transform.reason,
+            });
+        }
+    }
+    for (const combo of BRANCH_DIRECTIONAL_COMBINATIONS) {
+        const matched = combo.branches.filter((b) => branchChars.includes(b));
+        if (matched.length >= 2) {
+            const positions = matched.map((m) => branches.find((b) => b.char === m).position);
+            const isComplete = matched.length === 3;
+            const transform = checkTransformationCondition(combo.resultElement, monthBranch, allBranchChars, isComplete);
+            combinations.push({
+                type: "방합",
+                branches: matched,
+                positions,
+                resultElement: combo.resultElement,
+                isComplete,
+                transformStatus: transform.status,
+                transformReason: transform.reason,
+            });
+        }
+    }
+    for (const punishment of BRANCH_PUNISHMENTS) {
+        const matched = punishment.branches.filter((b) => branchChars.includes(b));
+        const isTriple = punishment.branches.length === 3;
+        const isSelfPunishment = punishment.type === "자형";
+        if (isSelfPunishment) {
+            const count = branchChars.filter((b) => b === punishment.branches[0]).length;
+            if (count >= 2) {
+                punishments.push({
+                    type: "형",
+                    branches: Array(count).fill(punishment.branches[0]),
+                    positions: branches
+                        .filter((b) => b.char === punishment.branches[0])
+                        .map((b) => b.position),
+                    punishmentType: punishment.type,
+                });
+            }
+        }
+        else if (isTriple && matched.length >= 2) {
+            const positions = matched.map((m) => branches.find((b) => b.char === m).position);
+            punishments.push({
+                type: "형",
+                branches: matched,
+                positions,
+                punishmentType: punishment.type,
+            });
+        }
+        else if (!isTriple && matched.length === 2) {
+            const positions = matched.map((m) => branches.find((b) => b.char === m).position);
+            punishments.push({
+                type: "형",
+                branches: matched,
+                positions,
+                punishmentType: punishment.type,
+            });
+        }
+    }
+    const all = [...combinations, ...clashes, ...harms, ...punishments, ...destructions];
+    return {
+        combinations,
+        clashes,
+        harms,
+        punishments,
+        destructions,
+        all,
+    };
+}
+export function findStemCombination(stem1, stem2) {
+    for (const combo of STEM_COMBINATIONS) {
+        if ((stem1 === combo.stems[0] && stem2 === combo.stems[1]) ||
+            (stem1 === combo.stems[1] && stem2 === combo.stems[0])) {
+            return combo;
+        }
+    }
+    return null;
+}
+export function findBranchClash(branch1, branch2) {
+    for (const clash of BRANCH_CLASHES) {
+        if ((branch1 === clash[0] && branch2 === clash[1]) ||
+            (branch1 === clash[1] && branch2 === clash[0])) {
+            return true;
+        }
+    }
+    return false;
+}
+export function findBranchSixCombination(branch1, branch2) {
+    for (const combo of BRANCH_SIX_COMBINATIONS) {
+        if ((branch1 === combo.branches[0] && branch2 === combo.branches[1]) ||
+            (branch1 === combo.branches[1] && branch2 === combo.branches[0])) {
+            return combo;
+        }
+    }
+    return null;
+}

package/dist/core/solar-terms.d.ts

@@ -0,0 +1,155 @@
+import type { DateAdapter } from "@/adapters/date-adapter";
+/**
+ * 24 Solar Terms (二十四節氣)
+ * Each term corresponds to a specific solar longitude
+ */
+export declare const SOLAR_TERMS: readonly [{
+    readonly name: "소한";
+    readonly hanja: "小寒";
+    readonly longitude: 285;
+}, {
+    readonly name: "대한";
+    readonly hanja: "大寒";
+    readonly longitude: 300;
+}, {
+    readonly name: "입춘";
+    readonly hanja: "立春";
+    readonly longitude: 315;
+}, {
+    readonly name: "우수";
+    readonly hanja: "雨水";
+    readonly longitude: 330;
+}, {
+    readonly name: "경칩";
+    readonly hanja: "驚蟄";
+    readonly longitude: 345;
+}, {
+    readonly name: "춘분";
+    readonly hanja: "春分";
+    readonly longitude: 0;
+}, {
+    readonly name: "청명";
+    readonly hanja: "淸明";
+    readonly longitude: 15;
+}, {
+    readonly name: "곡우";
+    readonly hanja: "穀雨";
+    readonly longitude: 30;
+}, {
+    readonly name: "입하";
+    readonly hanja: "立夏";
+    readonly longitude: 45;
+}, {
+    readonly name: "소만";
+    readonly hanja: "小滿";
+    readonly longitude: 60;
+}, {
+    readonly name: "망종";
+    readonly hanja: "芒種";
+    readonly longitude: 75;
+}, {
+    readonly name: "하지";
+    readonly hanja: "夏至";
+    readonly longitude: 90;
+}, {
+    readonly name: "소서";
+    readonly hanja: "小暑";
+    readonly longitude: 105;
+}, {
+    readonly name: "대서";
+    readonly hanja: "大暑";
+    readonly longitude: 120;
+}, {
+    readonly name: "입추";
+    readonly hanja: "立秋";
+    readonly longitude: 135;
+}, {
+    readonly name: "처서";
+    readonly hanja: "處暑";
+    readonly longitude: 150;
+}, {
+    readonly name: "백로";
+    readonly hanja: "白露";
+    readonly longitude: 165;
+}, {
+    readonly name: "추분";
+    readonly hanja: "秋分";
+    readonly longitude: 180;
+}, {
+    readonly name: "한로";
+    readonly hanja: "寒露";
+    readonly longitude: 195;
+}, {
+    readonly name: "상강";
+    readonly hanja: "霜降";
+    readonly longitude: 210;
+}, {
+    readonly name: "입동";
+    readonly hanja: "立冬";
+    readonly longitude: 225;
+}, {
+    readonly name: "소설";
+    readonly hanja: "小雪";
+    readonly longitude: 240;
+}, {
+    readonly name: "대설";
+    readonly hanja: "大雪";
+    readonly longitude: 255;
+}, {
+    readonly name: "동지";
+    readonly hanja: "冬至";
+    readonly longitude: 270;
+}];
+export type SolarTermName = (typeof SOLAR_TERMS)[number]["name"];
+export type SolarTermHanja = (typeof SOLAR_TERMS)[number]["hanja"];
+export interface SolarTerm {
+    name: SolarTermName;
+    hanja: SolarTermHanja;
+    longitude: number;
+}
+export interface SolarTermDateInfo {
+    year: number;
+    month: number;
+    day: number;
+    hour: number;
+    minute: number;
+}
+export interface SolarTermInfo {
+    /** Current solar term (the one that has passed) */
+    current: SolarTerm;
+    /** Date when the current solar term started */
+    currentDate: SolarTermDateInfo;
+    /** Milliseconds timestamp of current solar term (for calculations) */
+    currentMillis: number;
+    /** Days elapsed since the current solar term */
+    daysSinceCurrent: number;
+    /** Next solar term (upcoming) */
+    next: SolarTerm;
+    /** Date when the next solar term will start */
+    nextDate: SolarTermDateInfo;
+    /** Milliseconds timestamp of next solar term (for calculations) */
+    nextMillis: number;
+    /** Days until the next solar term */
+    daysUntilNext: number;
+    /** Previous "節" (Jie) - the solar term that marks month boundary (for major luck calculation) */
+    prevJie: SolarTerm;
+    /** Date of previous Jie */
+    prevJieDate: SolarTermDateInfo;
+    /** Milliseconds timestamp of previous Jie */
+    prevJieMillis: number;
+    /** Next "節" (Jie) - the solar term that marks month boundary (for major luck calculation) */
+    nextJie: SolarTerm;
+    /** Date of next Jie */
+    nextJieDate: SolarTermDateInfo;
+    /** Milliseconds timestamp of next Jie */
+    nextJieMillis: number;
+}
+export declare function analyzeSolarTerms<T>(adapter: DateAdapter<T>, dtLocal: T): SolarTermInfo;
+/**
+ * Get all solar term dates for a given year
+ */
+export declare function getSolarTermsForYear<T>(adapter: DateAdapter<T>, year: number, timezone: string): Array<{
+    term: SolarTerm;
+    date: SolarTermDateInfo;
+}>;
+//# sourceMappingURL=solar-terms.d.ts.map

package/dist/core/solar-terms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solar-terms.d.ts","sourceRoot":"","sources":["../../src/core/solar-terms.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE3D;;;GAGG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBd,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC;AACjE,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC;AAEnE,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,aAAa,CAAC;IACpB,KAAK,EAAE,cAAc,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,aAAa;IAC5B,mDAAmD;IACnD,OAAO,EAAE,SAAS,CAAC;IACnB,+CAA+C;IAC/C,WAAW,EAAE,iBAAiB,CAAC;IAC/B,sEAAsE;IACtE,aAAa,EAAE,MAAM,CAAC;IACtB,gDAAgD;IAChD,gBAAgB,EAAE,MAAM,CAAC;IACzB,iCAAiC;IACjC,IAAI,EAAE,SAAS,CAAC;IAChB,+CAA+C;IAC/C,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,mEAAmE;IACnE,UAAU,EAAE,MAAM,CAAC;IACnB,qCAAqC;IACrC,aAAa,EAAE,MAAM,CAAC;IACtB,iGAAiG;IACjG,OAAO,EAAE,SAAS,CAAC;IACnB,2BAA2B;IAC3B,WAAW,EAAE,iBAAiB,CAAC;IAC/B,6CAA6C;IAC7C,aAAa,EAAE,MAAM,CAAC;IACtB,6FAA6F;IAC7F,OAAO,EAAE,SAAS,CAAC;IACnB,uBAAuB;IACvB,WAAW,EAAE,iBAAiB,CAAC;IAC/B,yCAAyC;IACzC,aAAa,EAAE,MAAM,CAAC;CACvB;AAuMD,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,aAAa,CA0EvF;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EACpC,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC,EACvB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GACf,KAAK,CAAC;IACP,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,iBAAiB,CAAC;CACzB,CAAC,CAuBD"}