// This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not // distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/. // © LazyBear: the calculation of "Squeeze Momentum Indicator [LazyBear]", https://www.tradingview.com/script/nqQ1DT5a/ // Modified by ProEA, 2026: ported from Pine to TypeScript for a drill on simulated candles, with the fixed BB // MultFactor formula as a switch. // Source of this file: https://proea.app/open-source/squeeze.ts.txt, listed at https://proea.app/en/legal/open-source // // src/components/blog/squeeze-settings/squeeze.ts // Exact TypeScript twin of LazyBear's Squeeze Momentum Indicator [LazyBear] (nqQ1DT5a, lines 7–40, // read 11 November 2026 at 118,132 boosts), alongside the fixed BB MultFactor formula used by // Greeny (eFs5kf8F), Beardy_Fred (0drMdHsO), dgtrd (Dsr7B2xE) and 03.freeman (qp9BoNyS). export type SqueezeCandle = readonly [ timeSec: number, open: number, high: number, low: number, close: number, ]; export type SqueezeFormulaMode = "lazybear" | "fixed-bb"; export type HistColorKey = "lime" | "green" | "red" | "maroon"; export type SqueezeDotKey = "sqzOn" | "sqzOff" | "noSqz"; export interface SqueezeSettings { bbLength: number; bbMult: number; kcLength: number; kcMult: number; useTrueRange: boolean; mode: SqueezeFormulaMode; } export interface SqueezeBar { val: number; histColor: HistColorKey; dot: SqueezeDotKey; sqzOn: boolean; sqzOff: boolean; noSqz: boolean; fired: boolean; // sqzOn on previous bar -> sqzOff on this bar upperBB: number; lowerBB: number; upperKC: number; lowerKC: number; } export const SQUEEZE_DEFAULTS: SqueezeSettings = { bbLength: 20, bbMult: 2.0, kcLength: 20, kcMult: 1.5, useTrueRange: true, mode: "lazybear", }; export const SQUEEZE_WARM = 30; /** 96 deterministic simulated 15-minute candles (labelled simulated, never market data): * two low-volatility compression boxes separated by an upside expansion and followed by a downside break. */ export const SQUEEZE_BARS: readonly SqueezeCandle[] = (() => { const out: SqueezeCandle[] = []; let s = 42197; const rand = () => { s = (s * 1664525 + 1013904223) >>> 0; return s / 0x100000000; }; const t0 = Date.UTC(2026, 10, 10, 0, 0, 0) / 1000; let price = 100.0; for (let i = 0; i < 96; i++) { let drift = 0; let amp = 0.55; if (i < 22) { // Initial normal range drift = Math.sin(i * 0.5) * 0.16; amp = 0.68; } else if (i < 44) { // Tight compression #1 (triggers sqzOn) drift = (100.2 - price) * 0.25 + (rand() - 0.5) * 0.08; amp = 0.19; } else if (i < 60) { // Upside expansion + peak rollover (lime -> green) drift = i < 53 ? 0.44 : -0.14; amp = 0.78; } else if (i < 76) { // Tight compression #2 near highs drift = (103.1 - price) * 0.28 + (rand() - 0.5) * 0.08; amp = 0.2; } else { // Downside break + bounce (red -> maroon) drift = i < 88 ? -0.46 : 0.16; amp = 0.82; } const open = Number(price.toFixed(3)); const body = drift + (rand() - 0.5) * amp * 0.65; const close = Number((open + body).toFixed(3)); const hiWick = (0.25 + rand() * 0.55) * amp; const loWick = (0.25 + rand() * 0.55) * amp; const high = Number((Math.max(open, close) + hiWick).toFixed(3)); const low = Number((Math.min(open, close) - loWick).toFixed(3)); out.push([t0 + i * 900, open, high, low, close]); price = close; } return out; })(); function smaAt(arr: readonly number[], endIdx: number, len: number): number { const start = Math.max(0, endIdx - len + 1); const count = endIdx - start + 1; let sum = 0; for (let i = start; i <= endIdx; i++) sum += arr[i]!; return sum / count; } /** Pine's population stdev(source, length). */ function stdevAt(arr: readonly number[], endIdx: number, len: number): number { const start = Math.max(0, endIdx - len + 1); const count = endIdx - start + 1; const mean = smaAt(arr, endIdx, len); let sq = 0; for (let i = start; i <= endIdx; i++) { const d = arr[i]! - mean; sq += d * d; } return Math.sqrt(sq / count); } /** Pine's linreg(src, length, 0): endpoint of least-squares line over the last `length` bars. */ function linregAt(arr: readonly number[], endIdx: number, len: number): number { const start = Math.max(0, endIdx - len + 1); const n = endIdx - start + 1; if (n <= 1) return arr[endIdx] ?? 0; let sumX = 0; let sumY = 0; let sumXY = 0; let sumXX = 0; for (let k = 0; k < n; k++) { const y = arr[start + k]!; sumX += k; sumY += y; sumXY += k * y; sumXX += k * k; } const denom = n * sumXX - sumX * sumX; if (denom === 0) return sumY / n; const slope = (n * sumXY - sumX * sumY) / denom; const intercept = (sumY - slope * sumX) / n; return intercept + slope * (n - 1); } export function computeSqueezeMomentum( bars: readonly SqueezeCandle[], s: SqueezeSettings, ): SqueezeBar[] { const closes = bars.map((b) => b[4]); const ranges = bars.map((b, i) => { const [, , hi, lo] = b; if (!s.useTrueRange || i === 0) return hi - lo; const prevClose = bars[i - 1]![4]; return Math.max(hi - lo, Math.abs(hi - prevClose), Math.abs(lo - prevClose)); }); // LazyBear lines 32–33: source - avg(avg(highest(high, lengthKC), lowest(low, lengthKC)), sma(close, lengthKC)) const delta: number[] = bars.map((b, i) => { const start = Math.max(0, i - s.kcLength + 1); let hh = -Infinity; let ll = Infinity; for (let j = start; j <= i; j++) { if (bars[j]![2] > hh) hh = bars[j]![2]; if (bars[j]![3] < ll) ll = bars[j]![3]; } const midDonchian = (hh + ll) / 2; const smaClose = smaAt(closes, i, s.kcLength); const center = (midDonchian + smaClose) / 2; return b[4] - center; }); const out: SqueezeBar[] = []; for (let i = 0; i < bars.length; i++) { const basis = smaAt(closes, i, s.bbLength); // LazyBear line 17 bug: `dev = multKC * stdev(source, length)` ignores `mult` (BB MultFactor)! const effectiveBbMult = s.mode === "lazybear" ? s.kcMult : s.bbMult; const dev = effectiveBbMult * stdevAt(closes, i, s.bbLength); const upperBB = basis + dev; const lowerBB = basis - dev; const ma = smaAt(closes, i, s.kcLength); const rangema = smaAt(ranges, i, s.kcLength); const upperKC = ma + rangema * s.kcMult; const lowerKC = ma - rangema * s.kcMult; const sqzOn = lowerBB > lowerKC && upperBB < upperKC; const sqzOff = lowerBB < lowerKC && upperBB > upperKC; const noSqz = !sqzOn && !sqzOff; const val = linregAt(delta, i, s.kcLength); const prevVal = i > 0 ? out[i - 1]!.val : 0; const histColor: HistColorKey = val > 0 ? val > prevVal ? "lime" : "green" : val < prevVal ? "red" : "maroon"; const dot: SqueezeDotKey = noSqz ? "noSqz" : sqzOn ? "sqzOn" : "sqzOff"; const fired = i > 0 && out[i - 1]!.sqzOn && sqzOff; out.push({ val, histColor, dot, sqzOn, sqzOff, noSqz, fired, upperBB, lowerBB, upperKC, lowerKC, }); } return out; } export interface SqueezeSummary { bars: SqueezeBar[]; shown: SqueezeBar[]; sqzOnCount: number; sqzOffCount: number; noSqzCount: number; releases: number[]; // indices in `bars` (>= SQUEEZE_WARM) where squeeze fires } export function summarizeSqueeze( s: SqueezeSettings, bars: readonly SqueezeCandle[] = SQUEEZE_BARS, warm = SQUEEZE_WARM, ): SqueezeSummary { const computed = computeSqueezeMomentum(bars, s); const shown = computed.slice(warm); const releases: number[] = []; shown.forEach((b, k) => { if (b.fired) releases.push(warm + k); }); return { bars: computed, shown, sqzOnCount: shown.filter((b) => b.sqzOn).length, sqzOffCount: shown.filter((b) => b.sqzOff).length, noSqzCount: shown.filter((b) => b.noSqz).length, releases, }; }