@apple-pie/slice 0.1.3 → 0.1.4

package/dist/esm/stores/SSE.mjs

@@ -1,7 +1,7 @@
-export { u as useConnectionClose, a as useConnectionMessage, b as useIsConnected, c as useLastSSEMessage, d as useMessage, e as useSSE, f as useSSEActions, g as useSSEStore } from "../chunks/sseStore-m3IPyLwJ.mjs";
+export { u as useConnectionClose, a as useConnectionMessage, b as useIsConnected, c as useLastSSEMessage, d as useMessage, e as useSSE, f as useSSEActions, g as useSSEStore } from "../chunks/sseStore-DdqmnAAf.mjs";
 
 import "zustand";
 
 import "../chunks/tslib.es6-c-7TIv71.mjs";
 
-import "../utils/objects/index.mjs";
+import "../chunks/SSEConnection-Dj9P0SWE.mjs";

package/dist/esm/stores/WS.mjs

@@ -0,0 +1,59 @@
+import { create } from "zustand";
+
+import "../chunks/tslib.es6-c-7TIv71.mjs";
+
+import { W as WSConnection } from "../chunks/WSConnection-DlYSitff.mjs";
+
+const useWSStore = create((set, get) => ({
+    connections: [],
+    message: null,
+    closedConnection: null,
+    actions: {
+        addConnection: (name, options) => {
+            const existingConnection = get().connections.find(c => c.name === name);
+            null == existingConnection || existingConnection.connection.close({
+                code: 1e3,
+                reason: "Connection replaced"
+            });
+            const userOnMessageCallback = options.onMessageCallback, connection = new WSConnection(Object.assign(Object.assign({}, options), {
+                unifiedMessages: !0,
+                onMessageCallback: message => {
+                    set({
+                        message: message
+                    }), null == userOnMessageCallback || userOnMessageCallback(message), "close" === message.type && set({
+                        closedConnection: name
+                    });
+                }
+            })), nextConnection = {
+                name: name,
+                connection: connection
+            };
+            return set(state => ({
+                connections: [ ...state.connections.filter(connection => connection.name !== name), nextConnection ]
+            })), nextConnection;
+        },
+        removeConnection: name => {
+            const existingConnection = get().connections.find(c => c.name === name);
+            existingConnection && (existingConnection.connection.close({
+                code: 1e3,
+                reason: "Connection removed"
+            }), set(state => ({
+                connections: state.connections.filter(connection => connection.name !== name)
+            })));
+        }
+    }
+})), useWS = () => useWSStore(state => state.actions), useConnectionClose = () => useWSStore(state => state.closedConnection), useConnectionMessage = connection => useWSStore(state => state.connections.some(entry => entry.name === connection) ? state.message : null), useIsConnected = connection => useWSStore(state => {
+    var _a, _b;
+    return connection ? null !== (_b = null === (_a = state.connections.find(entry => entry.name === connection)) || void 0 === _a ? void 0 : _a.connection.connected) && void 0 !== _b && _b : state.connections.some(entry => entry.connection.connected);
+});
+
+function useMessage(type, connection) {
+    return useWSStore(state => {
+        const sourceMessage = connection && !state.connections.some(c => c.name === connection) ? null : state.message;
+        return type ? (null == sourceMessage ? void 0 : sourceMessage.type) !== type ? null : "open" === type || "error" === type || "close" === type ? "event" in sourceMessage ? sourceMessage.event : null : "data" in sourceMessage ? sourceMessage.data : null : sourceMessage;
+    });
+}
+
+const useWSActions = useWSStore.getState().actions, useLastWSMessage = () => useWSStore.getState().message;
+
+export { useConnectionClose, useConnectionMessage, useIsConnected, useLastWSMessage, useMessage, useWS, useWSActions, useWSStore };

package/dist/esm/stores/window.mjs

