dekun
1937 lines
58 KiB
JavaScript
1937 lines
58 KiB
JavaScript
/**
|
||
* 中控行情区：K 线 + 成交量；Hub 后台轮询 + SSE 推送；价格轴「自动」。
|
||
*/
|
||
(function () {
|
||
const AUTO_REFRESH_MS = 5000;
|
||
const CHART_WATCH_HEARTBEAT_MS = 25000;
|
||
const CHART_SSE_FALLBACK_MS = 30000;
|
||
const DEFAULT_VISIBLE_BARS = 200;
|
||
const RIGHT_OFFSET_BARS = 10;
|
||
const CANDLE_SCALE_BOTTOM = 0.26;
|
||
const VOLUME_SCALE_TOP = 0.73;
|
||
const VOLUME_SCALE_BOTTOM = 0.06;
|
||
const PANEL_VOL_H = 0.12;
|
||
const PANEL_MACD_H = 0.14;
|
||
const PANEL_RSI_H = 0.14;
|
||
const SWING_LOOKBACK = 4;
|
||
const MAX_DIV_MARKERS = 4;
|
||
const TF_MS = {
|
||
"1m": 60_000,
|
||
"5m": 5 * 60_000,
|
||
"15m": 15 * 60_000,
|
||
"1h": 60 * 60_000,
|
||
"2h": 2 * 60 * 60_000,
|
||
"4h": 4 * 60 * 60_000,
|
||
"12h": 12 * 60 * 60_000,
|
||
"1d": 24 * 60 * 60_000,
|
||
"1w": 7 * 24 * 60 * 60_000,
|
||
};
|
||
const TF_BY_MINUTES = {
|
||
"1": "1m",
|
||
"5": "5m",
|
||
"15": "15m",
|
||
"60": "1h",
|
||
"120": "2h",
|
||
"240": "4h",
|
||
"720": "12h",
|
||
"1440": "1d",
|
||
"10080": "1w",
|
||
};
|
||
const TF_MINUTE_KEYS = Object.keys(TF_BY_MINUTES).sort(function (a, b) {
|
||
return b.length - a.length;
|
||
});
|
||
const TF_CN_LABEL = {
|
||
"1m": "1分钟",
|
||
"5m": "5分钟",
|
||
"15m": "15分钟",
|
||
"1h": "1小时",
|
||
"2h": "2小时",
|
||
"4h": "4小时",
|
||
"12h": "12小时",
|
||
"1d": "日线",
|
||
"1w": "周线",
|
||
};
|
||
const TF_DIGIT_TIMEOUT_MS = 650;
|
||
const chartHost = document.getElementById("market-chart");
|
||
if (!chartHost) return;
|
||
|
||
const elExchange = document.getElementById("market-exchange");
|
||
const elSymbol = document.getElementById("market-symbol");
|
||
const elTf = document.getElementById("market-timeframe");
|
||
const elRefresh = document.getElementById("market-refresh");
|
||
const elStatus = document.getElementById("market-status");
|
||
const elUpdated = document.getElementById("market-updated");
|
||
const elBarCountdown = document.getElementById("market-bar-countdown");
|
||
const elO = document.getElementById("mkt-o");
|
||
const elH = document.getElementById("mkt-h");
|
||
const elL = document.getElementById("mkt-l");
|
||
const elC = document.getElementById("mkt-c");
|
||
const elV = document.getElementById("mkt-v");
|
||
const elAmp = document.getElementById("mkt-amp");
|
||
const elPriceTag = document.getElementById("market-price-tag");
|
||
const elPriceTagValue = document.getElementById("market-price-tag-value");
|
||
const elPriceTagTime = document.getElementById("market-price-tag-time");
|
||
const elExLabel = document.getElementById("mkt-exchange-label");
|
||
const elExBadge = document.getElementById("market-exchange-badge");
|
||
const elSymLabel = document.getElementById("mkt-symbol-label");
|
||
const elTfLabel = document.getElementById("mkt-tf-label");
|
||
const elPriceAuto = document.getElementById("market-price-auto");
|
||
const elPosPanel = document.getElementById("market-pos-panel");
|
||
const elPosSide = document.getElementById("mkt-pos-side");
|
||
const elPosEntry = document.getElementById("mkt-pos-entry");
|
||
const elPosSl = document.getElementById("mkt-pos-sl");
|
||
const elPosTp = document.getElementById("mkt-pos-tp");
|
||
const elPosSize = document.getElementById("mkt-pos-size");
|
||
const elPosOrders = document.getElementById("market-pos-orders");
|
||
const elPosClear = document.getElementById("market-pos-clear");
|
||
const elChartWrap = document.getElementById("market-chart-wrap");
|
||
const elFsBtn = document.getElementById("market-chart-fullscreen");
|
||
const elFsExit = document.getElementById("market-chart-fs-exit");
|
||
const elIndEma = document.getElementById("market-ind-ema");
|
||
const elIndMacd = document.getElementById("market-ind-macd");
|
||
const elIndRsi = document.getElementById("market-ind-rsi");
|
||
const elFsToolbar = document.getElementById("market-fs-toolbar");
|
||
const elFsExchange = document.getElementById("market-fs-exchange");
|
||
const elFsSymbol = document.getElementById("market-fs-symbol");
|
||
const elFsTf = document.getElementById("market-fs-timeframe");
|
||
const elFsLoad = document.getElementById("market-fs-load");
|
||
const elDivLegend = document.getElementById("market-div-legend");
|
||
|
||
const HUB_MARKET_POS_CTX_KEY = "hubMarketPosContext";
|
||
const EMA_FAST = 21;
|
||
const EMA_SLOW = 55;
|
||
|
||
let chartFullscreen = false;
|
||
const indicatorState = { ema: false, macd: false, rsi: false };
|
||
const indSeries = {
|
||
ema21: null,
|
||
ema55: null,
|
||
macdLine: null,
|
||
macdSignal: null,
|
||
macdHist: null,
|
||
rsi: null,
|
||
rsi30: null,
|
||
rsi70: null,
|
||
};
|
||
let divergenceMarkers = [];
|
||
|
||
let chart = null;
|
||
let candleSeries = null;
|
||
let volumeSeries = null;
|
||
let priceTick = null;
|
||
let priceAutoScale = true;
|
||
let rangeMarkers = [];
|
||
let positionLines = [];
|
||
let posContext = null;
|
||
let currentPriceLine = null;
|
||
let lastCandles = [];
|
||
let candleByTime = {};
|
||
let chartMeta = null;
|
||
let loadToken = 0;
|
||
let marketInited = false;
|
||
let refreshTimer = null;
|
||
let chartWatchTimer = null;
|
||
let chartEventSource = null;
|
||
let chartSseReconnectTimer = null;
|
||
let localChartVersion = 0;
|
||
let localSeriesVersion = 0;
|
||
let lastViewKey = "";
|
||
let currentTf = "1d";
|
||
let priceTagTimer = null;
|
||
let tfDigitBuf = "";
|
||
let tfDigitTimer = null;
|
||
let tfHintTimer = null;
|
||
|
||
function escHtml(s) {
|
||
return String(s || "")
|
||
.replace(/&/g, "&")
|
||
.replace(/</g, "<")
|
||
.replace(/>/g, ">")
|
||
.replace(/"/g, """);
|
||
}
|
||
|
||
function normalizeMarketSymbol(sym) {
|
||
const s = String(sym || "").trim().toUpperCase();
|
||
const m = s.match(/^([A-Z0-9]+)\/([A-Z0-9]+)(?::([A-Z0-9]+))?$/);
|
||
if (!m) return s;
|
||
return m[1] + "/" + m[2];
|
||
}
|
||
|
||
function loadPosContextFromStorage() {
|
||
try {
|
||
const raw = sessionStorage.getItem(HUB_MARKET_POS_CTX_KEY);
|
||
if (!raw) return null;
|
||
return JSON.parse(raw);
|
||
} catch (e) {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
function posContextMatches(ctx, exKey, sym) {
|
||
if (!ctx) return false;
|
||
const ctxSym = normalizeMarketSymbol(ctx.symbol || "");
|
||
const ctxEx = String(ctx.exchange_key || "").trim();
|
||
return ctxSym === normalizeMarketSymbol(sym) && ctxEx === String(exKey || "").trim();
|
||
}
|
||
|
||
function clearPosPanel() {
|
||
if (elPosPanel) elPosPanel.classList.add("hidden");
|
||
if (elPosSide) {
|
||
elPosSide.textContent = "";
|
||
elPosSide.className = "market-pos-side";
|
||
}
|
||
["entry", "sl", "tp", "size"].forEach(function (k) {
|
||
const el = { entry: elPosEntry, sl: elPosSl, tp: elPosTp, size: elPosSize }[k];
|
||
if (el) el.textContent = "—";
|
||
});
|
||
if (elPosOrders) elPosOrders.innerHTML = "";
|
||
syncChartWrapLayout();
|
||
}
|
||
|
||
function resizeChart() {
|
||
if (!chart || !chartHost) return;
|
||
chart.applyOptions({ width: chartHost.clientWidth, height: chartHost.clientHeight });
|
||
updatePriceTag();
|
||
}
|
||
|
||
let resizeChartRaf = 0;
|
||
function scheduleChartResize() {
|
||
if (resizeChartRaf) cancelAnimationFrame(resizeChartRaf);
|
||
resizeChartRaf = requestAnimationFrame(function () {
|
||
resizeChartRaf = 0;
|
||
syncChartWrapLayout();
|
||
});
|
||
}
|
||
|
||
function syncChartWrapLayout() {
|
||
const wrap = elChartWrap || (chartHost && chartHost.closest(".market-chart-wrap"));
|
||
if (wrap && elPosPanel && !chartFullscreen) {
|
||
wrap.classList.toggle("has-pos-panel", !elPosPanel.classList.contains("hidden"));
|
||
}
|
||
resizeChart();
|
||
}
|
||
|
||
function readIndicatorState() {
|
||
indicatorState.ema = !!(elIndEma && elIndEma.checked);
|
||
indicatorState.macd = !!(elIndMacd && elIndMacd.checked);
|
||
indicatorState.rsi = !!(elIndRsi && elIndRsi.checked);
|
||
}
|
||
|
||
function emaArray(values, period) {
|
||
const result = new Array(values.length).fill(null);
|
||
const k = 2 / (period + 1);
|
||
let ema = null;
|
||
for (let i = 0; i < values.length; i++) {
|
||
const v = values[i];
|
||
if (v == null || !Number.isFinite(v)) continue;
|
||
if (ema == null) {
|
||
if (i < period - 1) continue;
|
||
let sum = 0;
|
||
let ok = true;
|
||
for (let j = i - period + 1; j <= i; j++) {
|
||
const x = values[j];
|
||
if (x == null || !Number.isFinite(x)) {
|
||
ok = false;
|
||
break;
|
||
}
|
||
sum += x;
|
||
}
|
||
if (!ok) continue;
|
||
ema = sum / period;
|
||
} else {
|
||
ema = v * k + ema * (1 - k);
|
||
}
|
||
result[i] = ema;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
function buildEmaSeries(candles, period) {
|
||
const closes = candles.map(function (c) {
|
||
return Number(c.close);
|
||
});
|
||
const vals = emaArray(closes, period);
|
||
const out = [];
|
||
for (let i = 0; i < candles.length; i++) {
|
||
if (vals[i] == null) continue;
|
||
out.push({ time: candles[i].time, value: vals[i] });
|
||
}
|
||
return out;
|
||
}
|
||
|
||
function buildMacdData(candles) {
|
||
const closes = candles.map(function (c) {
|
||
return Number(c.close);
|
||
});
|
||
const ema12 = emaArray(closes, 12);
|
||
const ema26 = emaArray(closes, 26);
|
||
const macd = new Array(closes.length).fill(null);
|
||
for (let i = 0; i < closes.length; i++) {
|
||
if (ema12[i] == null || ema26[i] == null) continue;
|
||
macd[i] = ema12[i] - ema26[i];
|
||
}
|
||
const signal = emaArray(macd, 9);
|
||
const macdLine = [];
|
||
const signalLine = [];
|
||
const histData = [];
|
||
for (let i = 0; i < candles.length; i++) {
|
||
const t = candles[i].time;
|
||
if (macd[i] != null) macdLine.push({ time: t, value: macd[i] });
|
||
if (signal[i] != null) signalLine.push({ time: t, value: signal[i] });
|
||
if (macd[i] != null && signal[i] != null) {
|
||
const h = macd[i] - signal[i];
|
||
histData.push({
|
||
time: t,
|
||
value: h,
|
||
color: h >= 0 ? "rgba(0, 255, 157, 0.55)" : "rgba(255, 77, 109, 0.55)",
|
||
});
|
||
}
|
||
}
|
||
return { macdLine, signalLine, histData };
|
||
}
|
||
|
||
function buildRsiSeries(candles, period) {
|
||
const out = [];
|
||
if (!candles || candles.length < period + 1) return out;
|
||
let avgGain = 0;
|
||
let avgLoss = 0;
|
||
for (let i = 1; i <= period; i++) {
|
||
const ch = Number(candles[i].close) - Number(candles[i - 1].close);
|
||
if (ch >= 0) avgGain += ch;
|
||
else avgLoss -= ch;
|
||
}
|
||
avgGain /= period;
|
||
avgLoss /= period;
|
||
let rsi = 50;
|
||
if (avgLoss <= 0) rsi = 100;
|
||
else if (avgGain <= 0) rsi = 0;
|
||
else rsi = 100 - 100 / (1 + avgGain / avgLoss);
|
||
out.push({ time: candles[period].time, value: rsi });
|
||
|
||
for (let i = period + 1; i < candles.length; i++) {
|
||
const ch = Number(candles[i].close) - Number(candles[i - 1].close);
|
||
const gain = ch > 0 ? ch : 0;
|
||
const loss = ch < 0 ? -ch : 0;
|
||
avgGain = (avgGain * (period - 1) + gain) / period;
|
||
avgLoss = (avgLoss * (period - 1) + loss) / period;
|
||
if (avgLoss <= 0) rsi = 100;
|
||
else if (avgGain <= 0) rsi = 0;
|
||
else rsi = 100 - 100 / (1 + avgGain / avgLoss);
|
||
out.push({ time: candles[i].time, value: rsi });
|
||
}
|
||
return out;
|
||
}
|
||
|
||
function createLineSeries(opts) {
|
||
if (!chart) return null;
|
||
const base = {
|
||
lineWidth: 1,
|
||
priceLineVisible: false,
|
||
lastValueVisible: false,
|
||
};
|
||
const o = Object.assign(base, opts || {});
|
||
if (typeof chart.addLineSeries === "function") return chart.addLineSeries(o);
|
||
if (
|
||
typeof chart.addSeries === "function" &&
|
||
window.LightweightCharts &&
|
||
window.LightweightCharts.LineSeries
|
||
) {
|
||
return chart.addSeries(window.LightweightCharts.LineSeries, o);
|
||
}
|
||
return null;
|
||
}
|
||
|
||
function createHistSeries(opts) {
|
||
if (!chart) return null;
|
||
const base = { priceLineVisible: false, lastValueVisible: false };
|
||
const o = Object.assign(base, opts || {});
|
||
if (typeof chart.addHistogramSeries === "function") return chart.addHistogramSeries(o);
|
||
if (
|
||
typeof chart.addSeries === "function" &&
|
||
window.LightweightCharts &&
|
||
window.LightweightCharts.HistogramSeries
|
||
) {
|
||
return chart.addSeries(window.LightweightCharts.HistogramSeries, o);
|
||
}
|
||
return null;
|
||
}
|
||
|
||
function clearIndicatorSeries() {
|
||
if (!chart) return;
|
||
[indSeries.rsi30, indSeries.rsi70].forEach(function (pl) {
|
||
if (pl && indSeries.rsi) {
|
||
try {
|
||
indSeries.rsi.removePriceLine(pl);
|
||
} catch (e) {}
|
||
}
|
||
});
|
||
indSeries.rsi30 = null;
|
||
indSeries.rsi70 = null;
|
||
Object.keys(indSeries).forEach(function (k) {
|
||
if (k === "rsi30" || k === "rsi70") return;
|
||
if (indSeries[k]) {
|
||
try {
|
||
chart.removeSeries(indSeries[k]);
|
||
} catch (e) {}
|
||
indSeries[k] = null;
|
||
}
|
||
});
|
||
}
|
||
|
||
function findSwings(values, lookback) {
|
||
const lows = [];
|
||
const highs = [];
|
||
const lb = lookback || SWING_LOOKBACK;
|
||
for (let i = lb; i < values.length - lb; i++) {
|
||
const v = values[i];
|
||
if (v == null || !Number.isFinite(v)) continue;
|
||
let isLow = true;
|
||
let isHigh = true;
|
||
for (let j = 1; j <= lb; j++) {
|
||
const lv = values[i - j];
|
||
const rv = values[i + j];
|
||
if (lv == null || rv == null || v > lv || v > rv) isLow = false;
|
||
if (lv == null || rv == null || v < lv || v < rv) isHigh = false;
|
||
}
|
||
if (isLow) lows.push({ i: i, v: v });
|
||
if (isHigh) highs.push({ i: i, v: v });
|
||
}
|
||
return { lows, highs };
|
||
}
|
||
|
||
function detectDivergences(candles, indicatorByIndex, sourceLabel) {
|
||
const markers = [];
|
||
if (!candles.length || !indicatorByIndex.length) return markers;
|
||
|
||
const closes = candles.map(function (c) {
|
||
return Number(c.close);
|
||
});
|
||
const priceSw = findSwings(closes, SWING_LOOKBACK);
|
||
const indSw = findSwings(indicatorByIndex, SWING_LOOKBACK);
|
||
|
||
function pushMarker(idx, kind, label) {
|
||
const c = candles[idx];
|
||
if (!c || c.time == null) return;
|
||
const bull = kind === "bull";
|
||
markers.push({
|
||
time: c.time,
|
||
position: bull ? "belowBar" : "aboveBar",
|
||
color: bull ? "#00ff9d" : "#ff4d6d",
|
||
shape: bull ? "arrowUp" : "arrowDown",
|
||
text: label,
|
||
});
|
||
}
|
||
|
||
const pLows = priceSw.lows;
|
||
const iLows = indSw.lows;
|
||
if (pLows.length >= 2 && iLows.length >= 2) {
|
||
const p1 = pLows[pLows.length - 2];
|
||
const p2 = pLows[pLows.length - 1];
|
||
const i1 = iLows[iLows.length - 2];
|
||
const i2 = iLows[iLows.length - 1];
|
||
if (Math.abs(p1.i - i1.i) < 30 && Math.abs(p2.i - i2.i) < 30) {
|
||
if (p2.v < p1.v && i2.v > i1.v) {
|
||
pushMarker(p2.i, "bull", sourceLabel + "底背离");
|
||
}
|
||
}
|
||
}
|
||
|
||
const pHighs = priceSw.highs;
|
||
const iHighs = indSw.highs;
|
||
if (pHighs.length >= 2 && iHighs.length >= 2) {
|
||
const p1 = pHighs[pHighs.length - 2];
|
||
const p2 = pHighs[pHighs.length - 1];
|
||
const i1 = iHighs[iHighs.length - 2];
|
||
const i2 = iHighs[iHighs.length - 1];
|
||
if (Math.abs(p1.i - i1.i) < 30 && Math.abs(p2.i - i2.i) < 30) {
|
||
if (p2.v > p1.v && i2.v < i1.v) {
|
||
pushMarker(p2.i, "bear", sourceLabel + "顶背离");
|
||
}
|
||
}
|
||
}
|
||
|
||
return markers.slice(-MAX_DIV_MARKERS);
|
||
}
|
||
|
||
function buildRsiByIndex(candles, period) {
|
||
const series = buildRsiSeries(candles, period);
|
||
const byIdx = new Array(candles.length).fill(null);
|
||
let si = 0;
|
||
for (let i = 0; i < candles.length; i++) {
|
||
if (si < series.length && series[si].time === candles[i].time) {
|
||
byIdx[i] = series[si].value;
|
||
si++;
|
||
}
|
||
}
|
||
return { series, byIdx };
|
||
}
|
||
|
||
function buildMacdByIndex(candles) {
|
||
const closes = candles.map(function (c) {
|
||
return Number(c.close);
|
||
});
|
||
const ema12 = emaArray(closes, 12);
|
||
const ema26 = emaArray(closes, 26);
|
||
const macd = new Array(closes.length).fill(null);
|
||
for (let i = 0; i < closes.length; i++) {
|
||
if (ema12[i] == null || ema26[i] == null) continue;
|
||
macd[i] = ema12[i] - ema26[i];
|
||
}
|
||
return macd;
|
||
}
|
||
|
||
function panelLayout() {
|
||
const rsiOn = indicatorState.rsi;
|
||
const macdOn = indicatorState.macd;
|
||
if (!rsiOn && !macdOn) {
|
||
return {
|
||
candle: { top: 0.06, bottom: CANDLE_SCALE_BOTTOM },
|
||
volume: { top: VOLUME_SCALE_TOP, bottom: VOLUME_SCALE_BOTTOM },
|
||
macd: null,
|
||
rsi: null,
|
||
};
|
||
}
|
||
|
||
const gap = 0.02;
|
||
let stackBottom = gap;
|
||
let rsiMargins = null;
|
||
let macdMargins = null;
|
||
|
||
if (rsiOn) {
|
||
rsiMargins = {
|
||
top: 1 - stackBottom - PANEL_RSI_H,
|
||
bottom: stackBottom,
|
||
};
|
||
stackBottom += PANEL_RSI_H;
|
||
}
|
||
if (macdOn) {
|
||
macdMargins = {
|
||
top: 1 - stackBottom - PANEL_MACD_H,
|
||
bottom: stackBottom,
|
||
};
|
||
stackBottom += PANEL_MACD_H;
|
||
}
|
||
|
||
const volBottom = stackBottom;
|
||
const volTop = 1 - volBottom - PANEL_VOL_H;
|
||
const candleBottom = Math.max(CANDLE_SCALE_BOTTOM, 1 - volTop + 0.01);
|
||
|
||
return {
|
||
candle: { top: 0.06, bottom: candleBottom },
|
||
volume: { top: volTop, bottom: volBottom },
|
||
macd: macdMargins,
|
||
rsi: rsiMargins,
|
||
};
|
||
}
|
||
|
||
function applyScaleLayout() {
|
||
if (!chart) return;
|
||
const L = panelLayout();
|
||
chart.priceScale("right").applyOptions({
|
||
scaleMargins: L.candle,
|
||
});
|
||
if (volumeSeries && volumeSeries.priceScale) {
|
||
volumeSeries.priceScale().applyOptions({
|
||
scaleMargins: L.volume,
|
||
borderColor: "#2a4058",
|
||
});
|
||
}
|
||
if (indSeries.macdLine && indSeries.macdLine.priceScale) {
|
||
indSeries.macdLine.priceScale().applyOptions({
|
||
scaleMargins: L.macd,
|
||
borderColor: "#2a4058",
|
||
autoScale: true,
|
||
});
|
||
}
|
||
if (indSeries.rsi && indSeries.rsi.priceScale) {
|
||
indSeries.rsi.priceScale().applyOptions({
|
||
scaleMargins: L.rsi,
|
||
borderColor: "#2a4058",
|
||
autoScale: true,
|
||
});
|
||
}
|
||
}
|
||
|
||
function updateDivergenceLegend(rsiDiv, macdDiv) {
|
||
if (!elDivLegend) return;
|
||
const parts = [];
|
||
if (indicatorState.rsi && rsiDiv.length) {
|
||
parts.push("RSI " + rsiDiv.map(function (m) { return m.text; }).join(" · "));
|
||
}
|
||
if (indicatorState.macd && macdDiv.length) {
|
||
parts.push("MACD " + macdDiv.map(function (m) { return m.text; }).join(" · "));
|
||
}
|
||
if (!parts.length) {
|
||
elDivLegend.textContent = "";
|
||
elDivLegend.classList.add("hidden");
|
||
return;
|
||
}
|
||
elDivLegend.textContent = parts.join(" ｜ ");
|
||
elDivLegend.classList.remove("hidden");
|
||
}
|
||
|
||
function applyCandleDivergenceMarkers() {
|
||
if (!candleSeries || !candleSeries.setMarkers) return;
|
||
const sorted = divergenceMarkers
|
||
.slice()
|
||
.sort(function (a, b) {
|
||
return a.time > b.time ? 1 : a.time < b.time ? -1 : 0;
|
||
});
|
||
candleSeries.setMarkers(sorted);
|
||
}
|
||
|
||
function updateIndicators() {
|
||
if (!chart || !lastCandles.length) return;
|
||
readIndicatorState();
|
||
clearIndicatorSeries();
|
||
divergenceMarkers = [];
|
||
|
||
if (indicatorState.ema) {
|
||
const pf = tickToPriceFormat(priceTick);
|
||
indSeries.ema21 = createLineSeries({
|
||
color: "#f0c040",
|
||
title: "EMA21",
|
||
priceScaleId: "right",
|
||
priceFormat: pf,
|
||
});
|
||
indSeries.ema55 = createLineSeries({
|
||
color: "#c878ff",
|
||
title: "EMA55",
|
||
priceScaleId: "right",
|
||
priceFormat: pf,
|
||
});
|
||
if (indSeries.ema21) indSeries.ema21.setData(buildEmaSeries(lastCandles, EMA_FAST));
|
||
if (indSeries.ema55) indSeries.ema55.setData(buildEmaSeries(lastCandles, EMA_SLOW));
|
||
}
|
||
|
||
let rsiDiv = [];
|
||
let macdDiv = [];
|
||
|
||
if (indicatorState.macd) {
|
||
const macd = buildMacdData(lastCandles);
|
||
const macdByIdx = buildMacdByIndex(lastCandles);
|
||
indSeries.macdLine = createLineSeries({
|
||
color: "#5b9cf5",
|
||
title: "MACD",
|
||
priceScaleId: "macd",
|
||
priceLineVisible: false,
|
||
lastValueVisible: false,
|
||
});
|
||
indSeries.macdSignal = createLineSeries({
|
||
color: "#ffb84d",
|
||
title: "Signal",
|
||
priceScaleId: "macd",
|
||
priceLineVisible: false,
|
||
lastValueVisible: false,
|
||
});
|
||
indSeries.macdHist = createHistSeries({
|
||
priceScaleId: "macd",
|
||
priceLineVisible: false,
|
||
lastValueVisible: false,
|
||
});
|
||
if (indSeries.macdLine) indSeries.macdLine.setData(macd.macdLine);
|
||
if (indSeries.macdSignal) indSeries.macdSignal.setData(macd.signalLine);
|
||
if (indSeries.macdHist) indSeries.macdHist.setData(macd.histData);
|
||
macdDiv = detectDivergences(lastCandles, macdByIdx, "MACD");
|
||
divergenceMarkers = divergenceMarkers.concat(macdDiv);
|
||
}
|
||
|
||
if (indicatorState.rsi) {
|
||
const rsiPack = buildRsiByIndex(lastCandles, 14);
|
||
indSeries.rsi = createLineSeries({
|
||
color: "#8fc8ff",
|
||
title: "RSI(14)",
|
||
priceScaleId: "rsi",
|
||
priceFormat: { type: "price", precision: 1, minMove: 0.1 },
|
||
priceLineVisible: false,
|
||
lastValueVisible: true,
|
||
});
|
||
if (indSeries.rsi) {
|
||
indSeries.rsi.setData(rsiPack.series);
|
||
try {
|
||
indSeries.rsi30 = indSeries.rsi.createPriceLine({
|
||
price: 30,
|
||
color: "rgba(255, 77, 109, 0.75)",
|
||
lineWidth: 1,
|
||
lineStyle: 2,
|
||
axisLabelVisible: true,
|
||
title: "30",
|
||
});
|
||
indSeries.rsi70 = indSeries.rsi.createPriceLine({
|
||
price: 70,
|
||
color: "rgba(0, 255, 157, 0.75)",
|
||
lineWidth: 1,
|
||
lineStyle: 2,
|
||
axisLabelVisible: true,
|
||
title: "70",
|
||
});
|
||
} catch (e) {}
|
||
}
|
||
rsiDiv = detectDivergences(lastCandles, rsiPack.byIdx, "RSI");
|
||
divergenceMarkers = divergenceMarkers.concat(rsiDiv);
|
||
}
|
||
|
||
updateDivergenceLegend(rsiDiv, macdDiv);
|
||
applyCandleDivergenceMarkers();
|
||
applyScaleLayout();
|
||
scheduleChartResize();
|
||
}
|
||
|
||
function syncFsToolbarFromMain() {
|
||
if (!chartFullscreen) return;
|
||
if (elFsExchange && elExchange) elFsExchange.value = elExchange.value;
|
||
if (elFsSymbol && elSymbol) elFsSymbol.value = elSymbol.value;
|
||
if (elFsTf && elTf) elFsTf.value = elTf.value;
|
||
}
|
||
|
||
function syncMainFromFsToolbar() {
|
||
if (elExchange && elFsExchange) elExchange.value = elFsExchange.value;
|
||
if (elSymbol && elFsSymbol) elSymbol.value = elFsSymbol.value.trim().toUpperCase();
|
||
if (elTf && elFsTf) elTf.value = elFsTf.value;
|
||
updateExchangeDisplay();
|
||
updateHeaderLabels(elSymbol && elSymbol.value, elTf && elTf.value);
|
||
}
|
||
|
||
function isMarketPageActive() {
|
||
const page = document.getElementById("page-market");
|
||
return !!(page && !page.classList.contains("hidden"));
|
||
}
|
||
|
||
function isTypingInField(target) {
|
||
if (!target) return false;
|
||
const tag = (target.tagName || "").toLowerCase();
|
||
if (tag === "input" || tag === "textarea" || tag === "select") return true;
|
||
return !!target.isContentEditable;
|
||
}
|
||
|
||
function canUseTfKeyboard(e) {
|
||
if (!isMarketPageActive()) return false;
|
||
if (e.altKey || e.ctrlKey || e.metaKey) return false;
|
||
if (isTypingInField(e.target)) return false;
|
||
return true;
|
||
}
|
||
|
||
function canExtendTfDigitBuffer(buf) {
|
||
if (!buf) return false;
|
||
return TF_MINUTE_KEYS.some(function (k) {
|
||
return k.length > buf.length && k.indexOf(buf) === 0;
|
||
});
|
||
}
|
||
|
||
function shouldCommitTfBufferNow(buf) {
|
||
const tf = resolveTfFromDigitBuffer(buf);
|
||
if (!tf) return false;
|
||
return !canExtendTfDigitBuffer(buf);
|
||
}
|
||
|
||
function resolveTfFromDigitBuffer(buf) {
|
||
if (!buf) return null;
|
||
return TF_BY_MINUTES[buf] || null;
|
||
}
|
||
|
||
function flashTfSwitchHint(tf) {
|
||
const label = TF_CN_LABEL[tf] || tf;
|
||
const text = "周期 → " + label + "（" + tf + "）";
|
||
if (elTfLabel) elTfLabel.textContent = tf;
|
||
if (elBarCountdown) {
|
||
if (tfHintTimer) clearTimeout(tfHintTimer);
|
||
elBarCountdown.textContent = text;
|
||
elBarCountdown.classList.add("market-tf-key-hint");
|
||
tfHintTimer = setTimeout(function () {
|
||
tfHintTimer = null;
|
||
elBarCountdown.classList.remove("market-tf-key-hint");
|
||
tickLiveClock();
|
||
}, 1200);
|
||
return;
|
||
}
|
||
if (elStatus) {
|
||
if (tfHintTimer) clearTimeout(tfHintTimer);
|
||
const prevClass = elStatus.className;
|
||
const prevText = elStatus.textContent;
|
||
elStatus.className = "market-status";
|
||
elStatus.textContent = text;
|
||
tfHintTimer = setTimeout(function () {
|
||
tfHintTimer = null;
|
||
elStatus.className = prevClass;
|
||
elStatus.textContent = prevText;
|
||
}, 1200);
|
||
}
|
||
}
|
||
|
||
function applyTimeframe(tf, fromKeyboard) {
|
||
if (!tf || !TF_MS[tf]) return false;
|
||
const cur = (elTf && elTf.value) || currentTf;
|
||
if (cur === tf) return false;
|
||
if (elTf) elTf.value = tf;
|
||
if (elFsTf) elFsTf.value = tf;
|
||
currentTf = tf;
|
||
tickLiveClock();
|
||
updateHeaderLabels(
|
||
elSymbol && elSymbol.value.trim().toUpperCase(),
|
||
tf
|
||
);
|
||
syncFsToolbarFromMain();
|
||
if (fromKeyboard) flashTfSwitchHint(tf);
|
||
loadChart(false);
|
||
return true;
|
||
}
|
||
|
||
function commitTfDigitBuffer() {
|
||
const buf = tfDigitBuf;
|
||
tfDigitBuf = "";
|
||
if (tfDigitTimer) {
|
||
clearTimeout(tfDigitTimer);
|
||
tfDigitTimer = null;
|
||
}
|
||
const tf = resolveTfFromDigitBuffer(buf);
|
||
if (tf) applyTimeframe(tf, true);
|
||
}
|
||
|
||
function handleTfDigitKey(digit) {
|
||
if (!digit) return;
|
||
if (tfDigitBuf && !canExtendTfDigitBuffer(tfDigitBuf)) {
|
||
tfDigitBuf = "";
|
||
}
|
||
tfDigitBuf += digit;
|
||
if (shouldCommitTfBufferNow(tfDigitBuf)) {
|
||
commitTfDigitBuffer();
|
||
return;
|
||
}
|
||
if (!canExtendTfDigitBuffer(tfDigitBuf)) {
|
||
tfDigitBuf = digit;
|
||
if (shouldCommitTfBufferNow(tfDigitBuf)) {
|
||
commitTfDigitBuffer();
|
||
return;
|
||
}
|
||
}
|
||
if (tfDigitTimer) clearTimeout(tfDigitTimer);
|
||
tfDigitTimer = setTimeout(commitTfDigitBuffer, TF_DIGIT_TIMEOUT_MS);
|
||
}
|
||
|
||
function isChartFullscreenKey(e) {
|
||
if (e.ctrlKey || e.altKey || e.metaKey || e.shiftKey) return false;
|
||
return e.code === "KeyF" || e.key === "f" || e.key === "F";
|
||
}
|
||
|
||
function onChartFullscreenKey(e) {
|
||
if (!isMarketPageActive() || !isChartFullscreenKey(e)) return;
|
||
if (isTypingInField(e.target)) return;
|
||
e.preventDefault();
|
||
e.stopImmediatePropagation();
|
||
toggleChartFullscreen();
|
||
}
|
||
|
||
function focusMarketChartArea() {
|
||
const wrap = elChartWrap;
|
||
if (!wrap) return;
|
||
if (!wrap.hasAttribute("tabindex")) wrap.setAttribute("tabindex", "-1");
|
||
try {
|
||
wrap.focus({ preventScroll: true });
|
||
} catch (err) {
|
||
/* ignore */
|
||
}
|
||
}
|
||
|
||
function onMarketKeydown(e) {
|
||
if (!isMarketPageActive()) return;
|
||
|
||
if (e.key === "Escape" && chartFullscreen) {
|
||
e.preventDefault();
|
||
e.stopPropagation();
|
||
setChartFullscreen(false);
|
||
return;
|
||
}
|
||
|
||
if (!canUseTfKeyboard(e)) return;
|
||
if (e.key >= "0" && e.key <= "9") {
|
||
e.preventDefault();
|
||
handleTfDigitKey(e.key);
|
||
return;
|
||
}
|
||
if (e.key === "Enter" && tfDigitBuf) {
|
||
e.preventDefault();
|
||
commitTfDigitBuffer();
|
||
}
|
||
}
|
||
|
||
function populateFsExchangeOptions() {
|
||
if (!elFsExchange || !elExchange) return;
|
||
elFsExchange.innerHTML = elExchange.innerHTML;
|
||
elFsExchange.value = elExchange.value;
|
||
}
|
||
|
||
function setChartFullscreen(on) {
|
||
chartFullscreen = !!on;
|
||
const wrap = elChartWrap || (chartHost && chartHost.closest(".market-chart-wrap"));
|
||
if (wrap) wrap.classList.toggle("is-fullscreen", chartFullscreen);
|
||
document.body.classList.toggle("market-chart-fs-open", chartFullscreen);
|
||
if (elFsToolbar) elFsToolbar.classList.toggle("hidden", !chartFullscreen);
|
||
if (elFsBtn) elFsBtn.textContent = chartFullscreen ? "退出全屏" : "全屏";
|
||
if (elFsExit) {
|
||
if (chartFullscreen) elFsExit.classList.remove("hidden");
|
||
else elFsExit.classList.add("hidden");
|
||
}
|
||
if (chartFullscreen) {
|
||
populateFsExchangeOptions();
|
||
syncFsToolbarFromMain();
|
||
}
|
||
scheduleChartResize();
|
||
}
|
||
|
||
function toggleChartFullscreen() {
|
||
setChartFullscreen(!chartFullscreen);
|
||
}
|
||
|
||
function renderPosPanel(ctx) {
|
||
if (!elPosPanel || !ctx) {
|
||
clearPosPanel();
|
||
return;
|
||
}
|
||
elPosPanel.classList.remove("hidden");
|
||
if (elPosSide) {
|
||
const isShort = (ctx.side || "").toLowerCase() === "short";
|
||
elPosSide.textContent = isShort ? "空" : "多";
|
||
elPosSide.className = "market-pos-side " + (isShort ? "side-short" : "side-long");
|
||
}
|
||
if (elPosEntry) elPosEntry.textContent = ctx.entry != null ? fmtPrice(ctx.entry) : "—";
|
||
if (elPosSl) elPosSl.textContent = ctx.stop_loss != null ? fmtPrice(ctx.stop_loss) : "—";
|
||
if (elPosTp) {
|
||
if (ctx.tp_monitored) {
|
||
elPosTp.textContent =
|
||
ctx.take_profit != null
|
||
? "程序监控 · " + fmtPrice(ctx.take_profit)
|
||
: "程序监控";
|
||
elPosTp.classList.add("market-pos-tp-monitored");
|
||
} else {
|
||
elPosTp.textContent = ctx.take_profit != null ? fmtPrice(ctx.take_profit) : "—";
|
||
elPosTp.classList.remove("market-pos-tp-monitored");
|
||
}
|
||
}
|
||
if (elPosSize) elPosSize.textContent = ctx.contracts != null ? String(ctx.contracts) : "—";
|
||
if (elPosOrders) {
|
||
const orders = Array.isArray(ctx.orders) ? ctx.orders : [];
|
||
if (!orders.length) {
|
||
elPosOrders.innerHTML = '<span class="market-pos-orders-empty">暂无委托单</span>';
|
||
} else {
|
||
elPosOrders.innerHTML = orders
|
||
.map(function (o) {
|
||
const price = o.price != null ? fmtPrice(o.price) : "—";
|
||
const amt = o.amount != null ? String(o.amount) : "";
|
||
return (
|
||
'<span class="market-pos-order">' +
|
||
'<span class="market-pos-order-kind">' +
|
||
escHtml(o.kind || "") +
|
||
"</span>" +
|
||
'<span class="market-pos-order-label">' +
|
||
escHtml(o.label || "") +
|
||
"</span>" +
|
||
'<span class="market-pos-order-price">' +
|
||
price +
|
||
"</span>" +
|
||
(amt ? '<span class="market-pos-order-amt">×' + escHtml(amt) + "</span>" : "") +
|
||
"</span>"
|
||
);
|
||
})
|
||
.join("");
|
||
}
|
||
}
|
||
scheduleChartResize();
|
||
}
|
||
|
||
function clearPositionLines() {
|
||
positionLines.forEach(function (m) {
|
||
try {
|
||
candleSeries.removePriceLine(m);
|
||
} catch (e) {}
|
||
});
|
||
positionLines = [];
|
||
}
|
||
|
||
function updatePositionLines() {
|
||
clearPositionLines();
|
||
if (!candleSeries || !posContext) return;
|
||
const specs = [
|
||
{ price: posContext.entry, color: "#5b9cf5", title: "入场" },
|
||
{ price: posContext.stop_loss, color: "#ff4d6d", title: "止损" },
|
||
];
|
||
if (posContext.take_profit != null) {
|
||
specs.push({
|
||
price: posContext.take_profit,
|
||
color: "#00ff9d",
|
||
title: posContext.tp_monitored ? "止盈(程序)" : "止盈",
|
||
});
|
||
}
|
||
specs.forEach(function (s) {
|
||
if (s.price == null || !Number.isFinite(Number(s.price))) return;
|
||
const px = roundToTick(s.price);
|
||
if (px == null || !Number.isFinite(Number(px))) return;
|
||
positionLines.push(
|
||
candleSeries.createPriceLine({
|
||
price: Number(px),
|
||
color: s.color,
|
||
lineWidth: 1,
|
||
lineStyle: 2,
|
||
axisLabelVisible: true,
|
||
title: s.title,
|
||
})
|
||
);
|
||
});
|
||
}
|
||
|
||
function clearPosContext() {
|
||
posContext = null;
|
||
try {
|
||
sessionStorage.removeItem(HUB_MARKET_POS_CTX_KEY);
|
||
} catch (e) {}
|
||
clearPosPanel();
|
||
clearPositionLines();
|
||
}
|
||
|
||
function applyPosContext(ctx) {
|
||
posContext = ctx;
|
||
renderPosPanel(ctx);
|
||
updatePositionLines();
|
||
}
|
||
|
||
function syncPosContextForView(exKey, sym) {
|
||
const stored = loadPosContextFromStorage();
|
||
if (stored && posContextMatches(stored, exKey, sym)) {
|
||
applyPosContext(stored);
|
||
return;
|
||
}
|
||
clearPosContext();
|
||
}
|
||
|
||
function fmtVol(v) {
|
||
if (v == null || Number.isNaN(Number(v))) return "-";
|
||
const n = Number(v);
|
||
if (n >= 1e9) return (n / 1e9).toFixed(2) + "B";
|
||
if (n >= 1e6) return (n / 1e6).toFixed(2) + "M";
|
||
if (n >= 1e3) return (n / 1e3).toFixed(2) + "K";
|
||
return n.toFixed(2);
|
||
}
|
||
|
||
function decimalsFromTick(tick) {
|
||
if (tick == null || !Number.isFinite(Number(tick)) || Number(tick) <= 0) return null;
|
||
const minMove = Number(tick);
|
||
if (minMove >= 1) return 0;
|
||
const raw = String(minMove);
|
||
const sci = raw.match(/e-(\d+)/i);
|
||
if (sci) return Math.min(12, parseInt(sci[1], 10));
|
||
const fixed = minMove.toFixed(12);
|
||
const frac = fixed.split(".")[1] || "";
|
||
const trimmed = frac.replace(/0+$/, "");
|
||
if (trimmed.length) return Math.min(12, trimmed.length);
|
||
return Math.max(0, Math.min(12, Math.round(-Math.log10(minMove))));
|
||
}
|
||
|
||
const SAFE_PRICE_FORMAT = { type: "price", precision: 4, minMove: 0.0001 };
|
||
|
||
function tickToPriceFormat(tick) {
|
||
try {
|
||
if (tick == null || !Number.isFinite(Number(tick)) || Number(tick) <= 0) {
|
||
return { type: "price", precision: 2, minMove: 0.01 };
|
||
}
|
||
const minMove = Number(tick);
|
||
let prec = decimalsFromTick(minMove);
|
||
if (prec == null || prec < 0) prec = 4;
|
||
prec = Math.min(12, Math.max(0, Math.floor(prec)));
|
||
return { type: "price", precision: prec, minMove: minMove };
|
||
} catch (e) {
|
||
return SAFE_PRICE_FORMAT;
|
||
}
|
||
}
|
||
|
||
function roundToTick(v) {
|
||
if (v == null || Number.isNaN(Number(v))) return v;
|
||
const n = Number(v);
|
||
const tick = priceTick;
|
||
if (tick == null || !Number.isFinite(Number(tick)) || Number(tick) <= 0) return n;
|
||
const t = Number(tick);
|
||
const rounded = Math.round(n / t) * t;
|
||
const dec = decimalsFromTick(t);
|
||
if (dec == null) return rounded;
|
||
return parseFloat(rounded.toFixed(dec));
|
||
}
|
||
|
||
function alignCandlesToTick(candles) {
|
||
if (!Array.isArray(candles) || !candles.length) return candles || [];
|
||
if (priceTick == null || !Number.isFinite(Number(priceTick)) || Number(priceTick) <= 0) {
|
||
return candles;
|
||
}
|
||
return candles.map(function (c) {
|
||
return {
|
||
time: c.time,
|
||
open: roundToTick(c.open),
|
||
high: roundToTick(c.high),
|
||
low: roundToTick(c.low),
|
||
close: roundToTick(c.close),
|
||
volume: c.volume,
|
||
};
|
||
});
|
||
}
|
||
|
||
function applyPriceFormatToSeries(series, pf) {
|
||
if (!series || !series.applyOptions) return;
|
||
try {
|
||
series.applyOptions({ priceFormat: pf });
|
||
} catch (e) {
|
||
series.applyOptions({ priceFormat: SAFE_PRICE_FORMAT });
|
||
}
|
||
}
|
||
|
||
function applyChartPriceFormat() {
|
||
let pf = SAFE_PRICE_FORMAT;
|
||
try {
|
||
pf = tickToPriceFormat(priceTick);
|
||
} catch (e) {
|
||
pf = SAFE_PRICE_FORMAT;
|
||
}
|
||
applyPriceFormatToSeries(candleSeries, pf);
|
||
applyPriceFormatToSeries(indSeries.ema21, pf);
|
||
applyPriceFormatToSeries(indSeries.ema55, pf);
|
||
if (chart) {
|
||
chart.applyOptions({
|
||
localization: {
|
||
priceFormatter: function (p) {
|
||
return fmtPrice(p);
|
||
},
|
||
},
|
||
});
|
||
}
|
||
}
|
||
|
||
function fmtPrice(v) {
|
||
if (v == null || Number.isNaN(Number(v))) return "-";
|
||
const aligned = roundToTick(v);
|
||
const n = Number(aligned);
|
||
if (n === 0) return "0";
|
||
const dec = decimalsFromTick(priceTick);
|
||
if (dec != null) return n.toFixed(dec);
|
||
const av = Math.abs(n);
|
||
let d = 8;
|
||
if (av >= 10000) d = 2;
|
||
else if (av >= 100) d = 3;
|
||
else if (av >= 1) d = 4;
|
||
else if (av >= 0.01) d = 6;
|
||
let text = n.toFixed(d);
|
||
if (text.indexOf(".") >= 0) text = text.replace(/\.?0+$/, "");
|
||
return text;
|
||
}
|
||
|
||
function exchangeLabel() {
|
||
if (!elExchange) return "";
|
||
const opt = elExchange.options[elExchange.selectedIndex];
|
||
if (opt && opt.textContent) return opt.textContent.trim();
|
||
return (elExchange.value || "").trim().toUpperCase();
|
||
}
|
||
|
||
function updateExchangeDisplay() {
|
||
const label = exchangeLabel();
|
||
if (elExLabel) elExLabel.textContent = label;
|
||
if (elExBadge) {
|
||
elExBadge.textContent = label;
|
||
elExBadge.setAttribute("aria-hidden", label ? "false" : "true");
|
||
}
|
||
}
|
||
|
||
function updateHeaderLabels(sym, tf) {
|
||
if (elSymLabel) elSymLabel.textContent = sym || "—";
|
||
if (elTfLabel) elTfLabel.textContent = tf || "—";
|
||
updateExchangeDisplay();
|
||
}
|
||
|
||
function fmtAmplitude(bar) {
|
||
if (!bar) return "-";
|
||
const o = Number(bar.open);
|
||
const h = Number(bar.high);
|
||
const l = Number(bar.low);
|
||
if (!o || o <= 0 || !Number.isFinite(h) || !Number.isFinite(l)) return "-";
|
||
return (((h - l) / o) * 100).toFixed(2) + "%";
|
||
}
|
||
|
||
function barRemainMs(tf) {
|
||
const period = TF_MS[tf] || TF_MS["1d"];
|
||
const now = Date.now();
|
||
const barOpen = Math.floor(now / period) * period;
|
||
return Math.max(0, barOpen + period - now);
|
||
}
|
||
|
||
function fmtBarCountdown(ms) {
|
||
const total = Math.max(0, Math.floor(ms / 1000));
|
||
const h = Math.floor(total / 3600);
|
||
const m = Math.floor((total % 3600) / 60);
|
||
const s = total % 60;
|
||
const pad = function (n) {
|
||
return n < 10 ? "0" + n : String(n);
|
||
};
|
||
if (h > 0) return h + ":" + pad(m) + ":" + pad(s);
|
||
return pad(m) + ":" + pad(s);
|
||
}
|
||
|
||
function paintOhlcv(bar) {
|
||
if (!bar) {
|
||
["o", "h", "l", "c", "v", "amp"].forEach(function (k) {
|
||
const el = { o: elO, h: elH, l: elL, c: elC, v: elV, amp: elAmp }[k];
|
||
if (el) el.textContent = "-";
|
||
});
|
||
return;
|
||
}
|
||
if (elO) elO.textContent = fmtPrice(bar.open);
|
||
if (elH) elH.textContent = fmtPrice(bar.high);
|
||
if (elL) elL.textContent = fmtPrice(bar.low);
|
||
if (elC) elC.textContent = fmtPrice(bar.close);
|
||
if (elV) elV.textContent = fmtVol(bar.volume);
|
||
if (elAmp) elAmp.textContent = fmtAmplitude(bar);
|
||
}
|
||
|
||
function latestCandle() {
|
||
return lastCandles.length ? lastCandles[lastCandles.length - 1] : null;
|
||
}
|
||
|
||
function showLatestOhlcv() {
|
||
paintOhlcv(latestCandle());
|
||
updateCurrentPriceLine();
|
||
updatePriceTag();
|
||
}
|
||
|
||
function clearCurrentPriceLine() {
|
||
if (currentPriceLine && candleSeries) {
|
||
try {
|
||
candleSeries.removePriceLine(currentPriceLine);
|
||
} catch (e) {}
|
||
}
|
||
currentPriceLine = null;
|
||
}
|
||
|
||
function updateCurrentPriceLine() {
|
||
clearCurrentPriceLine();
|
||
if (!candleSeries) return;
|
||
const bar = latestCandle();
|
||
if (!bar || bar.close == null) return;
|
||
const up = Number(bar.close) >= Number(bar.open);
|
||
currentPriceLine = candleSeries.createPriceLine({
|
||
price: Number(roundToTick(bar.close)),
|
||
color: up ? "#00ff9d" : "#ff4d6d",
|
||
lineWidth: 1,
|
||
lineStyle: 2,
|
||
axisLabelVisible: false,
|
||
title: "",
|
||
});
|
||
}
|
||
|
||
function tickLiveClock() {
|
||
const cd = fmtBarCountdown(barRemainMs(currentTf));
|
||
if (elPriceTagTime && elPriceTag && !elPriceTag.classList.contains("hidden")) {
|
||
elPriceTagTime.textContent = cd;
|
||
}
|
||
if (elBarCountdown) elBarCountdown.textContent = "距收盘 " + cd;
|
||
}
|
||
|
||
function updatePriceTag() {
|
||
if (!elPriceTag || !candleSeries || !chart) return;
|
||
try {
|
||
tickLiveClock();
|
||
const bar = latestCandle();
|
||
if (!bar || bar.close == null) {
|
||
elPriceTag.classList.add("hidden");
|
||
elPriceTag.setAttribute("aria-hidden", "true");
|
||
return;
|
||
}
|
||
let y = null;
|
||
try {
|
||
y = candleSeries.priceToCoordinate(Number(bar.close));
|
||
} catch (e) {
|
||
y = null;
|
||
}
|
||
const hostH = chartHost.clientHeight || 0;
|
||
if (y == null || y < 8 || y > hostH - 8) {
|
||
elPriceTag.classList.add("hidden");
|
||
elPriceTag.setAttribute("aria-hidden", "true");
|
||
return;
|
||
}
|
||
const up = Number(bar.close) >= Number(bar.open);
|
||
elPriceTag.classList.remove("hidden", "is-up", "is-down");
|
||
elPriceTag.classList.add(up ? "is-up" : "is-down");
|
||
elPriceTag.setAttribute("aria-hidden", "false");
|
||
elPriceTag.style.left = "auto";
|
||
elPriceTag.style.right = "0";
|
||
elPriceTag.style.top = y + "px";
|
||
if (elPriceTagValue) elPriceTagValue.textContent = fmtPrice(bar.close);
|
||
} catch (e) {
|
||
elPriceTag.classList.add("hidden");
|
||
elPriceTag.setAttribute("aria-hidden", "true");
|
||
}
|
||
}
|
||
|
||
function startPriceTagTimer() {
|
||
stopPriceTagTimer();
|
||
tickLiveClock();
|
||
priceTagTimer = setInterval(tickLiveClock, 1000);
|
||
}
|
||
|
||
function stopPriceTagTimer() {
|
||
if (priceTagTimer) clearInterval(priceTagTimer);
|
||
priceTagTimer = null;
|
||
}
|
||
|
||
function applyPriceAutoScale() {
|
||
if (!chart) return;
|
||
chart.priceScale("right").applyOptions({ autoScale: priceAutoScale });
|
||
if (elPriceAuto) elPriceAuto.classList.toggle("is-on", priceAutoScale);
|
||
}
|
||
|
||
function indexCandles(candles) {
|
||
candleByTime = {};
|
||
(candles || []).forEach(function (c) {
|
||
if (c && c.time != null) candleByTime[c.time] = c;
|
||
});
|
||
}
|
||
|
||
function candleAtTime(t) {
|
||
if (t == null) return null;
|
||
return candleByTime[t] || null;
|
||
}
|
||
|
||
function chartThemePalette() {
|
||
const light = document.documentElement.getAttribute("data-theme") === "light";
|
||
return light
|
||
? {
|
||
bg: "#f0f4f9",
|
||
text: "#4a6078",
|
||
border: "#b8c8d8",
|
||
up: "#0a8f5c",
|
||
down: "#c93552",
|
||
volUp: "rgba(10, 143, 92, 0.45)",
|
||
volDown: "rgba(201, 53, 82, 0.45)",
|
||
}
|
||
: {
|
||
bg: "#0a1018",
|
||
text: "#b8d4e8",
|
||
border: "#2a4058",
|
||
up: "#00ff9d",
|
||
down: "#ff4d6d",
|
||
volUp: "rgba(0, 255, 157, 0.5)",
|
||
volDown: "rgba(255, 77, 109, 0.5)",
|
||
};
|
||
}
|
||
|
||
function applyChartTheme() {
|
||
if (!chart) return;
|
||
const p = chartThemePalette();
|
||
chart.applyOptions({
|
||
layout: { background: { color: p.bg }, textColor: p.text },
|
||
rightPriceScale: { borderColor: p.border },
|
||
timeScale: { borderColor: p.border },
|
||
});
|
||
if (candleSeries) {
|
||
candleSeries.applyOptions({
|
||
upColor: p.up,
|
||
downColor: p.down,
|
||
wickUpColor: p.up,
|
||
wickDownColor: p.down,
|
||
});
|
||
}
|
||
if (volumeSeries && lastCandles.length) {
|
||
volumeSeries.setData(buildVolumeData(lastCandles));
|
||
}
|
||
}
|
||
|
||
function buildVolumeData(candles) {
|
||
const p = chartThemePalette();
|
||
return (candles || []).map(function (c) {
|
||
const up = Number(c.close) >= Number(c.open);
|
||
return {
|
||
time: c.time,
|
||
value: Number(c.volume) || 0,
|
||
color: up ? p.volUp : p.volDown,
|
||
};
|
||
});
|
||
}
|
||
|
||
function ensureChart() {
|
||
if (chart && candleSeries && volumeSeries) return true;
|
||
if (!window.LightweightCharts) {
|
||
if (elStatus) {
|
||
elStatus.className = "market-status err";
|
||
elStatus.textContent = "图表库加载失败";
|
||
}
|
||
return false;
|
||
}
|
||
const tp = chartThemePalette();
|
||
chart = LightweightCharts.createChart(chartHost, {
|
||
layout: { background: { color: tp.bg }, textColor: tp.text },
|
||
grid: {
|
||
vertLines: { visible: false },
|
||
horzLines: { visible: false },
|
||
},
|
||
rightPriceScale: { borderColor: tp.border, autoScale: true },
|
||
timeScale: {
|
||
borderColor: tp.border,
|
||
timeVisible: true,
|
||
secondsVisible: false,
|
||
rightOffset: RIGHT_OFFSET_BARS,
|
||
},
|
||
crosshair: {
|
||
mode: LightweightCharts.CrosshairMode
|
||
? LightweightCharts.CrosshairMode.Normal
|
||
: 0,
|
||
},
|
||
});
|
||
|
||
const candleOpts = {
|
||
upColor: tp.up,
|
||
downColor: tp.down,
|
||
borderVisible: false,
|
||
wickUpColor: tp.up,
|
||
wickDownColor: tp.down,
|
||
lastValueVisible: false,
|
||
priceLineVisible: false,
|
||
priceFormat: SAFE_PRICE_FORMAT,
|
||
};
|
||
|
||
if (typeof chart.addCandlestickSeries === "function") {
|
||
candleSeries = chart.addCandlestickSeries(candleOpts);
|
||
} else if (
|
||
typeof chart.addSeries === "function" &&
|
||
window.LightweightCharts &&
|
||
window.LightweightCharts.CandlestickSeries
|
||
) {
|
||
candleSeries = chart.addSeries(window.LightweightCharts.CandlestickSeries, candleOpts);
|
||
}
|
||
if (!candleSeries) return false;
|
||
|
||
const volOpts = {
|
||
priceFormat: { type: "volume" },
|
||
priceScaleId: "",
|
||
lastValueVisible: false,
|
||
};
|
||
if (typeof chart.addHistogramSeries === "function") {
|
||
volumeSeries = chart.addHistogramSeries(volOpts);
|
||
} else if (
|
||
typeof chart.addSeries === "function" &&
|
||
window.LightweightCharts &&
|
||
window.LightweightCharts.HistogramSeries
|
||
) {
|
||
volumeSeries = chart.addSeries(window.LightweightCharts.HistogramSeries, volOpts);
|
||
}
|
||
if (!volumeSeries) return false;
|
||
|
||
applyScaleLayout();
|
||
applyChartPriceFormat();
|
||
applyPriceAutoScale();
|
||
|
||
chart.subscribeCrosshairMove(function (param) {
|
||
if (!param || param.time == null) {
|
||
showLatestOhlcv();
|
||
return;
|
||
}
|
||
const bar = candleAtTime(param.time);
|
||
if (!bar) {
|
||
showLatestOhlcv();
|
||
return;
|
||
}
|
||
paintOhlcv(bar);
|
||
});
|
||
|
||
chart.timeScale().subscribeVisibleLogicalRangeChange(function () {
|
||
updateVisibleRangeMarkers();
|
||
updatePriceTag();
|
||
});
|
||
|
||
window.addEventListener("resize", function () {
|
||
scheduleChartResize();
|
||
});
|
||
scheduleChartResize();
|
||
return true;
|
||
}
|
||
|
||
function clearMarkers() {
|
||
rangeMarkers.forEach(function (m) {
|
||
try {
|
||
candleSeries.removePriceLine(m);
|
||
} catch (e) {}
|
||
});
|
||
rangeMarkers = [];
|
||
}
|
||
|
||
function viewKey(exKey, sym, tf) {
|
||
return (exKey || "") + "|" + (sym || "") + "|" + (tf || "");
|
||
}
|
||
|
||
function applyChartRightGap() {
|
||
if (!chart) return;
|
||
chart.timeScale().applyOptions({
|
||
rightOffset: RIGHT_OFFSET_BARS,
|
||
fixRightEdge: false,
|
||
});
|
||
}
|
||
|
||
function applyDefaultVisibleRange() {
|
||
if (!chart || !lastCandles.length) return;
|
||
const n = lastCandles.length;
|
||
const visible = Math.min(DEFAULT_VISIBLE_BARS, n);
|
||
const from = Math.max(0, n - visible);
|
||
// to 延伸到最后一根 K 线之后，留出 RIGHT_OFFSET_BARS 根空白（K 线与价格轴间距）
|
||
const to = n - 1 + RIGHT_OFFSET_BARS;
|
||
applyChartRightGap();
|
||
chart.timeScale().setVisibleLogicalRange({ from: from, to: to });
|
||
}
|
||
|
||
function updateVisibleRangeMarkers() {
|
||
clearMarkers();
|
||
if (!candleSeries || !chart || !lastCandles.length) return;
|
||
|
||
const range = chart.timeScale().getVisibleLogicalRange();
|
||
if (!range) return;
|
||
|
||
const from = Math.max(0, Math.floor(range.from));
|
||
const to = Math.min(lastCandles.length - 1, Math.ceil(range.to));
|
||
if (to < from) return;
|
||
|
||
let hi = null;
|
||
let lo = null;
|
||
for (let i = from; i <= to; i++) {
|
||
const c = lastCandles[i];
|
||
if (!c) continue;
|
||
if (!hi || c.high > hi.high) hi = c;
|
||
if (!lo || c.low < lo.low) lo = c;
|
||
}
|
||
if (!hi || !lo) return;
|
||
|
||
rangeMarkers.push(
|
||
candleSeries.createPriceLine({
|
||
price: Number(roundToTick(hi.high)),
|
||
color: "#ffb84d",
|
||
lineWidth: 1,
|
||
lineStyle: 2,
|
||
axisLabelVisible: true,
|
||
title: "高点",
|
||
})
|
||
);
|
||
rangeMarkers.push(
|
||
candleSeries.createPriceLine({
|
||
price: Number(roundToTick(lo.low)),
|
||
color: "#4cd97f",
|
||
lineWidth: 1,
|
||
lineStyle: 2,
|
||
axisLabelVisible: true,
|
||
title: "低点",
|
||
})
|
||
);
|
||
}
|
||
|
||
function readQuery() {
|
||
const qs = new URLSearchParams(window.location.search);
|
||
const ex = qs.get("exchange_key") || qs.get("exchange") || "";
|
||
const sym = qs.get("symbol") || "";
|
||
const tf = qs.get("timeframe") || "";
|
||
if (ex && elExchange) elExchange.value = ex;
|
||
if (sym && elSymbol) elSymbol.value = sym;
|
||
if (tf && elTf) elTf.value = tf;
|
||
}
|
||
|
||
function applyDefaults() {
|
||
if (elSymbol && !elSymbol.value.trim()) elSymbol.value = "BTC/USDT";
|
||
if (elTf && !elTf.value) elTf.value = "1d";
|
||
}
|
||
|
||
function currentViewSeriesKey() {
|
||
const exKey = (elExchange && elExchange.value) || "";
|
||
const sym = (elSymbol && elSymbol.value.trim().toUpperCase()) || "";
|
||
const tf = (elTf && elTf.value) || "1d";
|
||
if (!exKey || !sym) return "";
|
||
return exKey + "|" + sym + "|" + tf;
|
||
}
|
||
|
||
function postChartWatch() {
|
||
const exKey = (elExchange && elExchange.value) || "";
|
||
const sym = (elSymbol && elSymbol.value.trim().toUpperCase()) || "";
|
||
const tf = (elTf && elTf.value) || "1d";
|
||
if (!exKey || !sym) return Promise.resolve();
|
||
return fetch("/api/chart/watch", {
|
||
method: "POST",
|
||
credentials: "same-origin",
|
||
headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify({ exchange_key: exKey, symbol: sym, timeframe: tf }),
|
||
}).catch(function () {});
|
||
}
|
||
|
||
function postChartUnwatch() {
|
||
const exKey = (elExchange && elExchange.value) || "";
|
||
const sym = (elSymbol && elSymbol.value.trim().toUpperCase()) || "";
|
||
const tf = (elTf && elTf.value) || "1d";
|
||
if (!exKey || !sym) return Promise.resolve();
|
||
return fetch("/api/chart/unwatch", {
|
||
method: "POST",
|
||
credentials: "same-origin",
|
||
headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify({ exchange_key: exKey, symbol: sym, timeframe: tf }),
|
||
}).catch(function () {});
|
||
}
|
||
|
||
function closeChartStream() {
|
||
if (chartEventSource) {
|
||
chartEventSource.close();
|
||
chartEventSource = null;
|
||
}
|
||
}
|
||
|
||
function connectChartStream() {
|
||
closeChartStream();
|
||
const page = document.getElementById("page-market");
|
||
if (!page || page.classList.contains("hidden")) return;
|
||
chartEventSource = new EventSource("/api/chart/stream");
|
||
chartEventSource.addEventListener("chart", function (ev) {
|
||
try {
|
||
const st = JSON.parse(ev.data || "{}");
|
||
const ver = Number(st.chart_version) || 0;
|
||
const series = st.series || {};
|
||
const vKey = currentViewSeriesKey();
|
||
const sVer = vKey && series[vKey] ? Number(series[vKey].series_version) || 0 : 0;
|
||
const seriesChanged = vKey && sVer > 0 && sVer !== localSeriesVersion;
|
||
if (seriesChanged) {
|
||
localSeriesVersion = sVer;
|
||
localChartVersion = ver;
|
||
loadChart(false, { autoTick: true });
|
||
} else if (ver !== localChartVersion) {
|
||
localChartVersion = ver;
|
||
}
|
||
} catch (_) {}
|
||
});
|
||
chartEventSource.onerror = function () {
|
||
closeChartStream();
|
||
if (chartSseReconnectTimer) clearTimeout(chartSseReconnectTimer);
|
||
chartSseReconnectTimer = setTimeout(function () {
|
||
const p = document.getElementById("page-market");
|
||
if (p && !p.classList.contains("hidden")) connectChartStream();
|
||
}, 8000);
|
||
};
|
||
}
|
||
|
||
function startChartWatchHeartbeat() {
|
||
stopChartWatchHeartbeat();
|
||
void postChartWatch();
|
||
chartWatchTimer = setInterval(function () {
|
||
const page = document.getElementById("page-market");
|
||
if (!page || page.classList.contains("hidden")) return;
|
||
void postChartWatch();
|
||
}, CHART_WATCH_HEARTBEAT_MS);
|
||
}
|
||
|
||
function stopChartWatchHeartbeat() {
|
||
if (chartWatchTimer) clearInterval(chartWatchTimer);
|
||
chartWatchTimer = null;
|
||
}
|
||
|
||
function startAutoRefresh() {
|
||
stopAutoRefresh();
|
||
refreshTimer = setInterval(function () {
|
||
const page = document.getElementById("page-market");
|
||
if (!page || page.classList.contains("hidden")) return;
|
||
loadChart(false, { autoTick: true });
|
||
}, CHART_SSE_FALLBACK_MS);
|
||
}
|
||
|
||
function stopAutoRefresh() {
|
||
if (refreshTimer) clearInterval(refreshTimer);
|
||
refreshTimer = null;
|
||
if (chartSseReconnectTimer) {
|
||
clearTimeout(chartSseReconnectTimer);
|
||
chartSseReconnectTimer = null;
|
||
}
|
||
}
|
||
|
||
function stopChartLive() {
|
||
stopAutoRefresh();
|
||
stopChartWatchHeartbeat();
|
||
closeChartStream();
|
||
void postChartUnwatch();
|
||
}
|
||
|
||
async function loadMeta() {
|
||
const r = await fetch("/api/chart/meta", { credentials: "same-origin" });
|
||
chartMeta = await r.json();
|
||
if (!elExchange || !chartMeta.exchanges) return;
|
||
elExchange.innerHTML = "";
|
||
chartMeta.exchanges.forEach(function (ex) {
|
||
const opt = document.createElement("option");
|
||
opt.value = ex.key || ex.id;
|
||
opt.textContent = ex.name || ex.key;
|
||
elExchange.appendChild(opt);
|
||
});
|
||
populateFsExchangeOptions();
|
||
readQuery();
|
||
applyDefaults();
|
||
updateExchangeDisplay();
|
||
}
|
||
|
||
async function loadChart(force, options) {
|
||
options = options || {};
|
||
const autoTick = !!options.autoTick;
|
||
if (!autoTick) {
|
||
localSeriesVersion = 0;
|
||
void postChartWatch();
|
||
}
|
||
if (!ensureChart()) return;
|
||
const exKey = (elExchange && elExchange.value) || "";
|
||
const sym = (elSymbol && elSymbol.value.trim().toUpperCase()) || "";
|
||
const tf = (elTf && elTf.value) || "1d";
|
||
currentTf = tf;
|
||
if (!exKey || !sym) {
|
||
if (elStatus) {
|
||
elStatus.className = "market-status err";
|
||
elStatus.textContent = "请选择交易所并输入币种";
|
||
}
|
||
return;
|
||
}
|
||
const myToken = ++loadToken;
|
||
const vKey = viewKey(exKey, sym, tf);
|
||
const resetView = !!force || !autoTick || vKey !== lastViewKey;
|
||
let savedRange = null;
|
||
if (!resetView && chart) {
|
||
savedRange = chart.timeScale().getVisibleLogicalRange();
|
||
}
|
||
if (!autoTick && elStatus) {
|
||
elStatus.className = "market-status";
|
||
elStatus.textContent = "加载中…";
|
||
}
|
||
updateHeaderLabels(sym, tf);
|
||
|
||
const qs = new URLSearchParams({
|
||
exchange_key: exKey,
|
||
symbol: sym,
|
||
timeframe: tf,
|
||
});
|
||
if (force) qs.set("refresh", "1");
|
||
|
||
try {
|
||
const r = await fetch("/api/chart/ohlcv?" + qs.toString(), { credentials: "same-origin" });
|
||
const data = await r.json();
|
||
if (myToken !== loadToken) return;
|
||
if (!r.ok) {
|
||
throw new Error(data.detail || data.msg || "请求失败");
|
||
}
|
||
if (!data.ok || !data.candles || !data.candles.length) {
|
||
throw new Error(data.msg || "无 K 线");
|
||
}
|
||
|
||
priceTick = data.price_tick;
|
||
try {
|
||
applyChartPriceFormat();
|
||
} catch (fmtErr) {
|
||
priceTick = null;
|
||
applyChartPriceFormat();
|
||
}
|
||
lastCandles = alignCandlesToTick(data.candles);
|
||
indexCandles(lastCandles);
|
||
candleSeries.setData(lastCandles);
|
||
volumeSeries.setData(buildVolumeData(lastCandles));
|
||
applyChartRightGap();
|
||
if (resetView) {
|
||
lastViewKey = vKey;
|
||
applyDefaultVisibleRange();
|
||
} else if (savedRange) {
|
||
chart.timeScale().setVisibleLogicalRange(savedRange);
|
||
}
|
||
applyPriceAutoScale();
|
||
updateVisibleRangeMarkers();
|
||
syncPosContextForView(exKey, sym);
|
||
showLatestOhlcv();
|
||
try {
|
||
updateIndicators();
|
||
} catch (indErr) {
|
||
/* 指标序列 priceFormat 异常时不阻断主图 */
|
||
}
|
||
scheduleChartResize();
|
||
|
||
const limit = data.limit || lastCandles.length;
|
||
let hint =
|
||
"已加载 " +
|
||
data.candles.length +
|
||
" 根（目标 " +
|
||
limit +
|
||
"）· 库 " +
|
||
(data.from_cache || 0) +
|
||
" / 新拉 " +
|
||
(data.fetched || 0) +
|
||
"）· 后台 " +
|
||
(data.chart_poll_interval_sec || 5) +
|
||
"s 轮询 · SSE";
|
||
if (data.stale && data.stale_message) {
|
||
hint += " · 缓存：" + data.stale_message;
|
||
}
|
||
if (elStatus) {
|
||
elStatus.className = data.stale ? "market-status warn" : "market-status";
|
||
elStatus.textContent = hint;
|
||
}
|
||
if (elUpdated) elUpdated.textContent = "数据 " + (data.updated_at || "--");
|
||
if (data.series_version != null) localSeriesVersion = Number(data.series_version) || localSeriesVersion;
|
||
if (data.chart_version != null) localChartVersion = Number(data.chart_version) || localChartVersion;
|
||
tickLiveClock();
|
||
} catch (e) {
|
||
if (myToken !== loadToken) return;
|
||
if (elStatus) {
|
||
elStatus.className = "market-status err";
|
||
elStatus.textContent = String(e.message || e);
|
||
}
|
||
}
|
||
}
|
||
|
||
function bind() {
|
||
if (elRefresh) {
|
||
elRefresh.addEventListener("click", function () {
|
||
loadChart(true);
|
||
});
|
||
}
|
||
if (elTf) {
|
||
elTf.addEventListener("change", function () {
|
||
tfDigitBuf = "";
|
||
if (tfDigitTimer) {
|
||
clearTimeout(tfDigitTimer);
|
||
tfDigitTimer = null;
|
||
}
|
||
currentTf = (elTf && elTf.value) || "1d";
|
||
tickLiveClock();
|
||
syncFsToolbarFromMain();
|
||
loadChart(false);
|
||
});
|
||
}
|
||
if (elExchange) {
|
||
elExchange.addEventListener("change", function () {
|
||
updateExchangeDisplay();
|
||
syncFsToolbarFromMain();
|
||
loadChart(false);
|
||
});
|
||
}
|
||
if (elSymbol) {
|
||
elSymbol.addEventListener("keydown", function (e) {
|
||
if (e.key === "Enter") loadChart(false);
|
||
});
|
||
}
|
||
const btnLoad = document.getElementById("market-load");
|
||
if (btnLoad) {
|
||
btnLoad.addEventListener("click", function () {
|
||
loadChart(false);
|
||
});
|
||
}
|
||
if (elPriceAuto) {
|
||
elPriceAuto.addEventListener("click", function () {
|
||
priceAutoScale = !priceAutoScale;
|
||
applyPriceAutoScale();
|
||
});
|
||
}
|
||
if (elPosClear) {
|
||
elPosClear.addEventListener("click", function () {
|
||
clearPosContext();
|
||
});
|
||
}
|
||
if (elFsBtn) {
|
||
elFsBtn.addEventListener("click", function () {
|
||
toggleChartFullscreen();
|
||
});
|
||
}
|
||
if (elFsExit) {
|
||
elFsExit.addEventListener("click", function () {
|
||
setChartFullscreen(false);
|
||
});
|
||
}
|
||
[elIndEma, elIndMacd, elIndRsi].forEach(function (el) {
|
||
if (!el) return;
|
||
el.addEventListener("change", function () {
|
||
updateIndicators();
|
||
});
|
||
});
|
||
const pageMarket = document.getElementById("page-market");
|
||
const fsKeyTargets = [window, pageMarket, elChartWrap, chartHost].filter(Boolean);
|
||
fsKeyTargets.forEach(function (el) {
|
||
el.addEventListener("keydown", onChartFullscreenKey, true);
|
||
});
|
||
window.addEventListener("keydown", onMarketKeydown, true);
|
||
if (elChartWrap) {
|
||
if (!elChartWrap.hasAttribute("tabindex")) elChartWrap.setAttribute("tabindex", "-1");
|
||
elChartWrap.addEventListener("mousedown", focusMarketChartArea);
|
||
}
|
||
if (elFsExchange) {
|
||
elFsExchange.addEventListener("change", function () {
|
||
syncMainFromFsToolbar();
|
||
loadChart(false);
|
||
});
|
||
}
|
||
if (elFsTf) {
|
||
elFsTf.addEventListener("change", function () {
|
||
currentTf = elFsTf.value || "1d";
|
||
syncMainFromFsToolbar();
|
||
tickLiveClock();
|
||
loadChart(false);
|
||
});
|
||
}
|
||
if (elFsSymbol) {
|
||
elFsSymbol.addEventListener("keydown", function (e) {
|
||
if (e.key === "Enter") {
|
||
syncMainFromFsToolbar();
|
||
loadChart(false);
|
||
}
|
||
});
|
||
}
|
||
if (elFsLoad) {
|
||
elFsLoad.addEventListener("click", function () {
|
||
syncMainFromFsToolbar();
|
||
loadChart(false);
|
||
});
|
||
}
|
||
}
|
||
|
||
window.hubMarketChart = {
|
||
init: async function () {
|
||
if (!marketInited) {
|
||
marketInited = true;
|
||
await loadMeta();
|
||
bind();
|
||
} else {
|
||
readQuery();
|
||
}
|
||
focusMarketChartArea();
|
||
connectChartStream();
|
||
startChartWatchHeartbeat();
|
||
startAutoRefresh();
|
||
await loadChart(false);
|
||
startPriceTagTimer();
|
||
},
|
||
openWith: async function (exKey, sym, tf) {
|
||
if (!marketInited) {
|
||
await this.init();
|
||
}
|
||
if (elExchange && exKey) elExchange.value = exKey;
|
||
if (elSymbol && sym) elSymbol.value = String(sym).trim().toUpperCase();
|
||
if (tf && elTf) elTf.value = tf;
|
||
lastViewKey = "";
|
||
localSeriesVersion = 0;
|
||
updateExchangeDisplay();
|
||
connectChartStream();
|
||
startChartWatchHeartbeat();
|
||
startAutoRefresh();
|
||
await loadChart(false);
|
||
startPriceTagTimer();
|
||
},
|
||
reload: function (force) {
|
||
loadChart(!!force);
|
||
},
|
||
startAutoRefresh: startAutoRefresh,
|
||
stopAutoRefresh: stopAutoRefresh,
|
||
stopChartLive: stopChartLive,
|
||
stopPriceTagTimer: stopPriceTagTimer,
|
||
};
|
||
|
||
document.addEventListener("hub-theme-change", function () {
|
||
applyChartTheme();
|
||
});
|
||
|
||
if (
|
||
document.getElementById("page-market") &&
|
||
!document.getElementById("page-market").classList.contains("hidden")
|
||
) {
|
||
window.hubMarketChart.init();
|
||
}
|
||
})();
|