Macbook
442 lines
14 KiB
TypeScript
442 lines
14 KiB
TypeScript
/**
|
|
* 9·20일 신고가 매수 / 9·20일 신저가 매도 — Ta4j NH_PRIOR·NL_PRIOR + 조절 가능 필터
|
|
*/
|
|
import type { ConditionDSL, LogicNode } from './strategyTypes';
|
|
import { initConditionPeriodsInherit, type IndicatorPeriodDef } from './conditionPeriods';
|
|
import { genId } from './strategyNodeIds';
|
|
import { nhPriorField, nlPriorField, syncPriceExtremeSimpleFields } from './priceExtremeIndicators';
|
|
|
|
export const NEW_HIGH_9_20_BUY_VALUE = 'NEW_HIGH_9_20_BUY';
|
|
export const NEW_LOW_9_20_SELL_VALUE = 'NEW_LOW_9_20_SELL';
|
|
|
|
export const DEFAULT_SHORT_PERIOD = 9;
|
|
export const DEFAULT_LONG_PERIOD = 20;
|
|
|
|
/** 필터 강도 — 전략편집기에서 조절 */
|
|
export type PriceExtremeFilterLevel = 'strict' | 'balanced' | 'relaxed';
|
|
|
|
export const DEFAULT_FILTER_LEVEL: PriceExtremeFilterLevel = 'balanced';
|
|
|
|
export const PRICE_EXTREME_FILTER_OPTIONS: {
|
|
value: PriceExtremeFilterLevel;
|
|
label: string;
|
|
desc: string;
|
|
}[] = [
|
|
{
|
|
value: 'strict',
|
|
label: '강함',
|
|
desc: 'ADX·거래량 필터 최대 — 횡보 구간 강력 제외',
|
|
},
|
|
{
|
|
value: 'balanced',
|
|
label: '보통 (권장)',
|
|
desc: 'ADX·거래량 완화 — 돌파 신호와 균형',
|
|
},
|
|
{
|
|
value: 'relaxed',
|
|
label: '완화',
|
|
desc: '가격 돌파만 — ADX·거래량 필터 없음',
|
|
},
|
|
];
|
|
|
|
type FilterPreset = {
|
|
buyAdx: number | null;
|
|
sellAdx: number | null;
|
|
volume: boolean;
|
|
/** strict — 단기(9) CROSS_UP 동시 확인 */
|
|
shortCrossConfirm: boolean;
|
|
highLowConfirm: boolean;
|
|
};
|
|
|
|
const FILTER_PRESETS: Record<PriceExtremeFilterLevel, FilterPreset> = {
|
|
strict: { buyAdx: 25, sellAdx: 20, volume: true, shortCrossConfirm: true, highLowConfirm: true },
|
|
balanced: { buyAdx: 20, sellAdx: 15, volume: true, shortCrossConfirm: false, highLowConfirm: true },
|
|
relaxed: { buyAdx: null, sellAdx: null, volume: false, shortCrossConfirm: false, highLowConfirm: false },
|
|
};
|
|
|
|
export function isNewHigh920BuyPaletteValue(value: string): boolean {
|
|
return value === NEW_HIGH_9_20_BUY_VALUE;
|
|
}
|
|
|
|
export function isNewLow920SellPaletteValue(value: string): boolean {
|
|
return value === NEW_LOW_9_20_SELL_VALUE;
|
|
}
|
|
|
|
export function isPriceExtremeBreakoutPairPaletteValue(value: string): boolean {
|
|
return isNewHigh920BuyPaletteValue(value) || isNewLow920SellPaletteValue(value);
|
|
}
|
|
|
|
export function isPriceExtremeBreakoutPairRoot(node: LogicNode): boolean {
|
|
return node.type === 'AND' && !!node.priceExtremePair?.mode;
|
|
}
|
|
|
|
function adxThresholdField(threshold: number): string {
|
|
return `ADX_${threshold}`;
|
|
}
|
|
|
|
function makePriceExtremeCondition(
|
|
indicatorType: 'NEW_HIGH' | 'NEW_LOW',
|
|
conditionType: string,
|
|
leftField: string,
|
|
rightField: string,
|
|
period: number,
|
|
): LogicNode {
|
|
const base: ConditionDSL = {
|
|
indicatorType,
|
|
conditionType,
|
|
leftField,
|
|
rightField,
|
|
period,
|
|
candleRange: 1,
|
|
valuePeriodOverride: true,
|
|
thresholdOverride: false,
|
|
rightPeriodOverride: false,
|
|
};
|
|
return {
|
|
id: genId(),
|
|
type: 'CONDITION',
|
|
condition: syncPriceExtremeSimpleFields(base),
|
|
};
|
|
}
|
|
|
|
function makeFilterCondition(
|
|
indicatorType: string,
|
|
conditionType: string,
|
|
leftField: string,
|
|
rightField: string,
|
|
def: IndicatorPeriodDef,
|
|
): LogicNode {
|
|
const base: ConditionDSL = {
|
|
indicatorType,
|
|
conditionType,
|
|
leftField,
|
|
rightField,
|
|
candleRange: 1,
|
|
valuePeriodOverride: false,
|
|
thresholdOverride: rightField.startsWith('ADX_'),
|
|
rightPeriodOverride: false,
|
|
...(rightField.startsWith('ADX_')
|
|
? { targetValue: parseInt(rightField.split('_')[1], 10) }
|
|
: null),
|
|
};
|
|
return {
|
|
id: genId(),
|
|
type: 'CONDITION',
|
|
condition: initConditionPeriodsInherit(indicatorType, base, def),
|
|
};
|
|
}
|
|
|
|
function resolveFilterLevel(level?: PriceExtremeFilterLevel): PriceExtremeFilterLevel {
|
|
return level ?? DEFAULT_FILTER_LEVEL;
|
|
}
|
|
|
|
/** 저장된 트리에서 필터 강도 추론 (레거시 strict 호환) */
|
|
export function inferPriceExtremeFilterLevel(node: LogicNode): PriceExtremeFilterLevel {
|
|
const stored = node.priceExtremePair?.filterLevel;
|
|
if (stored) return stored;
|
|
|
|
const children = node.children ?? [];
|
|
const hasAdx = children.some(c => c.condition?.indicatorType === 'ADX');
|
|
const hasVol = children.some(c => c.condition?.indicatorType === 'VOLUME');
|
|
if (!hasAdx && !hasVol) return 'relaxed';
|
|
|
|
const adxCond = children.find(c => c.condition?.indicatorType === 'ADX')?.condition;
|
|
const adxVal = adxCond?.targetValue
|
|
?? (adxCond?.rightField?.match(/ADX_(\d+)/)?.[1]
|
|
? parseInt(adxCond.rightField.match(/ADX_(\d+)/)![1], 10)
|
|
: null);
|
|
|
|
if (adxVal != null && adxVal >= 25) return 'strict';
|
|
if (adxVal != null && adxVal >= 20) return 'balanced';
|
|
return 'balanced';
|
|
}
|
|
|
|
function buildPriceChildren(
|
|
mode: 'buy' | 'sell',
|
|
short: number,
|
|
long: number,
|
|
preset: FilterPreset,
|
|
): LogicNode[] {
|
|
const ind = mode === 'buy' ? 'NEW_HIGH' : 'NEW_LOW';
|
|
const crossType = mode === 'buy' ? 'CROSS_UP' : 'CROSS_DOWN';
|
|
const priorShort = mode === 'buy' ? nhPriorField(short) : nlPriorField(short);
|
|
const priorLong = mode === 'buy' ? nhPriorField(long) : nlPriorField(long);
|
|
|
|
const nodes: LogicNode[] = [];
|
|
|
|
if (preset.shortCrossConfirm) {
|
|
nodes.push(makePriceExtremeCondition(ind, crossType, 'CLOSE_PRICE', priorShort, short));
|
|
}
|
|
|
|
// 장기 신고가/신저가 — 돌파 순간 1봉 (GTE 아님 → 연속 시그널 방지)
|
|
nodes.push(makePriceExtremeCondition(ind, crossType, 'CLOSE_PRICE', priorLong, long));
|
|
|
|
if (preset.highLowConfirm) {
|
|
nodes.push(makePriceExtremeCondition(
|
|
ind,
|
|
mode === 'buy' ? 'GTE' : 'LTE',
|
|
mode === 'buy' ? 'HIGH_PRICE' : 'LOW_PRICE',
|
|
priorLong,
|
|
long,
|
|
));
|
|
}
|
|
|
|
return nodes;
|
|
}
|
|
|
|
function buildFilterChildren(
|
|
mode: 'buy' | 'sell',
|
|
preset: FilterPreset,
|
|
def: IndicatorPeriodDef,
|
|
): LogicNode[] {
|
|
const nodes: LogicNode[] = [];
|
|
const adx = mode === 'buy' ? preset.buyAdx : preset.sellAdx;
|
|
if (adx != null) {
|
|
nodes.push(makeFilterCondition(
|
|
'ADX',
|
|
'GTE',
|
|
'ADX_VALUE',
|
|
adxThresholdField(adx),
|
|
def,
|
|
));
|
|
}
|
|
if (preset.volume) {
|
|
nodes.push(makeFilterCondition(
|
|
'VOLUME',
|
|
'GT',
|
|
'VOLUME_VALUE',
|
|
'VOLUME_MA',
|
|
def,
|
|
));
|
|
}
|
|
return nodes;
|
|
}
|
|
|
|
/** 9·20일 신고가 매수 */
|
|
export function buildNewHigh920BuyTree(
|
|
def: IndicatorPeriodDef,
|
|
shortPeriod = DEFAULT_SHORT_PERIOD,
|
|
longPeriod = DEFAULT_LONG_PERIOD,
|
|
filterLevel: PriceExtremeFilterLevel = DEFAULT_FILTER_LEVEL,
|
|
): LogicNode {
|
|
const short = Math.max(1, Math.round(shortPeriod));
|
|
const long = Math.max(short + 1, Math.round(longPeriod));
|
|
const level = resolveFilterLevel(filterLevel);
|
|
const preset = FILTER_PRESETS[level];
|
|
|
|
return {
|
|
id: genId(),
|
|
type: 'AND',
|
|
priceExtremePair: { mode: 'buy', shortPeriod: short, longPeriod: long, filterLevel: level },
|
|
children: [
|
|
...buildPriceChildren('buy', short, long, preset),
|
|
...buildFilterChildren('buy', preset, def),
|
|
],
|
|
};
|
|
}
|
|
|
|
/** 9·20일 신저가 매도 */
|
|
export function buildNewLow920SellTree(
|
|
def: IndicatorPeriodDef,
|
|
shortPeriod = DEFAULT_SHORT_PERIOD,
|
|
longPeriod = DEFAULT_LONG_PERIOD,
|
|
filterLevel: PriceExtremeFilterLevel = DEFAULT_FILTER_LEVEL,
|
|
): LogicNode {
|
|
const short = Math.max(1, Math.round(shortPeriod));
|
|
const long = Math.max(short + 1, Math.round(longPeriod));
|
|
const level = resolveFilterLevel(filterLevel);
|
|
const preset = FILTER_PRESETS[level];
|
|
|
|
return {
|
|
id: genId(),
|
|
type: 'AND',
|
|
priceExtremePair: { mode: 'sell', shortPeriod: short, longPeriod: long, filterLevel: level },
|
|
children: [
|
|
...buildPriceChildren('sell', short, long, preset),
|
|
...buildFilterChildren('sell', preset, def),
|
|
],
|
|
};
|
|
}
|
|
|
|
export function buildPriceExtremeBreakoutTree(
|
|
value: string,
|
|
def: IndicatorPeriodDef,
|
|
filterLevel: PriceExtremeFilterLevel = DEFAULT_FILTER_LEVEL,
|
|
): LogicNode | null {
|
|
if (isNewHigh920BuyPaletteValue(value)) return buildNewHigh920BuyTree(def, DEFAULT_SHORT_PERIOD, DEFAULT_LONG_PERIOD, filterLevel);
|
|
if (isNewLow920SellPaletteValue(value)) return buildNewLow920SellTree(def, DEFAULT_SHORT_PERIOD, DEFAULT_LONG_PERIOD, filterLevel);
|
|
return null;
|
|
}
|
|
|
|
export function filterLevelLabel(level: PriceExtremeFilterLevel): string {
|
|
return PRICE_EXTREME_FILTER_OPTIONS.find(o => o.value === level)?.label ?? level;
|
|
}
|
|
|
|
export function filterLevelDesc(level: PriceExtremeFilterLevel): string {
|
|
return PRICE_EXTREME_FILTER_OPTIONS.find(o => o.value === level)?.desc ?? '';
|
|
}
|
|
|
|
export function priceExtremePairDisplayName(
|
|
mode: 'buy' | 'sell',
|
|
short = DEFAULT_SHORT_PERIOD,
|
|
long = DEFAULT_LONG_PERIOD,
|
|
): string {
|
|
return mode === 'buy'
|
|
? `${short}·${long}일 신고가 매수`
|
|
: `${short}·${long}일 신저가 매도`;
|
|
}
|
|
|
|
export function priceExtremeFilterSummary(
|
|
mode: 'buy' | 'sell',
|
|
level: PriceExtremeFilterLevel = DEFAULT_FILTER_LEVEL,
|
|
): string {
|
|
const preset = FILTER_PRESETS[level];
|
|
const parts: string[] = [];
|
|
const adx = mode === 'buy' ? preset.buyAdx : preset.sellAdx;
|
|
if (adx != null) parts.push(`ADX≥${adx}`);
|
|
else parts.push('ADX 필터 없음');
|
|
if (preset.volume) parts.push('거래량>MA');
|
|
else parts.push('거래량 필터 없음');
|
|
if (!preset.highLowConfirm) parts.push('고/저가 확인 생략');
|
|
return parts.join(', ');
|
|
}
|
|
|
|
export function priceExtremePairSummaryText(
|
|
mode: 'buy' | 'sell',
|
|
short = DEFAULT_SHORT_PERIOD,
|
|
long = DEFAULT_LONG_PERIOD,
|
|
filterLevel: PriceExtremeFilterLevel = DEFAULT_FILTER_LEVEL,
|
|
): string {
|
|
const preset = FILTER_PRESETS[filterLevel];
|
|
const lines: string[] = [];
|
|
if (preset.shortCrossConfirm) {
|
|
lines.push(`종가 ${short}일 ${mode === 'buy' ? '신고가' : '신저가'} ${mode === 'buy' ? '상향돌파' : '하향이탈'}`);
|
|
}
|
|
lines.push(`종가 ${long}일 ${mode === 'buy' ? '신고가 상향돌파' : '신저가 하향이탈'}`);
|
|
if (preset.highLowConfirm) {
|
|
lines.push(`${mode === 'buy' ? '고가' : '저가'}${mode === 'buy' ? '≥' : '≤'}${long}일선`);
|
|
}
|
|
const adx = mode === 'buy' ? preset.buyAdx : preset.sellAdx;
|
|
if (adx != null) lines.push(`ADX≥${adx}`);
|
|
if (preset.volume) lines.push('거래량>MA');
|
|
return lines.join(' AND ');
|
|
}
|
|
|
|
export function priceExtremePairPaletteDesc(value: string): string {
|
|
if (isNewHigh920BuyPaletteValue(value)) {
|
|
return '9·20일 신고가 돌파 + 조절 가능 ADX·거래량 필터 (기본: 보통)';
|
|
}
|
|
if (isNewLow920SellPaletteValue(value)) {
|
|
return '9·20일 신저가 이탈 + 조절 가능 ADX·거래량 필터 (기본: 보통)';
|
|
}
|
|
return '';
|
|
}
|
|
|
|
/** 필터 강도 변경 — 노드 id·기간 유지, 자식 조건 재구성 */
|
|
export function setPriceExtremePairFilterLevel(
|
|
node: LogicNode,
|
|
filterLevel: PriceExtremeFilterLevel,
|
|
def: IndicatorPeriodDef,
|
|
): LogicNode {
|
|
if (!isPriceExtremeBreakoutPairRoot(node) || !node.priceExtremePair) return node;
|
|
const { mode, shortPeriod, longPeriod } = node.priceExtremePair;
|
|
const rebuilt = mode === 'buy'
|
|
? buildNewHigh920BuyTree(def, shortPeriod, longPeriod, filterLevel)
|
|
: buildNewLow920SellTree(def, shortPeriod, longPeriod, filterLevel);
|
|
return { ...rebuilt, id: node.id };
|
|
}
|
|
|
|
function nodeContainsId(node: LogicNode, targetId: string): boolean {
|
|
if (node.id === targetId) return true;
|
|
return (node.children ?? []).some(c => nodeContainsId(c, targetId));
|
|
}
|
|
|
|
export function findPriceExtremePairRootContaining(
|
|
node: LogicNode | null | undefined,
|
|
targetId: string,
|
|
): LogicNode | null {
|
|
if (!node) return null;
|
|
if (isPriceExtremeBreakoutPairRoot(node) && nodeContainsId(node, targetId)) return node;
|
|
for (const child of node.children ?? []) {
|
|
const hit = findPriceExtremePairRootContaining(child, targetId);
|
|
if (hit) return hit;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
export function findPriceExtremePairRootInForest(
|
|
roots: (LogicNode | null | undefined)[],
|
|
targetId: string,
|
|
): LogicNode | null {
|
|
for (const root of roots) {
|
|
const hit = findPriceExtremePairRootContaining(root, targetId);
|
|
if (hit) return hit;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
export function patchPriceExtremePairInTree(
|
|
root: LogicNode | null,
|
|
andNodeId: string,
|
|
filterLevel: PriceExtremeFilterLevel,
|
|
def: IndicatorPeriodDef,
|
|
): LogicNode | null {
|
|
if (!root) return null;
|
|
if (root.id === andNodeId && isPriceExtremeBreakoutPairRoot(root)) {
|
|
return setPriceExtremePairFilterLevel(root, filterLevel, def);
|
|
}
|
|
if (!root.children?.length) return root;
|
|
let changed = false;
|
|
const children = root.children.map(c => {
|
|
const patched = patchPriceExtremePairInTree(c, andNodeId, filterLevel, def);
|
|
if (patched !== c) changed = true;
|
|
return patched ?? c;
|
|
});
|
|
return changed ? { ...root, children } : root;
|
|
}
|
|
|
|
/** GTE/LTE 종가 조건 → CROSS 돌파 1봉 (과다 시그널·레거시 DSL 수리) */
|
|
export function repairPriceExtremePairEntryEdges(node: LogicNode): LogicNode {
|
|
if (!isPriceExtremeBreakoutPairRoot(node)) return node;
|
|
const mode = node.priceExtremePair!.mode;
|
|
const children = (node.children ?? []).map(child => {
|
|
if (child.type !== 'CONDITION' || !child.condition) return child;
|
|
const c = child.condition;
|
|
if (c.indicatorType !== 'NEW_HIGH' && c.indicatorType !== 'NEW_LOW') return child;
|
|
if (c.leftField === 'HIGH_PRICE' || c.leftField === 'LOW_PRICE') return child;
|
|
if (c.leftField !== 'CLOSE_PRICE') return child;
|
|
if (mode === 'buy' && c.conditionType === 'GTE') {
|
|
return { ...child, condition: { ...c, conditionType: 'CROSS_UP' } };
|
|
}
|
|
if (mode === 'sell' && c.conditionType === 'LTE') {
|
|
return { ...child, condition: { ...c, conditionType: 'CROSS_DOWN' } };
|
|
}
|
|
return child;
|
|
});
|
|
return { ...node, children };
|
|
}
|
|
|
|
function repairPriceExtremePairInTree(node: LogicNode): LogicNode {
|
|
let next = isPriceExtremeBreakoutPairRoot(node)
|
|
? repairPriceExtremePairEntryEdges(node)
|
|
: node;
|
|
if (next.children?.length) {
|
|
next = {
|
|
...next,
|
|
children: next.children.map(repairPriceExtremePairInTree),
|
|
};
|
|
}
|
|
return next;
|
|
}
|
|
|
|
/** 전략 로드 시 9·20 복합 — GTE/LTE 종가 조건을 CROSS 로 수리 */
|
|
export function repairPriceExtremePairForest(
|
|
root: LogicNode | null,
|
|
orphans: LogicNode[] = [],
|
|
): { root: LogicNode | null; orphans: LogicNode[] } {
|
|
return {
|
|
root: root ? repairPriceExtremePairInTree(root) : null,
|
|
orphans: orphans.map(repairPriceExtremePairInTree),
|
|
};
|
|
}
|