@@ -1,3 +1,5 @@
-export { F as FormFactor, u as useWindowStore } from "../chunks/windowStore-CwW0i_le.mjs";
+export { F as FormFactor, d as dpr, f as formFactor, g as gettingLocation, i as isAppleDevice, a as isElectron, b as isTouchDevice, l as location, c as locationError, u as useDpr, e as useFormFactor, h as useGetLocation, j as useGettingLocation, k as useInitializeWindow, m as useIsAppleDevice, n as useIsElectron, o as useIsTouchDevice, p as useLocation, q as useLocationError, r as useViewportHeight, s as useViewportWidth, t as useWindowStore, v as viewportHeight, w as viewportWidth } from "../chunks/windowStore-BOTh1g37.mjs";
+
+import "../chunks/tslib.es6-c-7TIv71.mjs";
 
 import "zustand";

package/dist/esm/stores.mjs

@@ -1,4 +1,4 @@
-export { F as FormFactor, u as useWindowStore } from "./chunks/windowStore-CwW0i_le.mjs";
+export { F as FormFactor, d as dpr, f as formFactor, g as gettingLocation, i as isAppleDevice, a as isElectron, b as isTouchDevice, l as location, c as locationError, u as useDpr, e as useFormFactor, h as useGetLocation, j as useGettingLocation, k as useInitializeWindow, m as useIsAppleDevice, n as useIsElectron, o as useIsTouchDevice, p as useLocation, q as useLocationError, r as useViewportHeight, s as useViewportWidth, t as useWindowStore, v as viewportHeight, w as viewportWidth } from "./chunks/windowStore-BOTh1g37.mjs";
 
 export { c as createUploadsWorker, g as getUploads, a as getUploadsError, b as getUploadsWorkerStatus, u as uploadsActions, d as uploadsInitialized, e as useUploads, f as useUploadsActions, h as useUploadsError, i as useUploadsInitialized, j as useUploadsStore, k as useUploadsWorkerStatus } from "./chunks/uploadsStore-D69fEXMY.mjs";
 
