@gxpl/sdk 0.0.7 → 0.0.8

package/lib/sdk-nextjs/utils/Animator/Animator.js

@@ -0,0 +1,443 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Animator = void 0;
+const color_1 = require("@cntrl-site/color");
+const binSearchInsertAt_1 = require("../binSearchInsertAt");
+const rangeMap_1 = require("../rangeMap");
+const Keyframe_1 = require("../../../sdk/types/keyframe/Keyframe");
+const compare = (lhs, rhs) => lhs.position - rhs.position;
+const insertBin = (0, binSearchInsertAt_1.createInsert)(binSearchInsertAt_1.binSearchInsertAt, compare);
+class Animator {
+    static pushKeyframeToMap(keyframe, map) {
+        insertBin(map[keyframe.type], keyframe);
+    }
+    constructor(keyframes) {
+        this.keyframes = keyframes;
+        this.keyframesMap = createKeyframesMap();
+        this.fillKeyframesMap();
+    }
+    getFXParams(valuesMap, pos) {
+        const keyframes = this.keyframesMap[Keyframe_1.KeyframeType.FXParams];
+        if (!keyframes.length)
+            return valuesMap;
+        if (keyframes.length === 1) {
+            const [keyframe] = keyframes;
+            return Object.entries(valuesMap).reduce((acc, [key, fallbackValue]) => {
+                var _a;
+                acc[key] = (_a = keyframe.value[key]) !== null && _a !== void 0 ? _a : fallbackValue;
+                return acc;
+            }, {});
+        }
+        const { start, end } = this.getStartEnd(pos, keyframes);
+        return Object.entries(valuesMap).reduce((acc, [key, fallbackValue]) => {
+            var _a, _b;
+            acc[key] = (0, rangeMap_1.rangeMap)(pos, start.position, end.position, (_a = start.value[key]) !== null && _a !== void 0 ? _a : fallbackValue, (_b = end.value[key]) !== null && _b !== void 0 ? _b : fallbackValue, true);
+            return acc;
+        }, {});
+    }
+    getDimensions(values, pos) {
+        const keyframes = this.keyframesMap[Keyframe_1.KeyframeType.Dimensions];
+        if (!keyframes || !keyframes.length)
+            return values;
+        if (keyframes.length === 1) {
+            const [keyframe] = keyframes;
+            return {
+                width: keyframe.value.width,
+                height: keyframe.value.height
+            };
+        }
+        const { start, end } = this.getStartEnd(pos, keyframes);
+        return {
+            width: (0, rangeMap_1.rangeMap)(pos, start.position, end.position, start.value.width, end.value.width, true),
+            height: (0, rangeMap_1.rangeMap)(pos, start.position, end.position, start.value.height, end.value.height, true)
+        };
+    }
+    getPositions(values, pos) {
+        const keyframes = this.keyframesMap[Keyframe_1.KeyframeType.Position];
+        if (!keyframes || !keyframes.length)
+            return values;
+        if (keyframes.length === 1) {
+            const [keyframe] = keyframes;
+            return {
+                left: keyframe.value.left,
+                top: keyframe.value.top
+            };
+        }
+        const { start, end } = this.getStartEnd(pos, keyframes);
+        return {
+            left: (0, rangeMap_1.rangeMap)(pos, start.position, end.position, start.value.left, end.value.left, true),
+            top: (0, rangeMap_1.rangeMap)(pos, start.position, end.position, start.value.top, end.value.top, true)
+        };
+    }
+    getBorderFill(values, pos) {
+        const keyframes = this.keyframesMap[Keyframe_1.KeyframeType.BorderFill];
+        if (!keyframes || !keyframes.length)
+            return values;
+        if (keyframes.length === 1) {
+            const [keyframe] = keyframes;
+            return keyframe.value;
+        }
+        const { start, end } = this.getStartEnd(pos, keyframes);
+        return this.getRangeGradient(start, end, pos);
+    }
+    getFill(values, pos) {
+        const keyframes = this.keyframesMap[Keyframe_1.KeyframeType.Fill];
+        if (!keyframes || !keyframes.length)
+            return values;
+        if (keyframes.length === 1) {
+            const [keyframe] = keyframes;
+            return keyframe.value;
+        }
+        const { start, end } = this.getStartEnd(pos, keyframes);
+        return this.getRangeGradient(start, end, pos);
+    }
+    getRadius(values, pos) {
+        const keyframes = this.keyframesMap[Keyframe_1.KeyframeType.BorderRadius];
+        if (!keyframes || !keyframes.length)
+            return values;
+        if (keyframes.length === 1) {
+            const [keyframe] = keyframes;
+            return {
+                radius: keyframe.value.radius
+            };
+        }
+        const { start, end } = this.getStartEnd(pos, keyframes);
+        return {
+            radius: (0, rangeMap_1.rangeMap)(pos, start.position, end.position, start.value.radius, end.value.radius, true)
+        };
+    }
+    getBorderWidth(values, pos) {
+        const keyframes = this.keyframesMap[Keyframe_1.KeyframeType.BorderWidth];
+        if (!keyframes || !keyframes.length)
+            return values;
+        if (keyframes.length === 1) {
+            const [keyframe] = keyframes;
+            return {
+                borderWidth: keyframe.value.borderWidth
+            };
+        }
+        const { start, end } = this.getStartEnd(pos, keyframes);
+        return {
+            borderWidth: (0, rangeMap_1.rangeMap)(pos, start.position, end.position, start.value.borderWidth, end.value.borderWidth, true)
+        };
+    }
+    getRotation(values, pos) {
+        const keyframes = this.keyframesMap[Keyframe_1.KeyframeType.Rotation];
+        if (!keyframes || !keyframes.length)
+            return values;
+        if (keyframes.length === 1) {
+            const [keyframe] = keyframes;
+            return {
+                angle: keyframe.value.angle
+            };
+        }
+        const { start, end } = this.getStartEnd(pos, keyframes);
+        return {
+            angle: (0, rangeMap_1.rangeMap)(pos, start.position, end.position, start.value.angle, end.value.angle, true)
+        };
+    }
+    getOpacity(values, pos) {
+        const keyframes = this.keyframesMap[Keyframe_1.KeyframeType.Opacity];
+        if (!keyframes || !keyframes.length)
+            return values;
+        if (keyframes.length === 1) {
+            const [keyframe] = keyframes;
+            return {
+                opacity: keyframe.value.opacity
+            };
+        }
+        const { start, end } = this.getStartEnd(pos, keyframes);
+        return {
+            opacity: (0, rangeMap_1.rangeMap)(pos, start.position, end.position, start.value.opacity, end.value.opacity, true)
+        };
+    }
+    getScale(values, pos) {
+        const keyframes = this.keyframesMap[Keyframe_1.KeyframeType.Scale];
+        if (!keyframes || !keyframes.length)
+            return values;
+        if (keyframes.length === 1) {
+            const [keyframe] = keyframes;
+            return {
+                scale: keyframe.value.scale
+            };
+        }
+        const { start, end } = this.getStartEnd(pos, keyframes);
+        return {
+            scale: (0, rangeMap_1.rangeMap)(pos, start.position, end.position, start.value.scale, end.value.scale, true)
+        };
+    }
+    getBlur(values, pos) {
+        const keyframes = this.keyframesMap[Keyframe_1.KeyframeType.Blur];
+        if (!keyframes || !keyframes.length)
+            return values;
+        if (keyframes.length === 1) {
+            const [keyframe] = keyframes;
+            return {
+                blur: keyframe.value.blur
+            };
+        }
+        const { start, end } = this.getStartEnd(pos, keyframes);
+        return {
+            blur: (0, rangeMap_1.rangeMap)(pos, start.position, end.position, start.value.blur, end.value.blur, true)
+        };
+    }
+    getBackdropBlur(values, pos) {
+        const keyframes = this.keyframesMap[Keyframe_1.KeyframeType.BackdropBlur];
+        if (!keyframes || !keyframes.length)
+            return values;
+        if (keyframes.length === 1) {
+            const [keyframe] = keyframes;
+            return {
+                backdropBlur: keyframe.value.backdropBlur
+            };
+        }
+        const { start, end } = this.getStartEnd(pos, keyframes);
+        return {
+            backdropBlur: (0, rangeMap_1.rangeMap)(pos, start.position, end.position, start.value.backdropBlur, end.value.backdropBlur, true)
+        };
+    }
+    getTextColor(values, pos) {
+        const keyframes = this.keyframesMap[Keyframe_1.KeyframeType.TextColor];
+        if (!keyframes || !keyframes.length)
+            return values;
+        if (keyframes.length === 1) {
+            const [keyframe] = keyframes;
+            return {
+                color: keyframe.value.color
+            };
+        }
+        const { start, end } = this.getStartEnd(pos, keyframes);
+        return {
+            color: this.getRangeColor(start, end, pos)
+        };
+    }
+    getLetterSpacing(values, pos) {
+        const keyframes = this.keyframesMap[Keyframe_1.KeyframeType.LetterSpacing];
+        if (!keyframes || !keyframes.length)
+            return values;
+        if (keyframes.length === 1) {
+            const [keyframe] = keyframes;
+            return {
+                letterSpacing: keyframe.value.letterSpacing
+            };
+        }
+        const { start, end } = this.getStartEnd(pos, keyframes);
+        return {
+            letterSpacing: (0, rangeMap_1.rangeMap)(pos, start.position, end.position, start.value.letterSpacing, end.value.letterSpacing, true)
+        };
+    }
+    getWordSpacing(values, pos) {
+        const keyframes = this.keyframesMap[Keyframe_1.KeyframeType.WordSpacing];
+        if (!keyframes || !keyframes.length)
+            return values;
+        if (keyframes.length === 1) {
+            const [keyframe] = keyframes;
+            return {
+                wordSpacing: keyframe.value.wordSpacing
+            };
+        }
+        const { start, end } = this.getStartEnd(pos, keyframes);
+        return {
+            wordSpacing: (0, rangeMap_1.rangeMap)(pos, start.position, end.position, start.value.wordSpacing, end.value.wordSpacing, true)
+        };
+    }
+    getStartEnd(position, keyframes) {
+        const index = (0, binSearchInsertAt_1.binSearchInsertAt)(keyframes, { position }, compare);
+        const end = index === keyframes.length ? index - 1 : index;
+        const start = end === 0 ? end : end - 1;
+        return { start: keyframes[start], end: keyframes[end] };
+    }
+    fillKeyframesMap() {
+        this.keyframesMap = createKeyframesMap();
+        for (const keyframe of this.keyframes) {
+            Animator.pushKeyframeToMap(keyframe, this.keyframesMap);
+        }
+    }
+    getRangeColor(start, end, position) {
+        const rangeAmount = (0, rangeMap_1.rangeMap)(position, start.position, end.position, 0, 1, true);
+        const startColor = color_1.CntrlColor.parse(start.value.color);
+        const endColor = color_1.CntrlColor.parse(end.value.color);
+        const mixedColor = startColor.mix(endColor, rangeAmount);
+        return mixedColor.fmt('oklch');
+    }
+    getRangeGradient(start, end, position) {
+        const rangeAmount = (0, rangeMap_1.rangeMap)(position, start.position, end.position, 0, 1, true);
+        const allLayerIds = new Set([
+            ...start.value.map(layer => layer.id),
+            ...end.value.map(layer => layer.id)
+        ]);
+        const result = [];
+        for (const layerId of allLayerIds) {
+            const startLayers = start.value.find(layer => layer.id === layerId);
+            const endLayers = end.value.find(layer => layer.id === layerId);
+            const startLayersArray = Array.isArray(startLayers) ? startLayers : startLayers ? [startLayers] : [];
+            const endLayersArray = Array.isArray(endLayers) ? endLayers : endLayers ? [endLayers] : [];
+            if (startLayersArray.length > 0 && endLayersArray.length === 0) {
+                result.push(...startLayersArray);
+                continue;
+            }
+            if (startLayersArray.length === 0 && endLayersArray.length > 0) {
+                result.push(...endLayersArray);
+                continue;
+            }
+            if (startLayersArray.length > 0 && endLayersArray.length > 0) {
+                result.push(...this.interpolateFillLayerArray(startLayersArray, endLayersArray, rangeAmount));
+            }
+        }
+        return result;
+    }
+    interpolateFillLayerArray(startLayers, endLayers, rangeAmount) {
+        const startLayerMap = new Map(startLayers.map(layer => [layer.id, layer]));
+        const endLayerMap = new Map(endLayers.map(layer => [layer.id, layer]));
+        const allLayerIds = new Set([
+            ...startLayers.map(layer => layer.id),
+            ...endLayers.map(layer => layer.id)
+        ]);
+        const interpolatedLayers = [];
+        for (const layerId of allLayerIds) {
+            const startLayer = startLayerMap.get(layerId);
+            const endLayer = endLayerMap.get(layerId);
+            if (startLayer && !endLayer) {
+                interpolatedLayers.push(startLayer);
+                continue;
+            }
+            if (!startLayer && endLayer) {
+                interpolatedLayers.push(endLayer);
+                continue;
+            }
+            if (startLayer && endLayer) {
+                interpolatedLayers.push(this.interpolateFillLayer(startLayer, endLayer, rangeAmount));
+            }
+        }
+        const result = [];
+        for (const startLayer of startLayers) {
+            const interpolatedLayer = interpolatedLayers.find(layer => layer.id === startLayer.id);
+            if (interpolatedLayer) {
+                result.push(interpolatedLayer);
+            }
+        }
+        for (const endLayer of endLayers) {
+            if (!startLayerMap.has(endLayer.id)) {
+                const interpolatedLayer = interpolatedLayers.find(layer => layer.id === endLayer.id);
+                if (interpolatedLayer) {
+                    result.push(interpolatedLayer);
+                }
+            }
+        }
+        return result;
+    }
+    interpolateFillLayer(startLayer, endLayer, rangeAmount) {
+        if (startLayer.type !== endLayer.type) {
+            return startLayer;
+        }
+        switch (startLayer.type) {
+            case 'solid': {
+                const endSolidLayer = endLayer;
+                const startColor = color_1.CntrlColor.parse(startLayer.value);
+                const endColor = color_1.CntrlColor.parse(endSolidLayer.value);
+                const mixedColor = startColor.mix(endColor, rangeAmount);
+                return Object.assign(Object.assign({}, startLayer), { value: mixedColor.fmt('oklch') });
+            }
+            case 'linear-gradient': {
+                const endLinearLayer = endLayer;
+                const interpolatedColors = this.interpolateColorStops(startLayer.colors, endLinearLayer.colors, rangeAmount);
+                const angle = startLayer.angle + (endLinearLayer.angle - startLayer.angle) * rangeAmount;
+                const startPoint = [
+                    startLayer.start[0] + (endLinearLayer.start[0] - startLayer.start[0]) * rangeAmount,
+                    startLayer.start[1] + (endLinearLayer.start[1] - startLayer.start[1]) * rangeAmount
+                ];
+                const endPoint = [
+                    startLayer.end[0] + (endLinearLayer.end[0] - startLayer.end[0]) * rangeAmount,
+                    startLayer.end[1] + (endLinearLayer.end[1] - startLayer.end[1]) * rangeAmount
+                ];
+                return Object.assign(Object.assign({}, startLayer), { colors: interpolatedColors, angle, start: startPoint, end: endPoint });
+            }
+            case 'radial-gradient': {
+                const endRadialLayer = endLayer;
+                const interpolatedColors = this.interpolateColorStops(startLayer.colors, endRadialLayer.colors, rangeAmount);
+                const angle = startLayer.angle + (endRadialLayer.angle - startLayer.angle) * rangeAmount;
+                const center = [
+                    startLayer.center[0] + (endRadialLayer.center[0] - startLayer.center[0]) * rangeAmount,
+                    startLayer.center[1] + (endRadialLayer.center[1] - startLayer.center[1]) * rangeAmount
+                ];
+                const diameter = startLayer.diameter + (endRadialLayer.diameter - startLayer.diameter) * rangeAmount;
+                return Object.assign(Object.assign({}, startLayer), { colors: interpolatedColors, angle,
+                    center,
+                    diameter });
+            }
+            case 'conic-gradient': {
+                const endConicLayer = endLayer;
+                const interpolatedColors = this.interpolateColorStops(startLayer.colors, endConicLayer.colors, rangeAmount);
+                const angle = startLayer.angle + (endConicLayer.angle - startLayer.angle) * rangeAmount;
+                const center = [
+                    startLayer.center[0] + (endConicLayer.center[0] - startLayer.center[0]) * rangeAmount,
+                    startLayer.center[1] + (endConicLayer.center[1] - startLayer.center[1]) * rangeAmount
+                ];
+                return Object.assign(Object.assign({}, startLayer), { colors: interpolatedColors, angle,
+                    center });
+            }
+            case 'image': {
+                const endImageLayer = endLayer;
+                const opacity = startLayer.opacity + (endImageLayer.opacity - startLayer.opacity) * rangeAmount;
+                const backgroundSize = startLayer.backgroundSize + (endImageLayer.backgroundSize - startLayer.backgroundSize) * rangeAmount;
+                return Object.assign(Object.assign({}, startLayer), { opacity,
+                    backgroundSize });
+            }
+            default:
+                return startLayer;
+        }
+    }
+    interpolateColorStops(startColors, endColors, rangeAmount) {
+        const startColorMap = new Map(startColors.map(stop => [stop.id, stop]));
+        const endColorMap = new Map(endColors.map(stop => [stop.id, stop]));
+        const allStopIds = new Set([
+            ...startColors.map(stop => stop.id),
+            ...endColors.map(stop => stop.id)
+        ]);
+        const interpolatedStops = [];
+        for (const stopId of allStopIds) {
+            const startStop = startColorMap.get(stopId);
+            const endStop = endColorMap.get(stopId);
+            if (startStop && !endStop) {
+                interpolatedStops.push(startStop);
+                continue;
+            }
+            if (!startStop && endStop) {
+                interpolatedStops.push(endStop);
+                continue;
+            }
+            if (startStop && endStop) {
+                const startColor = color_1.CntrlColor.parse(startStop.value);
+                const endColor = color_1.CntrlColor.parse(endStop.value);
+                const mixedColor = startColor.mix(endColor, rangeAmount);
+                const position = startStop.position + (endStop.position - startStop.position) * rangeAmount;
+                interpolatedStops.push({
+                    id: stopId,
+                    value: mixedColor.fmt('oklch'),
+                    position
+                });
+            }
+        }
+        return interpolatedStops.sort((a, b) => a.position - b.position);
+    }
+}
+exports.Animator = Animator;
+function createKeyframesMap() {
+    return {
+        [Keyframe_1.KeyframeType.Dimensions]: [],
+        [Keyframe_1.KeyframeType.Position]: [],
+        [Keyframe_1.KeyframeType.BorderWidth]: [],
+        [Keyframe_1.KeyframeType.BorderRadius]: [],
+        [Keyframe_1.KeyframeType.Rotation]: [],
+        [Keyframe_1.KeyframeType.BorderFill]: [],
+        [Keyframe_1.KeyframeType.Opacity]: [],
+        [Keyframe_1.KeyframeType.Scale]: [],
+        [Keyframe_1.KeyframeType.Blur]: [],
+        [Keyframe_1.KeyframeType.BackdropBlur]: [],
+        [Keyframe_1.KeyframeType.LetterSpacing]: [],
+        [Keyframe_1.KeyframeType.WordSpacing]: [],
+        [Keyframe_1.KeyframeType.TextColor]: [],
+        [Keyframe_1.KeyframeType.FXParams]: [],
+        [Keyframe_1.KeyframeType.Fill]: []
+    };
+}

