@esmalley/ts-utils 1.0.0

package/dist/Dates.js

@@ -0,0 +1,354 @@
+/* eslint-disable one-var-declaration-per-line */
+/* eslint-disable one-var */
+export class Dates {
+    // constructor() {
+    // }
+    /*
+     * Robust Date Parsing
+     * Handles:
+     * - Date Objects / Numbers (Timestamps)
+     * - ISO Strings (2025-01-01) -> Forces Local Midnight
+     * - US Formats (01/05/2026)
+     * - Mixed Time Formats (23:00 pm, 5:00pm, 14:30:00)
+     */
+    static parse(str, utc = false) {
+        // 1. Handle Null / Undefined -> Return Now
+        if (!str) {
+            return new Date();
+        }
+        // 2. Handle Existing Date Objects -> Return Copy
+        if (str instanceof Date) {
+            return new Date(str.getTime());
+        }
+        // 3. Handle Timestamps (Numbers)
+        if (typeof str === 'number') {
+            return new Date(str);
+        }
+        // 4. Handle Strings
+        if (typeof str === 'string') {
+            const input = str.trim();
+            // CASE A: Strict ISO Date "YYYY-MM-DD"
+            // Native JS parses this as UTC Midnight, which often shows as
+            // previous day 7pm EST. We force "T00:00:00" to make it Local Midnight.
+            if (/^\d{4}-\d{2}-\d{2}$/.test(input)) {
+                return new Date(`${input}T00:00:00`);
+            }
+            // CASE B: Manual Parsing for Complex Strings
+            // This handles "2026-01-05 23:03:19 pm", "01/05/2026", etc.
+            // Step 1: Extract Date Part (YYYY-MM-DD or MM/DD/YYYY)
+            // Regex looks for: (Group 1: Year/Month) -or/ (Group 2: Month/Day) -or/ (Group 3: Day/Year)
+            let year, month, day, timePart = '';
+            // Match YYYY-MM-DD or YYYY/MM/DD
+            const isoMatch = input.match(/^(\d{4})[-/](\d{1,2})[-/](\d{1,2})(.*)$/);
+            // Match MM/DD/YYYY or MM-DD-YYYY
+            const usMatch = input.match(/^(\d{1,2})[-/](\d{1,2})[-/](\d{4})(.*)$/);
+            if (isoMatch) {
+                year = parseInt(isoMatch[1], 10);
+                month = parseInt(isoMatch[2], 10) - 1; // JS Months are 0-11
+                day = parseInt(isoMatch[3], 10);
+                timePart = isoMatch[4];
+            }
+            else if (usMatch) {
+                year = parseInt(usMatch[3], 10);
+                month = parseInt(usMatch[1], 10) - 1;
+                day = parseInt(usMatch[2], 10);
+                timePart = usMatch[4];
+            }
+            else {
+                // Fallback: Let the browser try its best if our regex fails
+                const d = new Date(input);
+                return isNaN(d.getTime()) ? new Date() : d;
+            }
+            // Step 2: Extract Time Part
+            let hours = 0;
+            let minutes = 0;
+            let seconds = 0;
+            // Look for HH:MM(:SS) and optional AM/PM in the remaining string
+            if (timePart && timePart.trim().length > 0) {
+                // Matches: 23:03, 23:03:19, 5:00pm, 5:00 pm
+                const timeMatch = timePart.match(/(\d{1,2}):(\d{1,2})(?::(\d{1,2}))?\s*(am|pm|AM|PM)?/);
+                if (timeMatch) {
+                    hours = parseInt(timeMatch[1], 10);
+                    minutes = parseInt(timeMatch[2], 10);
+                    seconds = timeMatch[3] ? parseInt(timeMatch[3], 10) : 0;
+                    const meridiem = timeMatch[4] ? timeMatch[4].toLowerCase() : null;
+                    // Step 3: Normalize Hours (12h to 24h)
+                    if (meridiem === 'pm' && hours < 12) {
+                        hours += 12;
+                    }
+                    if (meridiem === 'am' && hours === 12) {
+                        hours = 0;
+                    }
+                    // Note: If input is "23:00 pm", we ignore the 'pm' because 23 > 12.
+                }
+            }
+            if (utc) {
+                return new Date(Date.UTC(year, month, day, hours, minutes, seconds));
+            }
+            // Step 4: Construct Date in Local Time
+            return new Date(year, month, day, hours, minutes, seconds);
+        }
+        return new Date();
+    }
+    static utc(date) {
+        const d = this.parse(date);
+        return new Date(d.getTime() + (d.getTimezoneOffset() * 60000));
+    }
+    static getMonthsShort() {
+        return ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+    }
+    static getMonths() {
+        return ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
+    }
+    static getDaysShort() {
+        return ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+    }
+    static getDays() {
+        return ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+    }
+    /**
+     * Format a date using php syntax
+     *
+      | Token | Meaning                   | Example |
+      | ----- | ------------------------- | ------- |
+      | `Y`   | 4-digit year              | 2025    |
+      | `y`   | 2-digit year              | 25      |
+      | `m`   | 2-digit month             | 03      |
+      | `n`   | month (no leading zero)   | 3       |
+      | `d`   | day (2-digit)             | 09      |
+      | `j`   | day (no leading zero)     | 9       |
+      | `S`   | Ordinal suffix            | th      |
+      | `H`   | 24-hour                   | 14      |
+      | `G`   | 24-hour (no leading zero) | 14      |
+      | `h`   | 12-hour                   | 02      |
+      | `g`   | 12-hour (no leading zero) | 2       |
+      | `i`   | minutes                   | 05      |
+      | `s`   | seconds                   | 09      |
+      | `A`   | AM/PM                     | PM      |
+      | `a`   | am/pm                     | pm      |
+      | `w`   | day of week (0–6)         | 1       |
+      | `N`   | day of week (1–7)         | 2       |
+      | `M`   | short month name          | Mar     |
+      | `F`   | full month name           | March   |
+      | `D`   | short weekday             | Mon     |
+      | `l`   | full weekday              | Monday  |
+     */
+    static format(dateInput, format) {
+        const date = this.parse(dateInput);
+        const pad = (n) => String(n).padStart(2, '0');
+        const monthsShort = this.getMonthsShort();
+        const monthsLong = this.getMonths();
+        const daysShort = this.getDaysShort();
+        const daysLong = this.getDays();
+        /*
+        const Y = date.getUTCFullYear();
+        const y = String(Y).slice(-2);
+        const month = date.getUTCMonth(); // 0-11
+        const dateNum = date.getUTCDate(); // 1-31
+        const day = date.getUTCDay(); // 0-6, Sun = 0
+        const hours = date.getUTCHours(); // 0-23
+        const minutes = date.getUTCMinutes();
+        const seconds = date.getUTCSeconds();
+        */
+        const Y = date.getFullYear();
+        const y = String(Y).slice(-2);
+        const month = date.getMonth(); // 0-11
+        const dateNum = date.getDate(); // 1-31
+        const day = date.getDay(); // 0-6, Sun = 0
+        const hours = date.getHours(); // 0-23
+        const minutes = date.getMinutes();
+        const seconds = date.getSeconds();
+        // Logic for ordinal suffix (st, nd, rd, th)
+        const getOrdinalSuffix = (n) => {
+            const v = n % 100;
+            // 11th, 12th, 13th are exceptions to the 1st, 2nd, 3rd rule
+            if (v >= 11 && v <= 13) {
+                return 'th';
+            }
+            switch (n % 10) {
+                case 1: {
+                    return 'st';
+                }
+                case 2: {
+                    return 'nd';
+                }
+                case 3: {
+                    return 'rd';
+                }
+                default: {
+                    return 'th';
+                }
+            }
+        };
+        const tokens = {
+            /// Year
+            Y: String(Y),
+            y,
+            // Month
+            m: pad(month + 1),
+            n: String(month + 1),
+            M: monthsShort[month],
+            F: monthsLong[month],
+            // Day
+            d: pad(dateNum),
+            j: String(dateNum),
+            D: daysShort[day],
+            l: daysLong[day],
+            w: String(day), // 0 (Sun) - 6
+            N: String(day === 0 ? 7 : day), // 1 (Mon) - 7 (Sun)
+            S: getOrdinalSuffix(dateNum),
+            // Time
+            H: pad(hours),
+            G: String(hours),
+            h: pad(((hours + 11) % 12) + 1),
+            g: String(((hours + 11) % 12) + 1),
+            i: pad(minutes),
+            s: pad(seconds),
+            // AM/PM
+            A: hours < 12 ? 'AM' : 'PM',
+            a: hours < 12 ? 'am' : 'pm',
+        };
+        // Replace tokens using regex
+        return format.replace(/\\(.)|([a-zA-Z])/g, (_, esc, token) => {
+            if (esc) {
+                // literal escaped char like \H or \Y → return the raw letter
+                return esc;
+            }
+            return tokens[token] ?? token;
+        });
+    }
+    static add(date, amount, unit) {
+        const d = this.parse(date);
+        if (unit === 'years') {
+            const originalDay = d.getDate();
+            d.setFullYear(d.getFullYear() + amount);
+            // Handle Leap Year Rollover:
+            // Feb 29, 2024 + 1 year -> Mar 1, 2025 (Standard JS behavior)
+            // If strict "same day or last day of month" logic is desired (turning it into Feb 28):
+            if (d.getDate() !== originalDay) {
+                d.setDate(0); // Set to last day of previous month (Feb 28)
+            }
+        }
+        else if (unit === 'months') {
+            const originalDay = d.getDate();
+            d.setMonth(d.getMonth() + amount);
+            // Handle rollover: Jan 31 + 1 month -> Feb 28/29
+            if (d.getDate() !== originalDay) {
+                d.setDate(0); // Set to last day of previous month
+            }
+        }
+        else if (unit === 'days') {
+            // Use setDate to be DST safe (24h addition via ms is unsafe across DST)
+            d.setDate(d.getDate() + amount);
+        }
+        else {
+            const map = {
+                hours: amount * 60 * 60 * 1000,
+                minutes: amount * 60 * 1000,
+            };
+            // Use getTime() for day/hour/minute units for simple millisecond addition
+            d.setTime(d.getTime() + map[unit]);
+        }
+        return d;
+    }
+    static subtract(date, amount, unit) {
+        return this.add(date, -amount, unit);
+    }
+    static fromNow(date) {
+        const d = this.parse(date);
+        const diff = Date.now() - d.getTime();
+        const mins = Math.floor(diff / 60000);
+        if (Math.abs(mins) < 1) {
+            return 'just now';
+        }
+        // Handle future dates roughly
+        if (mins < 0) {
+            return 'in the future';
+        }
+        if (mins < 60) {
+            return `${mins}m ago`;
+        }
+        const hours = Math.floor(mins / 60);
+        if (hours < 24) {
+            return `${hours}h ago`;
+        }
+        const days = Math.floor(hours / 24);
+        return `${days}d ago`;
+    }
+    /**
+     * Find the closest date in an array of dates
+     */
+    static getClosestDate(dateToMatch, datesArray) {
+        if (!datesArray.length) {
+            return null;
+        }
+        const matchDate = this.parse(dateToMatch).getTime();
+        let closestDate = null;
+        let closestDist = Infinity;
+        // eslint-disable-next-line no-restricted-syntax
+        for (const dateStr of datesArray) {
+            const currDate = this.parse(dateStr).getTime();
+            const dist = Math.abs(currDate - matchDate);
+            if (dist < closestDist) {
+                closestDist = dist;
+                closestDate = dateStr;
+            }
+            else if (dist === closestDist) {
+                // Tie-breaker: Prefer the date that is in the future relative to the matchDate
+                // Or if both are same direction, just keep the current one (or implementation defined)
+                // Requirement: "Both 17th and 19th have same dist. It should pick 19th"
+                if (currDate > matchDate) {
+                    closestDate = dateStr;
+                }
+            }
+        }
+        return closestDate;
+    }
+    static getTodayEST() {
+        return this.format(new Date().toLocaleString('en-US', { timeZone: 'America/New_York' }), 'Y-m-d');
+    }
+    static getStartOfDay(date) {
+        const d = this.parse(date);
+        d.setHours(0, 0, 0, 0);
+        return d;
+    }
+    static getStartOfMonth(date) {
+        const d = this.parse(date);
+        d.setDate(1);
+        d.setHours(0, 0, 0, 0);
+        return d;
+    }
+    static getStartOfGrid(date) {
+        const d = this.getStartOfMonth(date);
+        const dayOfWeek = d.getDay(); // 0 (Sunday) is the start in standard JS
+        // Move back to the beginning of the week
+        const result = this.parse(d);
+        // Subtract days to get to the start of the week (Sunday)
+        result.setDate(d.getDate() - dayOfWeek);
+        return result;
+    }
+    static isSameDay(date1, date2) {
+        if (!date1 || !date2) {
+            return false;
+        }
+        const d1 = this.parse(date1);
+        const d2 = this.parse(date2);
+        return (d1.getFullYear() === d2.getFullYear() &&
+            d1.getMonth() === d2.getMonth() &&
+            d1.getDate() === d2.getDate());
+    }
+    // Helper to check if one date is before another (ignoring time)
+    static isBeforeDay(date1, date2) {
+        if (!date1 || !date2) {
+            return false;
+        }
+        return this.getStartOfDay(date1).getTime() < this.getStartOfDay(date2).getTime();
+    }
+    // Helper to check if one date is after another (ignoring time)
+    static isAfterDay(date1, date2) {
+        if (!date1 || !date2) {
+            return false;
+        }
+        return this.getStartOfDay(date1).getTime() > this.getStartOfDay(date2).getTime();
+    }
+}