@@ -6,12 +6,12 @@ export { g as getTip, t as tipActions, u as useTip, a as useTipActions, b as use
 
 export { g as getToast, t as toastActions, u as useToast, a as useToastActions, b as useToastStore } from "./chunks/toastStore-D2PEIqCo.mjs";
 
-export { u as useConnectionClose, a as useConnectionMessage, b as useIsConnected, c as useLastSSEMessage, d as useMessage, e as useSSE, f as useSSEActions, g as useSSEStore } from "./chunks/sseStore-m3IPyLwJ.mjs";
+export { u as useConnectionClose, a as useConnectionMessage, b as useIsConnected, c as useLastSSEMessage, d as useMessage, e as useSSE, f as useSSEActions, g as useSSEStore } from "./chunks/sseStore-DdqmnAAf.mjs";
+
+import "./chunks/tslib.es6-c-7TIv71.mjs";
 
 import "zustand";
 
 import "./chunks/uploads-worker-Dv-4zGnC.mjs";
 
-import "./chunks/tslib.es6-c-7TIv71.mjs";
-
-import "./utils/objects/index.mjs";
+import "./chunks/SSEConnection-Dj9P0SWE.mjs";

package/dist/esm/utils/index.mjs

@@ -2,6 +2,8 @@ export { c as copyToClipboard } from "../chunks/misc-cg9I7drO.mjs";
 
 export { a as addOpacity, t as tintFromColor } from "../chunks/colors-DR9fLI5X.mjs";
 
-export { SSEConnection } from "./objects/index.mjs";
+export { S as SSEConnection } from "../chunks/SSEConnection-Dj9P0SWE.mjs";
+
+export { W as WSConnection } from "../chunks/WSConnection-DlYSitff.mjs";
 
 import "../chunks/tslib.es6-c-7TIv71.mjs";

package/dist/esm/utils/objects/index.mjs

@@ -1,140 +1,5 @@
-class SSEConnection {
-    /**
-     * Whether the underlying EventSource is currently open.
-     */
-    get connected() {
-        var _a;
-        return (null === (_a = this.sseConnection) || void 0 === _a ? void 0 : _a.readyState) === EventSource.OPEN;
-    }
-    /**
-     * Direct access to the underlying EventSource instance.
-     */    get connection() {
-        return this.sseConnection;
-    }
-    /**
-     * Create an SEE connection instance
-     */    constructor(options) {
-        var _a, _b, _c;
-        this.sseConnection = null, this.customEventHandlers = new Map, this.unifiedOnMessage = !1, 
-        /**
-         * One message received
-         */
-        this.onMessage = event => {
-            const data = this.parseEventData(event.data);
-            this.emitUnifiedMessage({
-                type: "message",
-                data: data,
-                event: event
-            }), this.emitParsedMessage(data), this.shouldCloseFromMessage(event.data, data) && this.closeFromConnectionEvent();
-        }, 
-        /**
-         * On error event
-         */
-        this.onError = event => {
-            var _a;
-            null === (_a = this.onErrorCallback) || void 0 === _a || _a.call(this, event), this.emitUnifiedMessage({
-                type: "error",
-                event: event
-            });
-        }, 
-        /**
-         * On open event
-         */
-        this.onOpen = event => {
-            var _a;
-            null === (_a = this.onOpenCallback) || void 0 === _a || _a.call(this, event), this.emitUnifiedMessage({
-                type: "open",
-                event: event
-            });
-        }, 
-        /**
-         * Close the SSE connection and release resources.
-         */
-        this.close = () => {
-            this.sseConnection && (this.detachAllEventListeners(this.sseConnection), this.sseConnection.close(), 
-            this.sseConnection = null);
-        }, this.url = null !== (_a = null == options ? void 0 : options.url) && void 0 !== _a ? _a : "", 
-        this.options = null !== (_b = null == options ? void 0 : options.options) && void 0 !== _b ? _b : void 0, 
-        this.unifiedOnMessage = null !== (_c = null == options ? void 0 : options.unifiedOnMessage) && void 0 !== _c && _c, 
-        this.onMessageCallback = null == options ? void 0 : options.onMessageCallback, this.onErrorCallback = null == options ? void 0 : options.onErrorCallback, 
-        this.onOpenCallback = null == options ? void 0 : options.onOpenCallback, this.onCloseCallback = null == options ? void 0 : options.onCloseCallback, 
-        this.connectionClose = null == options ? void 0 : options.connectionClose, (null == options ? void 0 : options.customEvents) ? this.customEvents = Array.isArray(null == options ? void 0 : options.customEvents) ? options.customEvents : [ options.customEvents ] : this.customEvents = [], 
-        this.sseConnection = new EventSource(this.url, this.options), this.attachDefaultEventListeners(this.sseConnection), 
-        this.customEvents.length > 0 && this.attachCustomEventListeners(this.customEvents);
-    }
-    /**
-     * Safely parse SSE event data. Falls back to the raw string when the payload is not JSON.
-     */    parseEventData(rawData) {
-        try {
-            return JSON.parse(rawData);
-        } catch (_a) {
-            return rawData;
-        }
-    }
-    /**
-     * Attach default SEE events
-     */    attachDefaultEventListeners(connection) {
-        connection.addEventListener("message", this.onMessage), connection.addEventListener("error", this.onError), 
-        connection.addEventListener("open", this.onOpen);
-    }
-    emitParsedMessage(data) {
-        var _a;
-        this.unifiedOnMessage || null === (_a = this.onMessageCallback) || void 0 === _a || _a.call(this, data);
-    }
-    emitUnifiedMessage(message) {
-        var _a;
-        this.unifiedOnMessage && (null === (_a = this.onMessageCallback) || void 0 === _a || _a.call(this, message));
-    }
-    emitCloseEvent(event) {
-        var _a;
-        null === (_a = this.onCloseCallback) || void 0 === _a || _a.call(this, event), this.emitUnifiedMessage({
-            type: "close",
-            event: event
-        });
-    }
-    closeFromConnectionEvent() {
-        const closeEvent = new Event("close");
-        this.emitCloseEvent(closeEvent), this.close();
-    }
-    shouldCloseFromMessage(rawData, data) {
-        var _a;
-        return !!(null === (_a = this.connectionClose) || void 0 === _a ? void 0 : _a.message) && (rawData === this.connectionClose.message || data === this.connectionClose.message);
-    }
-    emitUnifiedCustomMessage(customEvent, data, event) {
-        this.emitUnifiedMessage({
-            type: customEvent.name,
-            data: data,
-            event: event
-        });
-    }
-    /**
-     * Attach custom event listeners to the SSE connection
-     */    attachCustomEventListener(customEvent) {
-        var _a;
-        if (!this.sseConnection) return;
-        const handler = eventInfo => {
-            var _a, _b;
-            const data = this.parseEventData(eventInfo.data);
-            null === (_a = customEvent.handler) || void 0 === _a || _a.call(customEvent, data), 
-            this.emitUnifiedCustomMessage(customEvent, data, eventInfo), (null === (_b = this.connectionClose) || void 0 === _b ? void 0 : _b.event) === customEvent.name && this.closeFromConnectionEvent();
-        }, currentHandlers = null !== (_a = this.customEventHandlers.get(customEvent.name)) && void 0 !== _a ? _a : [];
-        currentHandlers.push(handler), this.customEventHandlers.set(customEvent.name, currentHandlers), 
-        this.sseConnection.addEventListener(customEvent.name, handler);
-    }
-    /**
-     * Attach custom event listeners to the SSE connection
-     */    attachCustomEventListeners(customEvents) {
-        const events = Array.isArray(customEvents) ? customEvents : [ customEvents ];
-        for (const event of events) this.attachCustomEventListener(event);
-    }
-    /**
-     * Clean up listeners
-     */    detachAllEventListeners(connection) {
-        connection.removeEventListener("message", this.onMessage), connection.removeEventListener("error", this.onError), 
-        connection.removeEventListener("open", this.onOpen);
-        for (const [eventName, handlers] of this.customEventHandlers.entries()) for (const handler of handlers) connection.removeEventListener(eventName, handler);
-        this.customEventHandlers.clear();
-    }
-}
+export { S as SSEConnection } from "../../chunks/SSEConnection-Dj9P0SWE.mjs";
 
-export { SSEConnection };
+export { W as WSConnection } from "../../chunks/WSConnection-DlYSitff.mjs";
+
+import "../../chunks/tslib.es6-c-7TIv71.mjs";

package/dist/types/hooks/index.d.ts

@@ -5,5 +5,5 @@ export { useToolTip } from './useToolTip/useToolTip';
 export { type KeyboardShortcut, type KeyboardShortcuts, useKeyboardShortcuts, } from './useKeyboardShortcuts/useKeyboardShortcuts';
 export { useLastUpdated } from './useLastUpdated/useLastUpdated';
 export { useLocalStore } from './useLocalStore/useLocalStore';
-export { useWindow, FormFactor, type BreakPoints } from './useWindow/useWindow';
+export { useWindow, FormFactor, type BreakPoints, type WindowGeolocation, type WindowGeolocationError, } from './useWindow/useWindow';
 export { useObserveResize } from './useObserveResize/useObserveResize';

package/dist/types/hooks/useWindow/useWindow.d.ts

@@ -12,6 +12,20 @@ export declare enum FormFactor {
  * Breakpoint type matching form factor to width value
  */
 export type BreakPoints = Record<FormFactor, number>;
+export type WindowGeolocation = {
+    latitude: number;
+    longitude: number;
+    accuracy: number;
+    altitude: number | null;
+    altitudeAccuracy: number | null;
+    heading: number | null;
+    speed: number | null;
+    timestamp: number;
+};
+export type WindowGeolocationError = {
+    code: number;
+    message: string;
+};
 export declare function useWindow(breakpoints?: BreakPoints, top?: boolean): {
     viewportWidth: number | null;
     viewportHeight: number | null;
@@ -21,4 +35,9 @@ export declare function useWindow(breakpoints?: BreakPoints, top?: boolean): {
     isAppleDevice: boolean;
     formFactor: FormFactor;
     dpr: 2 | 1 | 3;
+    geolocationSupported: boolean;
+    location: WindowGeolocation | null;
+    locationError: Error | null;
+    gettingLocation: boolean;
+    requestGeolocation: () => void;
 };

package/dist/types/index.d.ts

@@ -2,7 +2,7 @@ export type { ToolTip, ToolTipInfo } from './components/sharedTypes';
 export { ToolTipType } from './components/sharedTypes';
 export { light, dark, lightTheme, darkTheme, motion, elevations, Elevation, } from './theme';
 export type { SliceTheme, Colors, Type, Corners, Elevations, } from './theme';
-export { type KeyboardShortcut, type KeyboardShortcuts, type BreakPoints, useKeyboardShortcuts, useTheme, useObserveTheme, useToolTip, useLastUpdated, useLocalStore, useWindow, useDoubleClick, useObserveResize, } from './hooks';
+export { type KeyboardShortcut, type KeyboardShortcuts, type BreakPoints, type WindowGeolocation, type WindowGeolocationError, useKeyboardShortcuts, useTheme, useObserveTheme, useToolTip, useLastUpdated, useLocalStore, useWindow, useDoubleClick, useObserveResize, } from './hooks';
 export { Avatar } from './components/Avatar/index';
 export type { AvatarProps } from './components/Avatar/index';
 export { AvatarGroup } from './components/AvatarGroup';

package/dist/types/stores/WS/_types.d.ts

@@ -0,0 +1,17 @@
+import type { UnifiedMessageEvent, WSConnection, WSConnectionOptions } from '../../utils';
+export type WSStoreConnectionOptions = Omit<WSConnectionOptions<unknown>, 'unifiedMessages'> & {
+    onMessageCallback?: (message: UnifiedMessageEvent<unknown>) => void;
+};
+export interface WSStoreConnection {
+    name: string;
+    connection: WSConnection<unknown>;
+}
+export interface WSStore {
+    connections: WSStoreConnection[];
+    message: UnifiedMessageEvent<unknown> | null;
+    closedConnection: string | null;
+    actions: {
+        addConnection: (name: string, options: WSStoreConnectionOptions) => WSStoreConnection;
+        removeConnection: (name: string) => void;
+    };
+}

package/dist/types/stores/WS/index.d.ts

@@ -0,0 +1,2 @@
+export { useWSStore, useWS, useConnectionClose, useConnectionMessage, useIsConnected, useMessage, useWSActions, useLastWSMessage, } from './wsStore';
+export type { WSStore, WSStoreConnection, WSStoreConnectionOptions, } from './_types';

package/dist/types/stores/WS/wsStore.d.ts

@@ -0,0 +1,19 @@
+import { type UnifiedMessageEvent } from '../../utils';
+import type { WSStore, WSStoreConnectionOptions } from './_types';
+export declare const useWSStore: import("zustand").UseBoundStore<import("zustand").StoreApi<WSStore>>;
+export declare const useWS: () => {
+    addConnection: (name: string, options: WSStoreConnectionOptions) => import("./_types").WSStoreConnection;
+    removeConnection: (name: string) => void;
+};
+export declare const useConnectionClose: () => string | null;
+export declare const useConnectionMessage: (connection: string) => UnifiedMessageEvent<unknown> | null;
+export declare const useIsConnected: (connection?: string) => boolean;
+export declare function useMessage(): UnifiedMessageEvent<unknown> | null;
+export declare function useMessage<T = unknown>(type: 'message', connection?: string): T | string | Blob | ArrayBuffer | null;
+export declare function useMessage(type: 'open' | 'error' | 'close', connection?: string): Event | ErrorEvent | CloseEvent | null;
+export declare function useMessage<T = unknown>(type: string, connection?: string): T | string | Blob | ArrayBuffer | null;
+export declare const useWSActions: {
+    addConnection: (name: string, options: WSStoreConnectionOptions) => import("./_types").WSStoreConnection;
+    removeConnection: (name: string) => void;
+};
+export declare const useLastWSMessage: () => UnifiedMessageEvent<unknown> | null;

package/dist/types/stores/window/_types.d.ts

@@ -1,3 +1,4 @@
+import type { WindowGeolocation } from '../../hooks/useWindow/useWindow';
 export type WindowStore = {
     formFactor: FormFactor;
     dpr: 1 | 2 | 3;
@@ -7,8 +8,12 @@ export type WindowStore = {
     height: string;
     viewportWidth: number;
     viewportHeight: number;
+    location: WindowGeolocation | null;
+    locationError: Error | null;
+    gettingLocation: boolean;
     actions: {
         initialize: () => () => void;
+        getLocation: () => Promise<WindowGeolocation>;
     };
 };
 /**

package/dist/types/stores/window/index.d.ts

@@ -1,2 +1,3 @@
-export { useWindowStore } from './windowStore';
-export { FormFactor, type BreakPoints, type WindowStore, } from './_types';
+export { useWindowStore, useFormFactor, useViewportWidth, useViewportHeight, useIsAppleDevice, useIsTouchDevice, useIsElectron, useDpr, useLocation, useLocationError, useGettingLocation, useInitializeWindow, useGetLocation, formFactor, viewportWidth, viewportHeight, isAppleDevice, isTouchDevice, isElectron, dpr, location, locationError, gettingLocation, } from './windowStore';
+export { FormFactor, type BreakPoints, type WindowStore } from './_types';
+export type { WindowGeolocation, WindowGeolocationError, } from '../../hooks/useWindow/useWindow';

package/dist/types/stores/window/windowStore.d.ts

@@ -1,3 +1,4 @@
+import type { WindowGeolocation } from '../../hooks/useWindow/useWindow';
 import { FormFactor, type WindowStore } from './_types';
 export declare const useWindowStore: import("zustand").UseBoundStore<import("zustand").StoreApi<WindowStore>>;
 export declare const useFormFactor: () => FormFactor;
@@ -7,7 +8,11 @@ export declare const useIsAppleDevice: () => boolean;
 export declare const useIsTouchDevice: () => boolean;
 export declare const useIsElectron: () => boolean;
 export declare const useDpr: () => 2 | 1 | 3;
+export declare const useLocation: () => WindowGeolocation | null;
+export declare const useLocationError: () => Error | null;
+export declare const useGettingLocation: () => boolean;
 export declare const useInitializeWindow: () => () => () => void;
+export declare const useGetLocation: () => () => Promise<WindowGeolocation>;
 export declare const formFactor: () => FormFactor;
 export declare const viewportWidth: () => number;
 export declare const viewportHeight: () => number;
@@ -15,3 +20,6 @@ export declare const isAppleDevice: () => boolean;
 export declare const isTouchDevice: () => boolean;
 export declare const isElectron: () => boolean;
 export declare const dpr: () => 2 | 1 | 3;
+export declare const location: () => WindowGeolocation | null;
+export declare const locationError: () => Error | null;
+export declare const gettingLocation: () => boolean;

package/dist/types/utils/index.d.ts

@@ -1,4 +1,4 @@
 export { copyToClipboard } from './functions/misc';
 export { tintFromColor, addOpacity } from './functions/colors';
-export { SSEConnection } from './objects';
-export type { SSECustomEvent, SSEConnectionCloseOption, SSEConnectionOptions, SSEEventMap, SSEUnifiedBuiltInMessage, SSEUnifiedCustomMessage, SSEUnifiedMessage, } from './objects';
+export { SSEConnection, WSConnection } from './objects';
+export type { SSECustomEvent, SSEConnectionCloseOption, SSEConnectionOptions, SSEEventMap, SSEUnifiedBuiltInMessage, SSEUnifiedCustomMessage, SSEUnifiedMessage, UnifiedMessageEvent, WSConnectionOptions, } from './objects';

package/dist/types/utils/objects/WSConnection/WSConnection.d.ts

@@ -0,0 +1,147 @@
+type WSRawData = string | Blob | ArrayBuffer;
+type WSParsedData<TMessage> = TMessage | WSRawData;
+export type UnifiedMessageEvent<TMessage> = {
+    type: 'message';
+    data: WSParsedData<TMessage>;
+    event: MessageEvent;
+} | {
+    type: 'open';
+    event: Event;
+} | {
+    type: 'close';
+    event: CloseEvent;
+} | {
+    type: 'error';
+    event: ErrorEvent;
+};
+type WSStandardMessageCallback<TMessage> = (data: WSParsedData<TMessage>) => void;
+type WSUnifiedMessageCallback<TMessage> = (message: UnifiedMessageEvent<TMessage>) => void;
+interface WSConnectionOptionsBase {
+    url: string;
+    autoReconnect?: boolean;
+    reconnectInterval?: number;
+    reconnectAttempts?: number;
+    reconnectFalloff?: boolean;
+    keepAlive?: boolean;
+    keepAliveInterval?: number;
+    token?: string | (() => Promise<string>);
+    onOpenCallback?: (event: Event) => void;
+    onCloseCallback?: (event: CloseEvent) => void;
+    onErrorCallback?: (error: ErrorEvent) => void;
+}
+interface WSConnectionUnifiedOptions<TMessage = unknown> extends WSConnectionOptionsBase {
+    unifiedMessages: true;
+    onMessageCallback?: WSUnifiedMessageCallback<TMessage>;
+}
+interface WSConnectionStandardOptions<TMessage = unknown> extends WSConnectionOptionsBase {
+    unifiedMessages?: false;
+    onMessageCallback?: WSStandardMessageCallback<TMessage>;
+}
+export type WSConnectionOptions<TMessage = unknown> = WSConnectionStandardOptions<TMessage> | WSConnectionUnifiedOptions<TMessage>;
+export declare class WSConnection<TMessage = unknown> {
+    private readonly url;
+    private readonly autoReconnect;
+    private readonly reconnectInterval;
+    private readonly reconnectAttempts;
+    private readonly reconnectFalloff;
+    private readonly keepAlive;
+    private readonly keepAliveInterval;
+    private readonly unifiedMessages;
+    private readonly token;
+    private readonly onMessageCallback?;
+    private readonly onOpenCallback?;
+    private readonly onCloseCallback?;
+    private readonly onErrorCallback?;
+    private socket;
+    private keepAliveTimer;
+    private reconnectIntervalTimer;
+    private reconnectAttemptsCount;
+    private manuallyClosed;
+    get connected(): boolean;
+    get connection(): WebSocket | null;
+    constructor(options: WSConnectionOptions<TMessage>);
+    /**
+     * Gracefully handle sending messages
+     */
+    send(message: unknown): void;
+    /**
+     * Gracefully expose socket close
+     */
+    close(closeEvent: {
+        code: number;
+        reason: string;
+    }): void;
+    /**
+     * Emit the parsed message content for standard mode
+     */
+    private emitParsedMessage;
+    /**
+     * Emit a unified message if the unified flag is on
+     */
+    private emitUnifiedMessage;
+    /**
+     * Emit error
+     */
+    private emitErrorEvent;
+    /**
+     * Safe JSON parse message content
+     */
+    private parseEventData;
+    /**
+     * Open handler
+     */
+    private readonly onOpen;
+    /**
+     * Message handler
+     */
+    private readonly onMessage;
+    /**
+     * Close handler with the reconnection logic as needed
+     */
+    private readonly onClose;
+    /**
+     * Error handler
+     */
+    private readonly onError;
+    /**
+     * Attach socket listeners
+     */
+    private attachEventListeners;
+    /**
+     * set keep alive pings
+     */
+    private setKeepAlive;
+    /**
+     * Clear keep alive pings
+     */
+    private clearKeepAliveTimer;
+    /**
+     * Clear reconnect timer
+     */
+    private clearReconnectTimer;
+    /**
+     * detach all event listeners
+     */
+    private detachEventListeners;
+    /**
+     * Connect the socket
+     */
+    private connect;
+    /**
+     * Reconnect logic
+     */
+    private reconnect;
+    /**
+     * Calculate reconnect delay with fall off
+     */
+    private getReconnectDelay;
+    /**
+     * Determine if should reconnect based on the close event and props
+     */
+    private shouldReconnect;
+    /**
+     * Internal close socket - does not reset retry logic
+     */
+    private closeSocket;
+}
+export {};

package/dist/types/utils/objects/index.d.ts

@@ -1,2 +1,4 @@
 export { SSEConnection } from './SSEConnection/SSEConnection';
+export { WSConnection } from './WSConnection/WSConnection';
 export type { SSECustomEvent, SSEConnectionCloseOption, SSEConnectionOptions, SSEEventMap, SSEUnifiedBuiltInMessage, SSEUnifiedCustomMessage, SSEUnifiedMessage, } from './SSEConnection/SSEConnection';
+export type { UnifiedMessageEvent, WSConnectionOptions, } from './WSConnection/WSConnection';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@apple-pie/slice",
-	"version": "0.1.3",
+	"version": "0.1.4",
 	"main": "dist/cjs/index.js",
 	"module": "dist/esm/index.mjs",
 	"exports": {

package/dist/cjs/chunks/windowStore-RaJswiHM.js

@@ -1,70 +0,0 @@
-"use strict";
-
-var FormFactor, zustand = require("zustand");
-
-/**
- * Form factor names
- */ exports.FormFactor = void 0, (FormFactor = exports.FormFactor || (exports.FormFactor = {})).Mobile = "mobile", 
-FormFactor.Tablet = "tablet", FormFactor.Desktop = "desktop", FormFactor.DesktopL = "desktopL", 
-FormFactor.DesktopXL = "desktopXL";
-
-/**
- * Use bootstrap breakpoints
- */
-const bootstrapBreakPoints = {
-    [exports.FormFactor.Mobile]: 576,
-    [exports.FormFactor.Tablet]: 768,
-    [exports.FormFactor.Desktop]: 992,
-    [exports.FormFactor.DesktopL]: 1200,
-    [exports.FormFactor.DesktopXL]: 1400
-}, orderedBps = Object.entries(bootstrapBreakPoints).sort((a, b) => -b[1] - a[1]), getFormFactor = width => {
-    if (!width || width <= 0) return exports.FormFactor.Mobile;
-    for (const [formFactor, breakpoint] of orderedBps) if (width >= breakpoint) return formFactor;
-    return exports.FormFactor.Mobile;
-}, initialSize = processWindowSize(), useWindowStore = zustand.create((set, get) => {
-    var _a;
-    return {
-        formFactor: initialSize.formFactor,
-        viewportWidth: initialSize.viewportWidth,
-        viewportHeight: initialSize.viewportHeight,
-        height: initialSize.height,
-        isElectron: checkElectron(),
-        isAppleDevice: navigator.platform.startsWith("Mac") || "iPhone" === navigator.platform,
-        isTouchDevice: "ontouchstart" in globalThis || navigator.maxTouchPoints > 0,
-        dpr: null !== (_a = Math.min(Math.ceil(window.devicePixelRatio), 3)) && void 0 !== _a ? _a : 1,
-        actions: {
-            initialize: () => {
-                var _a;
-                const win = null !== (_a = globalThis.top) && void 0 !== _a ? _a : globalThis;
-                return null == win || win.addEventListener("resize", handleResize), () => null == win ? void 0 : win.removeEventListener("resize", handleResize);
-            }
-        }
-    };
-});
-
-function checkElectron() {
-    return navigator.userAgent.toLowerCase().includes("electron/");
-}
-
-function handleResize() {
-    const {formFactor: formFactor, viewportWidth: viewportWidth, viewportHeight: viewportHeight, height: height} = processWindowSize();
-    useWindowStore.setState({
-        formFactor: formFactor,
-        viewportWidth: viewportWidth,
-        viewportHeight: viewportHeight,
-        height: height
-    });
-}
-
-function processWindowSize(top = !0) {
-    var _a, _b, _c;
-    const viewport = null !== (_a = globalThis.top) && void 0 !== _a ? _a : globalThis, touch = "ontouchstart" in globalThis || navigator.maxTouchPoints > 0, windowWidth = null !== (_b = null == viewport ? void 0 : viewport.innerWidth) && void 0 !== _b ? _b : -1, windowHeight = null !== (_c = null == viewport ? void 0 : viewport.innerHeight) && void 0 !== _c ? _c : -1;
-    return {
-        formFactor: getFormFactor(windowWidth),
-        viewportWidth: windowWidth,
-        viewportHeight: windowHeight,
-        height: viewport && touch ? `${windowHeight}px` : "100vh"
-    };
-}
-
-exports.useWindowStore = useWindowStore;