package/lib/sdk-nextjs/utils/ArticleRectManager/ArticleRectObserver.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArticleRectObserver = void 0;
+const EventEmitter_1 = require("../EventEmitter");
+const resize_observer_polyfill_1 = __importDefault(require("resize-observer-polyfill"));
+class ArticleRectObserver extends EventEmitter_1.EventEmitter {
+    constructor() {
+        super();
+        this.articleWidth = 0;
+        this.registry = new Map();
+        this.scrollPos = window.scrollY;
+        this.animationFrame = NaN;
+        this.parent = undefined;
+        this.sectionsScrollMap = new Map();
+        this.handleScroll = (scroll) => {
+            this.setScroll(scroll / this.articleWidth);
+        };
+        this.resizeObserver = new resize_observer_polyfill_1.default(this.handleResize.bind(this));
+    }
+    get scroll() {
+        return this.scrollPos;
+    }
+    getSectionScroll(sectionId) {
+        const sectionTop = this.sectionsScrollMap.get(sectionId);
+        if (sectionTop === undefined)
+            return 0;
+        return -(sectionTop / this.articleWidth - this.scrollPos);
+    }
+    getSectionTop(sectionId) {
+        const sectionTop = this.sectionsScrollMap.get(sectionId);
+        return sectionTop !== null && sectionTop !== void 0 ? sectionTop : 0;
+    }
+    get width() {
+        return this.articleWidth;
+    }
+    setScroll(scroll) {
+        this.scrollPos = scroll;
+    }
+    init(parent) {
+        this.parent = parent;
+        const onScroll = () => {
+            this.handleScroll(window.scrollY);
+            if (!isNaN(this.animationFrame))
+                return;
+            this.animationFrame = window.requestAnimationFrame(() => {
+                this.animationFrame = NaN;
+                this.emit('scroll', undefined);
+            });
+        };
+        window.addEventListener('scroll', onScroll);
+        return () => {
+            this.parent = undefined;
+            window.removeEventListener('scroll', onScroll);
+            if (!isNaN(this.animationFrame)) {
+                window.cancelAnimationFrame(this.animationFrame);
+                this.animationFrame = NaN;
+            }
+        };
+    }
+    register(el, sectionId) {
+        this.registry.set(sectionId, el);
+        this.resizeObserver.observe(el);
+        return () => {
+            this.registry.delete(sectionId);
+            this.resizeObserver.unobserve(el);
+        };
+    }
+    handleResize() {
+        if (!this.parent)
+            return;
+        const parentBoundary = this.parent.getBoundingClientRect();
+        this.articleWidth = parentBoundary.width;
+        this.setScroll(window.scrollY / this.articleWidth);
+        this.emit('resize', parentBoundary);
+        for (const sectionId of this.registry.keys()) {
+            const el = this.registry.get(sectionId);
+            if (!el)
+                continue;
+            const rect = el.getBoundingClientRect();
+            this.sectionsScrollMap.set(sectionId, rect.top - parentBoundary.top);
+        }
+    }
+    ;
+}
+exports.ArticleRectObserver = ArticleRectObserver;