package/dist/Kontororu/Socket.d.ts

@@ -0,0 +1,44 @@
+import { Kontororu } from '@/Kontororu.js';
+type SocketMessage = {
+    type: 'subscribe' | 'unsubscribe' | 'data' | 'heartbeat';
+    table: string;
+    id: string;
+};
+declare class Socket extends Kontororu {
+    private ws?;
+    private connection_state;
+    private protocol;
+    private url;
+    private session_id?;
+    private message_queue;
+    private reconnect_attempts;
+    private should_reconnect;
+    private reconnect_timeout?;
+    private last_heartbeat_timestamp;
+    private readonly HEARTBEAT_INTERVAL_MS;
+    private readonly SUSPENSION_THRESHOLD_MS;
+    private readonly DISCONNECT_THRESHOLD_MS;
+    constructor();
+    connect(session_id: string): void;
+    /**
+     * Send message if the websocket is open,
+     * otherwise add it to the message queue
+     */
+    message({ type, table, id }: SocketMessage): void;
+    disconnect(): void;
+    /**
+     * Update the connection state, dispatch an event if it actually changed.
+     */
+    private update_connection_state;
+    /**
+     * Helper to determine if we need to fetch missing data
+     */
+    private check_staleness;
+    private handle_open;
+    private handle_message;
+    private handle_close;
+    private handle_error;
+}
+export declare const socket: Socket;
+export {};
+//# sourceMappingURL=Socket.d.ts.map

