Macbook
255 lines
8.0 KiB
TypeScript
255 lines
8.0 KiB
TypeScript
import type { IndicatorConfig } from '../types';
|
|
import { enrichIndicatorConfig, getIndicatorDef } from './indicatorRegistry';
|
|
import { normalizeSmaConfig, createDefaultSmaPlotVisibility } from './smaConfig';
|
|
import { normalizeIchimokuConfig } from './ichimokuConfig';
|
|
import { buildMainIndicatorConfig } from './indicatorMainConfig';
|
|
import type { PlotDef, HLineDef } from './indicatorRegistry';
|
|
import type { IchimokuCloudColors } from './ichimokuConfig';
|
|
|
|
/** 보조지표 인스턴스 복제 (새 id, 별도 pane) */
|
|
export function cloneIndicatorConfig(src: IndicatorConfig, newId: string): IndicatorConfig {
|
|
return enrichIndicatorConfig({
|
|
...src,
|
|
id: newId,
|
|
mergedWith: undefined,
|
|
params: { ...src.params },
|
|
plots: src.plots?.map(p => ({ ...p })),
|
|
hlines: src.hlines?.map(h => ({ ...h })),
|
|
plotVisibility: src.plotVisibility ? { ...src.plotVisibility } : undefined,
|
|
timeframeVisibility: src.timeframeVisibility
|
|
? { ...src.timeframeVisibility }
|
|
: undefined,
|
|
cloudColors: src.cloudColors ? { ...src.cloudColors } : undefined,
|
|
hlinesBackground: src.hlinesBackground
|
|
? { ...src.hlinesBackground }
|
|
: undefined,
|
|
bandBackground: src.bandBackground
|
|
? { ...src.bandBackground }
|
|
: undefined,
|
|
});
|
|
}
|
|
|
|
/** sourceId 바로 아래에 동일 설정의 보조지표 복사본 추가 */
|
|
export function duplicateIndicatorInList(
|
|
sourceId: string,
|
|
prev: IndicatorConfig[],
|
|
newId: () => string,
|
|
): IndicatorConfig[] | null {
|
|
const idx = prev.findIndex(i => i.id === sourceId);
|
|
if (idx === -1) return null;
|
|
const src = prev[idx];
|
|
const def = getIndicatorDef(src.type);
|
|
if (!def || def.overlay || def.returnsMarkers) return null;
|
|
|
|
const clone = cloneIndicatorConfig(src, newId());
|
|
const next = [...prev];
|
|
next.splice(idx + 1, 0, clone);
|
|
return next;
|
|
}
|
|
|
|
/** mergedWith 체인의 루트(공유 pane 소유) 지표 id */
|
|
export function getPaneHostId(id: string, indicators: IndicatorConfig[]): string {
|
|
const seen = new Set<string>();
|
|
let cur = id;
|
|
for (;;) {
|
|
if (seen.has(cur)) return id;
|
|
seen.add(cur);
|
|
const ind = indicators.find(i => i.id === cur);
|
|
if (!ind?.mergedWith) return cur;
|
|
cur = ind.mergedWith;
|
|
}
|
|
}
|
|
|
|
/** 같은 pane 에 묶인 지표 id 목록 (배열 순서 유지) */
|
|
export function getMergedGroupIds(hostId: string, indicators: IndicatorConfig[]): string[] {
|
|
const host = getPaneHostId(hostId, indicators);
|
|
return indicators
|
|
.filter(i => getPaneHostId(i.id, indicators) === host)
|
|
.map(i => i.id);
|
|
}
|
|
|
|
/** 드롭 대상 → 실제 pane 호스트 id */
|
|
export function resolveMergeTargetId(targetId: string, indicators: IndicatorConfig[]): string {
|
|
return getPaneHostId(targetId, indicators);
|
|
}
|
|
|
|
/** reload 시 호스트 지표를 먼저 addIndicator 하도록 정렬 */
|
|
export function sortIndicatorsForPaneLoad(inds: IndicatorConfig[]): IndicatorConfig[] {
|
|
const byId = new Map(inds.map(i => [i.id, i]));
|
|
const out: IndicatorConfig[] = [];
|
|
const added = new Set<string>();
|
|
|
|
const addOne = (ind: IndicatorConfig) => {
|
|
if (added.has(ind.id)) return;
|
|
if (ind.mergedWith) {
|
|
const host = byId.get(ind.mergedWith);
|
|
if (host) addOne(host);
|
|
}
|
|
out.push(ind);
|
|
added.add(ind.id);
|
|
};
|
|
|
|
for (const ind of inds) addOne(ind);
|
|
return out;
|
|
}
|
|
|
|
/** 보조지표 그룹(병합 pane) 통째로 순서 변경 */
|
|
export function reorderIndicatorGroup(
|
|
fromId: string,
|
|
insertBeforeId: string | null,
|
|
prev: IndicatorConfig[],
|
|
): IndicatorConfig[] {
|
|
const hostId = getPaneHostId(fromId, prev);
|
|
const groupSet = new Set(getMergedGroupIds(hostId, prev));
|
|
const groupItems = prev.filter(i => groupSet.has(i.id));
|
|
const without = prev.filter(i => !groupSet.has(i.id));
|
|
|
|
if (insertBeforeId === null) {
|
|
return [...without, ...groupItems];
|
|
}
|
|
|
|
const beforeHost = getPaneHostId(insertBeforeId, prev);
|
|
const toIdx = without.findIndex(i => i.id === beforeHost);
|
|
without.splice(toIdx === -1 ? without.length : toIdx, 0, ...groupItems);
|
|
return without;
|
|
}
|
|
|
|
/** fromId 를 intoId pane 에 병합 */
|
|
export function mergeIndicators(
|
|
fromId: string,
|
|
intoId: string,
|
|
prev: IndicatorConfig[],
|
|
): IndicatorConfig[] {
|
|
const host = resolveMergeTargetId(intoId, prev);
|
|
if (fromId === host) return prev;
|
|
if (getPaneHostId(fromId, prev) === host) return prev;
|
|
return prev.map(i => (i.id === fromId ? { ...i, mergedWith: host } : i));
|
|
}
|
|
|
|
/** 병합 pane 분리 — 호스트 그룹의 mergedWith 제거 */
|
|
export function splitIndicatorPane(
|
|
hostOrMemberId: string,
|
|
prev: IndicatorConfig[],
|
|
): IndicatorConfig[] {
|
|
const host = getPaneHostId(hostOrMemberId, prev);
|
|
return prev.map(i => {
|
|
if (getPaneHostId(i.id, prev) !== host || !i.mergedWith) return i;
|
|
const { mergedWith: _m, ...rest } = i;
|
|
return rest;
|
|
});
|
|
}
|
|
|
|
export function layoutKey(inds: IndicatorConfig[]): string {
|
|
return inds.map(i => `${i.id}>${i.mergedWith ?? ''}`).join(';');
|
|
}
|
|
|
|
type ParamRecord = Record<string, number | string | boolean>;
|
|
type GetParams = (type: string, defaults?: ParamRecord) => ParamRecord;
|
|
type GetVisual = (
|
|
type: string,
|
|
defaultPlots?: PlotDef[],
|
|
defaultHlines?: HLineDef[],
|
|
) => {
|
|
plots: PlotDef[];
|
|
hlines: HLineDef[];
|
|
cloudColors?: IchimokuCloudColors;
|
|
bandBackground?: import('../types').HlinesBackground;
|
|
};
|
|
|
|
/** 탭 전체 추가 — 기존 차트 지표를 제거하고 types 목록만 새로 구성 */
|
|
export function replaceIndicatorConfigsFromTypes(
|
|
types: string[],
|
|
getParams: GetParams,
|
|
getVisualConfig: GetVisual,
|
|
newId: () => string,
|
|
): IndicatorConfig[] {
|
|
return buildIndicatorConfigsFromTypes(types, [], getParams, getVisualConfig, newId);
|
|
}
|
|
|
|
/** DB 보조지표 설정(파라미터·색상·선굵기·유형)을 반영한 단일 IndicatorConfig */
|
|
export function buildChartIndicatorConfig(
|
|
type: string,
|
|
id: string,
|
|
getParams: GetParams,
|
|
getVisualConfig: GetVisual,
|
|
extras: Partial<IndicatorConfig> = {},
|
|
): IndicatorConfig | null {
|
|
const def = getIndicatorDef(type);
|
|
if (!def) return null;
|
|
|
|
const params = getParams(type, def.defaultParams as ParamRecord);
|
|
const { plots, hlines, cloudColors, bandBackground } = getVisualConfig(
|
|
type,
|
|
def.plots,
|
|
def.hlines ?? [],
|
|
);
|
|
|
|
let cfg: IndicatorConfig = {
|
|
id,
|
|
type: def.type,
|
|
params,
|
|
plots,
|
|
hlines,
|
|
...(cloudColors ? { cloudColors } : {}),
|
|
...(bandBackground ? { bandBackground } : {}),
|
|
...extras,
|
|
};
|
|
|
|
if (type === 'SMA') {
|
|
const mainSma = buildMainIndicatorConfig(type, [], getParams, getVisualConfig);
|
|
if (mainSma?.plotVisibility) {
|
|
cfg.plotVisibility = mainSma.plotVisibility;
|
|
}
|
|
if (mainSma?.plots?.length) {
|
|
cfg.plots = mainSma.plots;
|
|
}
|
|
cfg = normalizeSmaConfig({
|
|
...cfg,
|
|
plotVisibility: cfg.plotVisibility ?? createDefaultSmaPlotVisibility(),
|
|
});
|
|
} else if (type === 'IchimokuCloud') {
|
|
cfg = normalizeIchimokuConfig(cfg);
|
|
}
|
|
|
|
return enrichIndicatorConfig(cfg);
|
|
}
|
|
|
|
/** 지표 타입 목록 → 차트에 추가할 IndicatorConfig 배열 (이미 활성인 type 제외) */
|
|
export function buildIndicatorConfigsFromTypes(
|
|
types: string[],
|
|
existing: IndicatorConfig[],
|
|
getParams: GetParams,
|
|
getVisualConfig: GetVisual,
|
|
newId: () => string,
|
|
): IndicatorConfig[] {
|
|
const seen = new Set(existing.map(i => i.type));
|
|
const out: IndicatorConfig[] = [];
|
|
|
|
for (const type of types) {
|
|
if (seen.has(type)) continue;
|
|
seen.add(type);
|
|
const cfg = buildChartIndicatorConfig(type, newId(), getParams, getVisualConfig);
|
|
if (cfg) out.push(cfg);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
/** id 제거 — 병합 호스트 제거 시 해당 pane 멤버도 함께 제거 */
|
|
export function removeIndicatorFromList(
|
|
prev: IndicatorConfig[],
|
|
id: string,
|
|
): IndicatorConfig[] {
|
|
return prev.filter(i => i.id !== id && i.mergedWith !== id);
|
|
}
|
|
|
|
/** type 제거 — 해당 type 인스턴스 및 병합 멤버 함께 제거 */
|
|
export function removeIndicatorTypeFromList(
|
|
prev: IndicatorConfig[],
|
|
type: string,
|
|
): IndicatorConfig[] {
|
|
const removedIds = new Set(prev.filter(i => i.type === type).map(i => i.id));
|
|
return prev.filter(
|
|
i => i.type !== type && (!i.mergedWith || !removedIds.has(i.mergedWith)),
|
|
);
|
|
}
|