package/lib/sdk-nextjs/utils/ArticleRectManager/useArticleRectObserver.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useArticleRectObserver = void 0;
+const react_1 = require("react");
+const ArticleRectObserver_1 = require("./ArticleRectObserver");
+const useArticleRectObserver = (el) => {
+    const [articleRectObserver, setArticleRectObserver] = (0, react_1.useState)(null);
+    (0, react_1.useEffect)(() => {
+        setArticleRectObserver(new ArticleRectObserver_1.ArticleRectObserver());
+    }, []);
+    (0, react_1.useEffect)(() => {
+        if (!el || !articleRectObserver)
+            return;
+        return articleRectObserver.init(el);
+    }, [el, articleRectObserver]);
+    return articleRectObserver;
+};
+exports.useArticleRectObserver = useArticleRectObserver;

package/lib/sdk-nextjs/utils/ArticleRectManager/useSectionRegistry.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSectionRegistry = void 0;
+const react_1 = require("react");
+const ArticleRectContext_1 = require("../../provider/ArticleRectContext");
+const useSectionRegistry = (sectionId, el) => {
+    const articleRectObserver = (0, react_1.useContext)(ArticleRectContext_1.ArticleRectContext);
+    (0, react_1.useEffect)(() => {
+        if (!el || !articleRectObserver)
+            return;
+        return articleRectObserver.register(el, sectionId);
+    }, [el, articleRectObserver]);
+};
+exports.useSectionRegistry = useSectionRegistry;

package/lib/sdk-nextjs/utils/EventEmitter.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventEmitter = void 0;
+class EventEmitter {
+    constructor() {
+        this.listeners = {};
+    }
+    on(event, listener) {
+        var _a;
+        if (!Array.isArray(this.listeners[event])) {
+            this.listeners[event] = [];
+        }
+        (_a = this.listeners[event]) === null || _a === void 0 ? void 0 : _a.push(listener);
+        return () => {
+            this.off(event, listener);
+        };
+    }
+    off(event, listener) {
+        var _a;
+        const filtered = (_a = this.listeners[event]) === null || _a === void 0 ? void 0 : _a.filter(l => l !== listener);
+        this.listeners[event] = filtered && filtered.length > 0 ? filtered : undefined;
+    }
+    emit(event, payload) {
+        const listeners = this.listeners[event];
+        if (!Array.isArray(listeners))
+            return;
+        for (const listener of listeners) {
+            try {
+                listener(payload);
+            }
+            catch (error) {
+                console.error(error instanceof Error ? error.stack : error);
+            }
+        }
+    }
+}
+exports.EventEmitter = EventEmitter;