package/dist/Kontororu/Socket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Socket.d.ts","sourceRoot":"","sources":["../../src/Kontororu/Socket.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAS3C,KAAK,aAAa,GAAG;IACnB,IAAI,EAAE,WAAW,GAAG,aAAa,GAAG,MAAM,GAAG,WAAW,CAAC;IACzD,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;CACZ,CAAA;AAUD,cAAM,MAAO,SAAQ,SAAS;IAC5B,OAAO,CAAC,EAAE,CAAC,CAAY;IAEvB,OAAO,CAAC,gBAAgB,CAAgC;IAExD,OAAO,CAAC,QAAQ,CAA4I;IAE5J,OAAO,CAAC,GAAG,CAAoE;IAE/E,OAAO,CAAC,UAAU,CAAC,CAAS;IAE5B,OAAO,CAAC,aAAa,CAAuB;IAG5C,OAAO,CAAC,kBAAkB,CAAa;IACvC,OAAO,CAAC,gBAAgB,CAAQ;IAChC,OAAO,CAAC,iBAAiB,CAAC,CAAiB;IAG3C,OAAO,CAAC,wBAAwB,CAAsB;IAEtD,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAQ;IAE9C,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAA2C;IAEnF,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAA2C;;IAyC5E,OAAO,CAAC,UAAU,EAAE,MAAM;IA+BjC;;;OAGG;IACI,OAAO,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,aAAa;IAa1C,UAAU;IAYjB;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAmB/B;;OAEG;IACH,OAAO,CAAC,eAAe;IAuBvB,OAAO,CAAC,WAAW;IA+BnB,OAAO,CAAC,cAAc;IA+BtB,OAAO,CAAC,YAAY;IAkBpB,OAAO,CAAC,YAAY;CAMrB;AAED,eAAO,MAAM,MAAM,QAAe,CAAC"}

