dotdo 0.0.1 → 0.0.2

package/dist/db/primitives/window-manager.js

@@ -0,0 +1,764 @@
+/**
+ * Window Manager - Unified windowing primitive inspired by Apache Flink
+ *
+ * Provides stream windowing capabilities including:
+ * - Tumbling windows (non-overlapping, fixed-size)
+ * - Sliding windows (overlapping, fixed-size with slide interval)
+ * - Session windows (gap-based, dynamic size)
+ * - Global windows (single window for all elements)
+ * - Various triggers (event-time, count-based, processing-time)
+ * - Late data handling and side outputs
+ *
+ * @see https://nightlies.apache.org/flink/flink-docs-stable/docs/dev/datastream/operators/windows/
+ */
+import { noopMetrics, MetricNames } from './observability';
+export { hours, minutes, seconds, milliseconds } from './utils/duration';
+// ============================================================================
+// Tumbling Window Assigner
+// ============================================================================
+class TumblingWindowAssigner {
+    size;
+    type = 'tumbling';
+    constructor(size) {
+        this.size = size;
+    }
+    assignWindows(element, timestamp) {
+        const sizeMs = this.size.toMillis();
+        const windowStart = Math.floor(timestamp / sizeMs) * sizeMs;
+        return [
+            {
+                start: windowStart,
+                end: windowStart + sizeMs,
+            },
+        ];
+    }
+}
+// ============================================================================
+// Sliding Window Assigner
+// ============================================================================
+class SlidingWindowAssigner {
+    size;
+    slide;
+    type = 'sliding';
+    constructor(size, slide) {
+        this.size = size;
+        this.slide = slide;
+        const slideMs = slide.toMillis();
+        const sizeMs = size.toMillis();
+        if (slideMs <= 0) {
+            throw new Error('Slide must be positive');
+        }
+        if (slideMs > sizeMs) {
+            throw new Error('Slide cannot be larger than size');
+        }
+    }
+    assignWindows(element, timestamp) {
+        const sizeMs = this.size.toMillis();
+        const slideMs = this.slide.toMillis();
+        const windows = [];
+        // Find all windows that contain this timestamp
+        // A window contains timestamp if: start <= timestamp < end
+        // where end = start + size
+        // So: start <= timestamp < start + size
+        // Which means: timestamp - size < start <= timestamp
+        // The last window start that contains this element
+        const lastWindowStart = Math.floor(timestamp / slideMs) * slideMs;
+        // Count backwards to find all windows
+        const numWindows = Math.ceil(sizeMs / slideMs);
+        for (let i = 0; i < numWindows; i++) {
+            const windowStart = lastWindowStart - i * slideMs;
+            const windowEnd = windowStart + sizeMs;
+            // Check if this window actually contains the timestamp
+            if (windowStart <= timestamp && timestamp < windowEnd) {
+                windows.push({ start: windowStart, end: windowEnd });
+            }
+        }
+        return windows.sort((a, b) => a.start - b.start);
+    }
+}
+// ============================================================================
+// Session Window Assigner
+// ============================================================================
+class SessionWindowAssigner {
+    gap;
+    type = 'session';
+    constructor(gap) {
+        this.gap = gap;
+    }
+    assignWindows(element, timestamp, key, existingWindows) {
+        const gapMs = this.gap.toMillis();
+        // For session windows, we need to find or create a session
+        // The initial window is [timestamp, timestamp + gap)
+        const newWindow = {
+            start: timestamp,
+            end: timestamp + gapMs,
+            key,
+        };
+        if (!existingWindows) {
+            return [newWindow];
+        }
+        // Find overlapping or adjacent sessions to merge
+        const windowsToMerge = [newWindow];
+        for (const [windowKey, windowData] of existingWindows) {
+            const w = windowData.window;
+            if (key !== undefined && w.key !== key)
+                continue;
+            // Check if windows overlap or are adjacent (within gap)
+            // Two sessions should merge if the gap between them is less than the session gap
+            // Session windows: [start1, end1) and [start2, end2) merge if they overlap or touch
+            if ((newWindow.start <= w.end && newWindow.end >= w.start) || // Overlap
+                Math.abs(newWindow.start - w.end) <= gapMs || // New starts within gap of existing end
+                Math.abs(w.start - newWindow.end) <= gapMs // Existing starts within gap of new end
+            ) {
+                windowsToMerge.push(w);
+            }
+        }
+        // Merge all overlapping windows
+        if (windowsToMerge.length === 1) {
+            return [newWindow];
+        }
+        const mergedStart = Math.min(...windowsToMerge.map((w) => w.start));
+        const mergedEnd = Math.max(...windowsToMerge.map((w) => w.end));
+        return [{ start: mergedStart, end: mergedEnd, key }];
+    }
+}
+// ============================================================================
+// Global Window Assigner
+// ============================================================================
+class GlobalWindowAssigner {
+    type = 'global';
+    assignWindows() {
+        return [
+            {
+                start: Number.MIN_SAFE_INTEGER,
+                end: Number.MAX_SAFE_INTEGER,
+            },
+        ];
+    }
+}
+// ============================================================================
+// Trigger Types
+// ============================================================================
+export var TriggerResult;
+(function (TriggerResult) {
+    TriggerResult["CONTINUE"] = "CONTINUE";
+    TriggerResult["FIRE"] = "FIRE";
+    TriggerResult["FIRE_AND_PURGE"] = "FIRE_AND_PURGE";
+    TriggerResult["PURGE"] = "PURGE";
+})(TriggerResult || (TriggerResult = {}));
+export class Trigger {
+    /**
+     * Clean up any resources held by this trigger.
+     * Subclasses should override if they hold timers or other resources.
+     */
+    dispose() {
+        // Default implementation does nothing
+    }
+    static or(...triggers) {
+        return new OrTrigger(triggers);
+    }
+    static and(...triggers) {
+        return new AndTrigger(triggers);
+    }
+}
+// ============================================================================
+// Event Time Trigger
+// ============================================================================
+export class EventTimeTrigger extends Trigger {
+    onElement(_ctx) {
+        return TriggerResult.CONTINUE;
+    }
+    onWatermark(ctx) {
+        if (ctx.watermark >= ctx.window.end) {
+            return TriggerResult.FIRE;
+        }
+        return TriggerResult.CONTINUE;
+    }
+    onProcessingTime(_ctx) {
+        return TriggerResult.CONTINUE;
+    }
+}
+// ============================================================================
+// Count Trigger
+// ============================================================================
+export class CountTrigger extends Trigger {
+    count;
+    constructor(count) {
+        super();
+        this.count = count;
+    }
+    onElement(ctx) {
+        if (ctx.countSinceLastTrigger >= this.count) {
+            return TriggerResult.FIRE_AND_PURGE;
+        }
+        return TriggerResult.CONTINUE;
+    }
+    onWatermark(_ctx) {
+        return TriggerResult.CONTINUE;
+    }
+    onProcessingTime(_ctx) {
+        return TriggerResult.CONTINUE;
+    }
+}
+// ============================================================================
+// Processing Time Trigger
+// ============================================================================
+export class ProcessingTimeTrigger extends Trigger {
+    interval;
+    timerId = null;
+    callback = null;
+    constructor(interval) {
+        super();
+        this.interval = interval;
+    }
+    setCallback(callback) {
+        this.callback = callback;
+        if (this.timerId) {
+            clearInterval(this.timerId);
+        }
+        this.timerId = setInterval(() => {
+            if (this.callback) {
+                this.callback();
+            }
+        }, this.interval.toMillis());
+    }
+    clearTimer() {
+        if (this.timerId) {
+            clearInterval(this.timerId);
+            this.timerId = null;
+        }
+    }
+    /**
+     * Clean up the interval timer to prevent memory leaks.
+     */
+    dispose() {
+        this.clearTimer();
+        this.callback = null;
+    }
+    onElement(_ctx) {
+        return TriggerResult.CONTINUE;
+    }
+    onWatermark(_ctx) {
+        return TriggerResult.CONTINUE;
+    }
+    onProcessingTime(_ctx) {
+        return TriggerResult.FIRE;
+    }
+}
+// ============================================================================
+// Purging Trigger
+// ============================================================================
+export class PurgingTrigger extends Trigger {
+    innerTrigger;
+    constructor(innerTrigger) {
+        super();
+        this.innerTrigger = innerTrigger;
+    }
+    onElement(ctx) {
+        const result = this.innerTrigger.onElement(ctx);
+        if (result === TriggerResult.FIRE) {
+            return TriggerResult.FIRE_AND_PURGE;
+        }
+        return result;
+    }
+    onWatermark(ctx) {
+        const result = this.innerTrigger.onWatermark(ctx);
+        if (result === TriggerResult.FIRE) {
+            return TriggerResult.FIRE_AND_PURGE;
+        }
+        return result;
+    }
+    onProcessingTime(ctx) {
+        const result = this.innerTrigger.onProcessingTime(ctx);
+        if (result === TriggerResult.FIRE) {
+            return TriggerResult.FIRE_AND_PURGE;
+        }
+        return result;
+    }
+    dispose() {
+        this.innerTrigger.dispose();
+    }
+}
+// ============================================================================
+// Composite Triggers
+// ============================================================================
+class OrTrigger extends Trigger {
+    triggers;
+    firedTriggers = new Set();
+    constructor(triggers) {
+        super();
+        this.triggers = triggers;
+    }
+    onElement(ctx) {
+        for (let i = 0; i < this.triggers.length; i++) {
+            const result = this.triggers[i].onElement(ctx);
+            if (result === TriggerResult.FIRE || result === TriggerResult.FIRE_AND_PURGE) {
+                this.firedTriggers.add(i);
+                return result;
+            }
+        }
+        return TriggerResult.CONTINUE;
+    }
+    onWatermark(ctx) {
+        for (let i = 0; i < this.triggers.length; i++) {
+            const result = this.triggers[i].onWatermark(ctx);
+            if (result === TriggerResult.FIRE || result === TriggerResult.FIRE_AND_PURGE) {
+                this.firedTriggers.add(i);
+                return result;
+            }
+        }
+        return TriggerResult.CONTINUE;
+    }
+    onProcessingTime(ctx) {
+        for (let i = 0; i < this.triggers.length; i++) {
+            const result = this.triggers[i].onProcessingTime(ctx);
+            if (result === TriggerResult.FIRE || result === TriggerResult.FIRE_AND_PURGE) {
+                this.firedTriggers.add(i);
+                return result;
+            }
+        }
+        return TriggerResult.CONTINUE;
+    }
+    dispose() {
+        for (const trigger of this.triggers) {
+            trigger.dispose();
+        }
+        this.firedTriggers.clear();
+    }
+}
+class AndTrigger extends Trigger {
+    triggers;
+    satisfiedTriggers = new Map();
+    constructor(triggers) {
+        super();
+        this.triggers = triggers;
+    }
+    getWindowKey(window) {
+        return `${window.start}-${window.end}-${window.key || ''}`;
+    }
+    checkAndFire(windowKey) {
+        const satisfied = this.satisfiedTriggers.get(windowKey);
+        if (satisfied && satisfied.size === this.triggers.length) {
+            this.satisfiedTriggers.delete(windowKey);
+            return TriggerResult.FIRE;
+        }
+        return TriggerResult.CONTINUE;
+    }
+    onElement(ctx) {
+        const windowKey = this.getWindowKey(ctx.window);
+        if (!this.satisfiedTriggers.has(windowKey)) {
+            this.satisfiedTriggers.set(windowKey, new Set());
+        }
+        const satisfied = this.satisfiedTriggers.get(windowKey);
+        for (let i = 0; i < this.triggers.length; i++) {
+            const result = this.triggers[i].onElement(ctx);
+            if (result === TriggerResult.FIRE || result === TriggerResult.FIRE_AND_PURGE) {
+                satisfied.add(i);
+            }
+        }
+        return this.checkAndFire(windowKey);
+    }
+    onWatermark(ctx) {
+        const windowKey = this.getWindowKey(ctx.window);
+        if (!this.satisfiedTriggers.has(windowKey)) {
+            this.satisfiedTriggers.set(windowKey, new Set());
+        }
+        const satisfied = this.satisfiedTriggers.get(windowKey);
+        for (let i = 0; i < this.triggers.length; i++) {
+            const result = this.triggers[i].onWatermark(ctx);
+            if (result === TriggerResult.FIRE || result === TriggerResult.FIRE_AND_PURGE) {
+                satisfied.add(i);
+            }
+        }
+        return this.checkAndFire(windowKey);
+    }
+    onProcessingTime(ctx) {
+        const windowKey = this.getWindowKey(ctx.window);
+        if (!this.satisfiedTriggers.has(windowKey)) {
+            this.satisfiedTriggers.set(windowKey, new Set());
+        }
+        const satisfied = this.satisfiedTriggers.get(windowKey);
+        for (let i = 0; i < this.triggers.length; i++) {
+            const result = this.triggers[i].onProcessingTime(ctx);
+            if (result === TriggerResult.FIRE || result === TriggerResult.FIRE_AND_PURGE) {
+                satisfied.add(i);
+            }
+        }
+        return this.checkAndFire(windowKey);
+    }
+    dispose() {
+        for (const trigger of this.triggers) {
+            trigger.dispose();
+        }
+        this.satisfiedTriggers.clear();
+    }
+}
+// ============================================================================
+// Window Manager
+// ============================================================================
+export class WindowManager {
+    assigner;
+    windows = new Map();
+    watermark = Number.MIN_SAFE_INTEGER;
+    trigger = null;
+    lateDataHandler = null;
+    allowedLateness = 0;
+    triggerCallback = null;
+    keyExtractor = null;
+    metrics;
+    constructor(assigner, options) {
+        this.assigner = assigner;
+        this.metrics = options?.metrics ?? noopMetrics;
+    }
+    // -------------------------------------------------------------------------
+    // Static Factory Methods
+    // -------------------------------------------------------------------------
+    static tumbling(size) {
+        return new TumblingWindowAssigner(size);
+    }
+    static sliding(size, slide) {
+        return new SlidingWindowAssigner(size, slide);
+    }
+    static session(gap) {
+        return new SessionWindowAssigner(gap);
+    }
+    static global() {
+        return new GlobalWindowAssigner();
+    }
+    // -------------------------------------------------------------------------
+    // Configuration Methods
+    // -------------------------------------------------------------------------
+    withTrigger(trigger) {
+        this.trigger = trigger;
+        // Set up processing time trigger if applicable
+        if (trigger instanceof ProcessingTimeTrigger) {
+            trigger.setCallback(() => {
+                this.fireProcessingTimeTrigger();
+            });
+        }
+        return this;
+    }
+    withKeyExtractor(fn) {
+        this.keyExtractor = fn;
+        return this;
+    }
+    allowLateness(duration) {
+        this.allowedLateness = duration.toMillis();
+        return this;
+    }
+    sideOutputLate(handler) {
+        this.lateDataHandler = handler;
+        return this;
+    }
+    onTrigger(callback) {
+        this.triggerCallback = callback;
+    }
+    // -------------------------------------------------------------------------
+    // Core Methods
+    // -------------------------------------------------------------------------
+    getWindowKey(window) {
+        return `${window.start}-${window.end}-${window.key || ''}`;
+    }
+    assign(element, timestamp) {
+        const key = this.keyExtractor ? this.keyExtractor(element) : undefined;
+        if (this.assigner.type === 'session') {
+            return this.assigner.assignWindows(element, timestamp, key, this.windows);
+        }
+        const windows = this.assigner.assignWindows(element, timestamp, key);
+        if (key !== undefined) {
+            return windows.map((w) => ({ ...w, key }));
+        }
+        return windows;
+    }
+    process(element, timestamp) {
+        const start = performance.now();
+        try {
+            const key = this.keyExtractor ? this.keyExtractor(element) : undefined;
+            // Check if data is late (beyond watermark + allowed lateness)
+            if (this.assigner.type !== 'global' && this.assigner.type !== 'session') {
+                const windows = this.assign(element, timestamp);
+                for (const window of windows) {
+                    if (window.end <= this.watermark - this.allowedLateness) {
+                        // Data is too late
+                        this.metrics.incrementCounter(MetricNames.WINDOW_MANAGER_LATE_DATA);
+                        if (this.lateDataHandler) {
+                            this.lateDataHandler(element, window);
+                        }
+                        return;
+                    }
+                }
+            }
+            // For session windows, we need special handling
+            if (this.assigner.type === 'session') {
+                this.processSessionElement(element, timestamp, key);
+                this.metrics.incrementCounter(MetricNames.WINDOW_MANAGER_ELEMENTS_PROCESSED);
+                return;
+            }
+            const windows = this.assign(element, timestamp);
+            for (const window of windows) {
+                const windowKey = this.getWindowKey(window);
+                // Check if window is still accepting data (within allowed lateness)
+                if (window.end <= this.watermark) {
+                    // Window has been triggered, check if within allowed lateness
+                    if (window.end > this.watermark - this.allowedLateness) {
+                        // Re-trigger the window with the late element
+                        const existing = this.windows.get(windowKey);
+                        if (existing) {
+                            existing.elements.push(element);
+                            this.fireTrigger(existing);
+                        }
+                        else if (this.lateDataHandler) {
+                            this.metrics.incrementCounter(MetricNames.WINDOW_MANAGER_LATE_DATA);
+                            this.lateDataHandler(element, window);
+                        }
+                    }
+                    else if (this.lateDataHandler) {
+                        this.metrics.incrementCounter(MetricNames.WINDOW_MANAGER_LATE_DATA);
+                        this.lateDataHandler(element, window);
+                    }
+                    continue;
+                }
+                let windowData = this.windows.get(windowKey);
+                const isNewWindow = !windowData;
+                if (!windowData) {
+                    windowData = {
+                        window,
+                        elements: [],
+                        triggered: false,
+                        countSinceLastTrigger: 0,
+                    };
+                    this.windows.set(windowKey, windowData);
+                    this.metrics.incrementCounter(MetricNames.WINDOW_MANAGER_WINDOW_CREATED);
+                }
+                windowData.elements.push(element);
+                windowData.countSinceLastTrigger++;
+                // Check element trigger
+                if (this.trigger) {
+                    const ctx = {
+                        window: windowData.window,
+                        elements: windowData.elements,
+                        watermark: this.watermark,
+                        countSinceLastTrigger: windowData.countSinceLastTrigger,
+                    };
+                    const result = this.trigger.onElement(ctx);
+                    this.handleTriggerResult(result, windowData);
+                }
+            }
+            this.metrics.incrementCounter(MetricNames.WINDOW_MANAGER_ELEMENTS_PROCESSED);
+            this.metrics.recordGauge(MetricNames.WINDOW_MANAGER_ACTIVE_WINDOWS, this.windows.size);
+        }
+        finally {
+            this.metrics.recordLatency(MetricNames.WINDOW_MANAGER_PROCESS_LATENCY, performance.now() - start);
+        }
+    }
+    processSessionElement(element, timestamp, key) {
+        const gapMs = this.assigner.gap.toMillis();
+        // Find all windows that should be merged with this element
+        const windowsToMerge = [];
+        const newWindow = { start: timestamp, end: timestamp + gapMs, key };
+        for (const [windowKey, windowData] of this.windows) {
+            const w = windowData.window;
+            if (key !== undefined && w.key !== key)
+                continue;
+            // Check if windows should merge
+            if ((newWindow.start <= w.end && newWindow.end >= w.start) ||
+                Math.abs(newWindow.start - w.end) <= 0 ||
+                Math.abs(w.start - newWindow.end) <= 0) {
+                windowsToMerge.push(windowData);
+            }
+        }
+        if (windowsToMerge.length === 0) {
+            // Create new session window
+            const windowKey = this.getWindowKey(newWindow);
+            this.windows.set(windowKey, {
+                window: newWindow,
+                elements: [element],
+                triggered: false,
+                countSinceLastTrigger: 1,
+            });
+        }
+        else {
+            // Merge windows
+            const allElements = [element];
+            let mergedStart = timestamp;
+            let mergedEnd = timestamp + gapMs;
+            for (const wd of windowsToMerge) {
+                allElements.push(...wd.elements);
+                mergedStart = Math.min(mergedStart, wd.window.start);
+                mergedEnd = Math.max(mergedEnd, wd.window.end);
+                // Remove old window
+                this.windows.delete(this.getWindowKey(wd.window));
+            }
+            // Update merged end to be max timestamp + gap
+            const maxTimestamp = Math.max(timestamp, ...windowsToMerge.flatMap((wd) => 
+            // For simplicity, use window end - gap as approximate max timestamp
+            [wd.window.end - gapMs]));
+            mergedEnd = maxTimestamp + gapMs;
+            const mergedWindow = { start: mergedStart, end: mergedEnd, key };
+            const windowKey = this.getWindowKey(mergedWindow);
+            this.windows.set(windowKey, {
+                window: mergedWindow,
+                elements: allElements,
+                triggered: false,
+                countSinceLastTrigger: allElements.length,
+            });
+        }
+    }
+    advanceWatermark(timestamp) {
+        const start = performance.now();
+        try {
+            if (timestamp < this.watermark) {
+                throw new Error('Watermark cannot go backwards');
+            }
+            this.watermark = timestamp;
+            const triggeredWindows = [];
+            // Check watermark trigger for all windows
+            for (const [windowKey, windowData] of this.windows) {
+                if (windowData.triggered && this.assigner.type !== 'session')
+                    continue;
+                // For session windows, automatically trigger when watermark passes window end
+                if (this.assigner.type === 'session' && !windowData.triggered) {
+                    if (this.watermark >= windowData.window.end) {
+                        this.fireTrigger(windowData);
+                        windowData.triggered = true;
+                        triggeredWindows.push(windowData.window);
+                        this.metrics.incrementCounter(MetricNames.WINDOW_MANAGER_WINDOW_TRIGGERED);
+                        continue;
+                    }
+                }
+                if (this.trigger) {
+                    const ctx = {
+                        window: windowData.window,
+                        elements: windowData.elements,
+                        watermark: this.watermark,
+                        countSinceLastTrigger: windowData.countSinceLastTrigger,
+                    };
+                    const result = this.trigger.onWatermark(ctx);
+                    if (result === TriggerResult.FIRE || result === TriggerResult.FIRE_AND_PURGE) {
+                        this.fireTrigger(windowData);
+                        windowData.triggered = true;
+                        triggeredWindows.push(windowData.window);
+                        this.metrics.incrementCounter(MetricNames.WINDOW_MANAGER_WINDOW_TRIGGERED);
+                        if (result === TriggerResult.FIRE_AND_PURGE) {
+                            windowData.elements = [];
+                            windowData.countSinceLastTrigger = 0;
+                        }
+                    }
+                }
+            }
+            // Clean up old windows beyond allowed lateness
+            const windowCountBefore = this.windows.size;
+            this.cleanupOldWindows();
+            const windowsRemoved = windowCountBefore - this.windows.size;
+            if (windowsRemoved > 0) {
+                this.metrics.incrementCounter(MetricNames.WINDOW_MANAGER_WINDOW_CLOSED, undefined, windowsRemoved);
+            }
+            this.metrics.recordGauge(MetricNames.WINDOW_MANAGER_ACTIVE_WINDOWS, this.windows.size);
+            return triggeredWindows;
+        }
+        finally {
+            this.metrics.recordLatency(MetricNames.WINDOW_MANAGER_ADVANCE_WATERMARK_LATENCY, performance.now() - start);
+        }
+    }
+    cleanupOldWindows() {
+        const windowsToRemove = [];
+        for (const [windowKey, windowData] of this.windows) {
+            // Don't clean up global windows
+            if (this.assigner.type === 'global')
+                continue;
+            // Remove windows that are beyond watermark + allowed lateness
+            if (windowData.triggered &&
+                windowData.window.end <= this.watermark - this.allowedLateness) {
+                windowsToRemove.push(windowKey);
+            }
+        }
+        for (const key of windowsToRemove) {
+            this.windows.delete(key);
+        }
+    }
+    getCurrentWatermark() {
+        return this.watermark;
+    }
+    getWindowState(window) {
+        const windowKey = this.getWindowKey(window);
+        const windowData = this.windows.get(windowKey);
+        if (!windowData) {
+            return [];
+        }
+        // Return a copy
+        return [...windowData.elements];
+    }
+    clearWindow(window) {
+        const windowKey = this.getWindowKey(window);
+        const windowData = this.windows.get(windowKey);
+        if (windowData) {
+            windowData.elements = [];
+            windowData.countSinceLastTrigger = 0;
+        }
+    }
+    getActiveWindowCount() {
+        return this.windows.size;
+    }
+    /**
+     * Dispose of all resources held by this WindowManager.
+     * This MUST be called when the WindowManager is no longer needed to prevent
+     * memory leaks from interval timers (especially ProcessingTimeTrigger).
+     *
+     * After calling dispose():
+     * - All timers are cleared
+     * - All window state is cleared
+     * - The trigger callback is removed
+     * - The WindowManager should not be used again
+     */
+    dispose() {
+        // Clean up trigger (especially important for ProcessingTimeTrigger)
+        if (this.trigger) {
+            this.trigger.dispose();
+            this.trigger = null;
+        }
+        // Clear all window state
+        this.windows.clear();
+        // Clear callbacks
+        this.triggerCallback = null;
+        this.lateDataHandler = null;
+        this.keyExtractor = null;
+    }
+    // -------------------------------------------------------------------------
+    // Private Helpers
+    // -------------------------------------------------------------------------
+    fireTrigger(windowData) {
+        if (this.triggerCallback && windowData.elements.length > 0) {
+            this.triggerCallback(windowData.window, [...windowData.elements]);
+        }
+    }
+    handleTriggerResult(result, windowData) {
+        if (result === TriggerResult.FIRE) {
+            this.fireTrigger(windowData);
+            windowData.countSinceLastTrigger = 0;
+        }
+        else if (result === TriggerResult.FIRE_AND_PURGE) {
+            this.fireTrigger(windowData);
+            windowData.elements = [];
+            windowData.countSinceLastTrigger = 0;
+        }
+        else if (result === TriggerResult.PURGE) {
+            windowData.elements = [];
+            windowData.countSinceLastTrigger = 0;
+        }
+    }
+    fireProcessingTimeTrigger() {
+        for (const [_, windowData] of this.windows) {
+            if (this.trigger) {
+                const ctx = {
+                    window: windowData.window,
+                    elements: windowData.elements,
+                    watermark: this.watermark,
+                    countSinceLastTrigger: windowData.countSinceLastTrigger,
+                };
+                const result = this.trigger.onProcessingTime(ctx);
+                this.handleTriggerResult(result, windowData);
+            }
+        }
+    }
+}
+//# sourceMappingURL=window-manager.js.map