package/dist/Kontororu/Socket.js

@@ -0,0 +1,218 @@
+import { Kontororu } from '@/Kontororu.js';
+const hostname = process.env.NEXT_PUBLIC_WS_HOST;
+const port = process.env.NEXT_PUBLIC_WS_PORT;
+const path = process.env.NEXT_PUBLIC_WS_PATH;
+const debug = false;
+class Socket extends Kontororu {
+    constructor() {
+        super();
+        this.connection_state = 'connected';
+        this.protocol = (typeof window !== 'undefined' && window.location && window.location.protocol && window.location.protocol === 'https:' ? 'wss:' : 'ws:');
+        this.url = `${this.protocol}//${hostname}${port ? `:${port}` : ''}/${path}`;
+        this.message_queue = [];
+        // Reconnection logic
+        this.reconnect_attempts = 0;
+        this.should_reconnect = true;
+        // Heartbeat / Sleep Detection Logic
+        this.last_heartbeat_timestamp = Date.now();
+        // How often the server pings THIS specific client (5 seconds)
+        this.HEARTBEAT_INTERVAL_MS = 5000;
+        // Calculate threshold: 2 missed beats + 1 second of network jitter buffer
+        this.SUSPENSION_THRESHOLD_MS = (this.HEARTBEAT_INTERVAL_MS * 2) + 1000;
+        // 3 Heartbeats + 1s buffer = 16 seconds
+        this.DISCONNECT_THRESHOLD_MS = (this.HEARTBEAT_INTERVAL_MS * 3) + 1000;
+        if (typeof document !== 'undefined') {
+            document.addEventListener('visibilitychange', (event) => {
+                if (document.visibilityState === 'visible') {
+                    this.check_staleness('tab_switch');
+                }
+            });
+        }
+        if (typeof window !== 'undefined') {
+            const offlineChecker = () => {
+                const check = 3;
+                let checked = 1;
+                const checker = () => {
+                    if (checked > check) {
+                        return;
+                    }
+                    setTimeout(() => {
+                        this.check_staleness('offline');
+                        checked++;
+                        checker();
+                    }, (this.HEARTBEAT_INTERVAL_MS) + 500);
+                };
+                checker();
+            };
+            window.addEventListener('online', () => {
+                window.removeEventListener('offline', offlineChecker);
+            });
+            window.addEventListener('offline', offlineChecker);
+        }
+    }
+    connect(session_id) {
+        if (!session_id) {
+            console.warn('session_id required to open ws');
+            return;
+        }
+        if (this.ws &&
+            (this.ws.readyState === WebSocket.OPEN ||
+                this.ws.readyState === WebSocket.CONNECTING)) {
+            return;
+        }
+        this.ws = new WebSocket(this.url);
+        if (debug)
+            console.log('new websocket');
+        this.session_id = session_id;
+        // Reset heartbeat timer on new connection
+        this.last_heartbeat_timestamp = Date.now();
+        this.ws.addEventListener('open', (event) => this.handle_open(event));
+        this.ws.addEventListener('message', (event) => this.handle_message(event));
+        this.ws.addEventListener('close', (event) => this.handle_close(event));
+        this.ws.addEventListener('error', (event) => this.handle_error(event));
+    }
+    /**
+     * Send message if the websocket is open,
+     * otherwise add it to the message queue
+     */
+    message({ type, table, id }) {
+        const payload = { type, table, id };
+        if (this.ws &&
+            this.ws.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(payload));
+        }
+        else {
+            this.message_queue.push(payload);
+        }
+    }
+    disconnect() {
+        if (debug)
+            console.log('websocket disconnect()');
+        this.update_connection_state('disconnected');
+        // if we are manually disconnecting we do not want an auto reconnect
+        this.should_reconnect = false;
+        this.ws?.close();
+        this.ws = undefined;
+        if (this.reconnect_timeout) {
+            clearTimeout(this.reconnect_timeout);
+        }
+    }
+    /**
+     * Update the connection state, dispatch an event if it actually changed.
+     */
+    update_connection_state(new_connection_state) {
+        const old_connection_state = this.connection_state;
+        if (this.connection_state !== new_connection_state) {
+            if (debug)
+                console.log('update_connection_state', new_connection_state);
+            this.connection_state = new_connection_state;
+            if (debug)
+                console.warn(`[Socket] State changed to: ${this.connection_state}`);
+            this.dispatchEvent(new CustomEvent('connection_state', { detail: this.connection_state }));
+            if ((new_connection_state === 'connected' || new_connection_state === 'reconnected') &&
+                (old_connection_state === 'stale' || old_connection_state === 'disconnected')) {
+                this.dispatchEvent(new CustomEvent('refresh', { bubbles: true }));
+            }
+        }
+    }
+    /**
+     * Helper to determine if we need to fetch missing data
+     */
+    check_staleness(source) {
+        const now = Date.now();
+        const time_since_last = now - this.last_heartbeat_timestamp;
+        if (debug)
+            console.log('websocket check_staleness()', source, time_since_last);
+        if (!this.ws ||
+            this.ws.readyState === this.ws.CLOSED ||
+            time_since_last > this.DISCONNECT_THRESHOLD_MS) {
+            this.update_connection_state('disconnected');
+            return;
+        }
+        // If gap is larger than threshold, we missed messages
+        if (time_since_last > this.SUSPENSION_THRESHOLD_MS) {
+            this.update_connection_state('stale');
+        }
+        else {
+            this.update_connection_state('connected');
+        }
+    }
+    handle_open(event) {
+        if (debug)
+            console.log('websocket handle open()');
+        if (this.ws &&
+            this.ws.readyState === this.ws.OPEN) {
+            this.update_connection_state('connected');
+        }
+        // clear reconnect timeout if we connected
+        if (this.reconnect_timeout) {
+            clearTimeout(this.reconnect_timeout);
+        }
+        // If we are reconnecting (attempts > 0), we definitely missed data.
+        if (this.reconnect_attempts > 0) {
+            if (debug)
+                console.log('[Socket] Reconnected. Triggering refresh.');
+            this.dispatchEvent(new CustomEvent('refresh', { bubbles: true }));
+        }
+        // reset the reconnect attempts
+        this.reconnect_attempts = 0;
+        this.ws?.send(JSON.stringify({ type: 'session', table: 'session', id: this.session_id }));
+        while (this.message_queue.length > 0) {
+            const queuedMsg = this.message_queue.shift();
+            this.ws?.send(JSON.stringify(queuedMsg));
+        }
+    }
+    handle_message(event) {
+        if (debug)
+            console.log('websocket handle message()');
+        try {
+            const data = JSON.parse(event.data);
+            if (debug)
+                console.log('data', data);
+            // HEARTBEAT CHECK: Intercept heartbeat messages
+            if (data.type === 'heartbeat') {
+                this.check_staleness('heartbeat');
+                this.last_heartbeat_timestamp = Date.now();
+                return; // Do not bubble 'heartbeat' to the UI
+            }
+            // todo not sure I like this
+            const messageEvent = new CustomEvent('message', {
+                detail: JSON.parse(event.data),
+                bubbles: true,
+            });
+            this.dispatchEvent(messageEvent);
+        }
+        catch (e) {
+            const messageEvent = new CustomEvent('message', {
+                detail: event.data,
+                bubbles: true,
+            });
+            this.dispatchEvent(messageEvent);
+        }
+    }
+    handle_close(event) {
+        if (debug)
+            console.log('websocket handle close()');
+        this.update_connection_state('disconnected');
+        if (this.should_reconnect) {
+            const delay = Math.min(1000 * Math.pow(2, this.reconnect_attempts), 30000);
+            if (debug)
+                console.log(`Connection lost. Retrying in ${delay}ms... (Attempt ${this.reconnect_attempts + 1})`);
+            this.reconnect_timeout = setTimeout(() => {
+                this.reconnect_attempts++;
+                if (this.session_id) {
+                    this.connect(this.session_id);
+                }
+            }, delay);
+        }
+        this.ws = undefined;
+    }
+    handle_error(event) {
+        if (debug)
+            console.log('websocket handle error()');
+        this.update_connection_state('disconnected');
+        console.error('WebSocket Error:', event);
+        this.ws?.close();
+    }
+}
+export const socket = new Socket();

package/dist/Kontororu.d.ts

@@ -0,0 +1,8 @@
+export declare class Kontororu extends EventTarget {
+    constructor();
+    private listeners;
+    addEventListener(type: string, listener: (...args: unknown[]) => void): void;
+    removeEventListener(type: string, listener: (...args: unknown[]) => void): void;
+    getListeners(type: string): ((...args: unknown[]) => void)[];
+}
+//# sourceMappingURL=Kontororu.d.ts.map

package/dist/Kontororu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Kontororu.d.ts","sourceRoot":"","sources":["../src/Kontororu.ts"],"names":[],"mappings":"AAGA,qBAAa,SAAU,SAAQ,WAAW;;IAMxC,OAAO,CAAC,SAAS,CAEf;IAEF,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI;IASrE,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI;IAQxE,YAAY,CAAC,IAAI,EAAE,MAAM,cApBS,OAAO,EAAE,KAAK,IAAI;CAuBrD"}

package/dist/Kontororu.js

@@ -0,0 +1,23 @@
+// コントロール
+export class Kontororu extends EventTarget {
+    constructor() {
+        super();
+        this.listeners = {};
+    }
+    addEventListener(type, listener) {
+        super.addEventListener(type, listener);
+        if (!this.listeners[type]) {
+            this.listeners[type] = [];
+        }
+        this.listeners[type].push(listener);
+    }
+    removeEventListener(type, listener) {
+        super.removeEventListener(type, listener);
+        if (this.listeners[type]) {
+            this.listeners[type] = this.listeners[type].filter((l) => l !== listener);
+        }
+    }
+    getListeners(type) {
+        return this.listeners[type] || [];
+    }
+}