@apple-pie/slice 0.1.2 → 0.1.4

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/SSE/_types.d.ts

@@ -0,0 +1,17 @@
+import type { SSEConnection, SSEConnectionOptions, SSEEventMap, SSEUnifiedMessage } from '../../utils';
+export type SSEStoreConnectionOptions = Omit<SSEConnectionOptions<unknown, SSEEventMap>, 'unifiedOnMessage'> & {
+    onMessageCallback?: (message: SSEUnifiedMessage<unknown, SSEEventMap>) => void;
+};
+export interface SSEStoreConnection {
+    name: string;
+    connection: SSEConnection<unknown, SSEEventMap>;
+}
+export interface SSEStore {
+    connections: SSEStoreConnection[];
+    message: SSEUnifiedMessage<unknown, SSEEventMap> | null;
+    closedConnection: string | null;
+    actions: {
+        addConnection: (name: string, options: SSEStoreConnectionOptions) => SSEStoreConnection;
+        removeConnection: (name: string) => void;
+    };
+}

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

@@ -0,0 +1,2 @@
+export { useSSEStore, useSSE, useConnectionClose, useConnectionMessage, useIsConnected, useMessage, useSSEActions, useLastSSEMessage, } from './sseStore';
+export type { SSEStore, SSEStoreConnection, SSEStoreConnectionOptions, } from './_types';

package/dist/types/stores/SSE/sseStore.d.ts

@@ -0,0 +1,28 @@
+import { type SSEEventMap, type SSEUnifiedMessage } from '../../utils';
+import type { SSEStore, SSEStoreConnectionOptions } from './_types';
+export declare const useSSEStore: import("zustand").UseBoundStore<import("zustand").StoreApi<SSEStore>>;
+export declare const useSSE: () => {
+    addConnection: (name: string, options: SSEStoreConnectionOptions) => import("./_types").SSEStoreConnection;
+    removeConnection: (name: string) => void;
+};
+export declare const useConnectionClose: () => string | null;
+export declare const useConnectionMessage: (connection: string) => {
+    type: "error";
+    event: Event;
+} | {
+    type: "open";
+    event: Event;
+} | {
+    type: "close";
+    event: Event;
+} | import("../../utils").SSEUnifiedCustomMessage<SSEEventMap, string> | null;
+export declare const useIsConnected: (connection?: string) => boolean;
+export declare function useMessage(): SSEUnifiedMessage<unknown, SSEEventMap> | null;
+export declare function useMessage<T = unknown>(type: 'message', connection?: string): T | string | null;
+export declare function useMessage(type: 'open' | 'error' | 'close', connection?: string): Event | null;
+export declare function useMessage<T = unknown>(type: string, connection?: string): T | string | null;
+export declare const useSSEActions: {
+    addConnection: (name: string, options: SSEStoreConnectionOptions) => import("./_types").SSEStoreConnection;
+    removeConnection: (name: string) => void;
+};
+export declare const useLastSSEMessage: () => SSEUnifiedMessage<unknown, SSEEventMap> | null;

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/index.d.ts

@@ -1,3 +1,4 @@
+export * from './SSE';
 export * from './toast';
 export * from './tip';
 export * from './uploads';

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

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

@@ -0,0 +1,166 @@
+/**
+ * Maps each custom SSE event name to the payload type that event emits.
+ */
+export type SSEEventMap = Record<string, unknown>;
+/**
+ * Parsed SSE payloads can still be raw strings when the event data is not JSON.
+ */
+type SSEParsedData<T> = T | string;
+/**
+ * Restricts custom event names to string keys so they can be used with
+ * `addEventListener`.
+ */
+type SSEEventName<TCustomEvents extends SSEEventMap> = Extract<keyof TCustomEvents, string>;
+/**
+ * Built-in EventSource events represented in unified callback mode.
+ */
+export type SSEUnifiedBuiltInMessage<TMessage> = {
+    type: 'message';
+    data: SSEParsedData<TMessage>;
+    event: MessageEvent;
+} | {
+    type: 'error';
+    event: Event;
+} | {
+    type: 'open';
+    event: Event;
+} | {
+    type: 'close';
+    event: Event;
+};
+export interface SSEConnectionCloseOption<TCustomEvents extends SSEEventMap = Record<string, never>> {
+    event?: SSEEventName<TCustomEvents>;
+    message?: string;
+}
+/**
+ * A custom event in unified callback mode. The `type` determines the shape of
+ * `data`.
+ */
+export type SSEUnifiedCustomMessage<TCustomEvents extends SSEEventMap, TName extends SSEEventName<TCustomEvents> = SSEEventName<TCustomEvents>> = {
+    type: TName;
+    data: SSEParsedData<TCustomEvents[TName]>;
+    event: MessageEvent;
+};
+/**
+ * All messages that can flow through the single unified callback.
+ */
+export type SSEUnifiedMessage<TMessage, TCustomEvents extends SSEEventMap> = SSEUnifiedBuiltInMessage<TMessage> | SSEUnifiedCustomMessage<TCustomEvents>;
+/**
+ * Callback signature for standard mode, where only the default `message`
+ * event is routed to `onMessageCallback`.
+ */
+type SSEStandardMessageCallback<TMessage> = (data: SSEParsedData<TMessage>) => void;
+/**
+ * Callback signature for unified mode, where built-in and custom events are
+ * all routed through a discriminated object.
+ */
+type SSEUnifiedMessageCallback<TMessage, TCustomEvents extends SSEEventMap> = (message: SSEUnifiedMessage<TMessage, TCustomEvents>) => void;
+/**
+ * Declares one custom SSE event. `name` selects a key from the event map, and
+ * `handler` is typed to that event's payload when provided.
+ */
+export interface SSECustomEvent<TCustomEvents extends SSEEventMap, TName extends SSEEventName<TCustomEvents> = SSEEventName<TCustomEvents>> {
+    name: TName;
+    handler?: (data: TCustomEvents[TName]) => void;
+}
+/**
+ * Options shared by both standard and unified message modes.
+ */
+interface SSEConnectionOptionsBase<TCustomEvents extends SSEEventMap = Record<string, never>> {
+    url?: string;
+    options?: EventSourceInit;
+    connectionClose?: SSEConnectionCloseOption<TCustomEvents>;
+    onErrorCallback?: (event: Event) => void;
+    onOpenCallback?: (event: Event) => void;
+    onCloseCallback?: (event: Event) => void;
+    customEvents?: SSECustomEvent<TCustomEvents> | SSECustomEvent<TCustomEvents>[];
+}
+/**
+ * Options for unified mode. When enabled, every built-in and custom event is
+ * emitted through `onMessageCallback`.
+ */
+interface SSEConnectionUnifiedOptions<TMessage = unknown, TCustomEvents extends SSEEventMap = Record<string, never>> extends SSEConnectionOptionsBase<TCustomEvents> {
+    unifiedOnMessage: true;
+    onMessageCallback?: SSEUnifiedMessageCallback<TMessage, TCustomEvents>;
+}
+/**
+ * Options for standard mode. Only the default `message` event payload is sent
+ * to `onMessageCallback`.
+ */
+interface SSEConnectionStandardOptions<TMessage = unknown, TCustomEvents extends SSEEventMap = Record<string, never>> extends SSEConnectionOptionsBase<TCustomEvents> {
+    unifiedOnMessage?: false;
+    onMessageCallback?: SSEStandardMessageCallback<TMessage>;
+}
+/**
+ * Public connection options. The `unifiedOnMessage` flag selects which
+ * callback signature is valid.
+ */
+export type SSEConnectionOptions<TMessage = unknown, TCustomEvents extends SSEEventMap = Record<string, never>> = SSEConnectionStandardOptions<TMessage, TCustomEvents> | SSEConnectionUnifiedOptions<TMessage, TCustomEvents>;
+export declare class SSEConnection<TMessage = unknown, TCustomEvents extends SSEEventMap = Record<string, never>> {
+    private readonly url;
+    private readonly options;
+    private sseConnection;
+    private readonly onMessageCallback?;
+    private readonly onErrorCallback?;
+    private readonly onOpenCallback?;
+    private readonly onCloseCallback?;
+    private readonly connectionClose?;
+    private readonly customEvents;
+    private readonly customEventHandlers;
+    private readonly unifiedOnMessage;
+    /**
+     * Whether the underlying EventSource is currently open.
+     */
+    get connected(): boolean;
+    /**
+     * Direct access to the underlying EventSource instance.
+     */
+    get connection(): EventSource | null;
+    /**
+     * Create an SEE connection instance
+     */
+    constructor(options?: SSEConnectionOptions<TMessage, TCustomEvents>);
+    /**
+     * Safely parse SSE event data. Falls back to the raw string when the payload is not JSON.
+     */
+    private parseEventData;
+    /**
+     * Attach default SEE events
+     */
+    private attachDefaultEventListeners;
+    private emitParsedMessage;
+    private emitUnifiedMessage;
+    private emitCloseEvent;
+    private closeFromConnectionEvent;
+    private shouldCloseFromMessage;
+    private emitUnifiedCustomMessage;
+    /**
+     * Attach custom event listeners to the SSE connection
+     */
+    private attachCustomEventListener;
+    /**
+     * Attach custom event listeners to the SSE connection
+     */
+    private attachCustomEventListeners;
+    /**
+     * Clean up listeners
+     */
+    private detachAllEventListeners;
+    /**
+     * One message received
+     */
+    onMessage: (event: MessageEvent) => void;
+    /**
+     * On error event
+     */
+    onError: (event: Event) => void;
+    /**
+     * On open event
+     */
+    onOpen: (event: Event) => void;
+    /**
+     * Close the SSE connection and release resources.
+     */
+    close: () => void;
+}
+export {};

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

@@ -0,0 +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.2",
+	"version": "0.1.4",
 	"main": "dist/cjs/index.js",
 	"module": "dist/esm/index.mjs",
 	"exports": {
@@ -83,6 +83,11 @@
 			"import": "./dist/esm/utils/index.mjs",
 			"require": "./dist/cjs/utils/index.js"
 		},
+		"./utils/objects": {
+			"types": "./dist/types/utils/objects/index.d.ts",
+			"import": "./dist/esm/utils/objects/index.mjs",
+			"require": "./dist/cjs/utils/objects/index.js"
+		},
 		"./components/*": {
 			"types": "./dist/types/components/*/index.d.ts",
 			"import": "./dist/esm/components/*/index.mjs",

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;

package/dist/esm/chunks/windowStore-CwW0i_le.mjs

@@ -1,71 +0,0 @@
-import { create } from "zustand";
-
-/**
- * Form factor names
- */ var FormFactor;
-
-!function(FormFactor) {
-    FormFactor.Mobile = "mobile", FormFactor.Tablet = "tablet", FormFactor.Desktop = "desktop", 
-    FormFactor.DesktopL = "desktopL", FormFactor.DesktopXL = "desktopXL";
-}(FormFactor || (FormFactor = {}));
-
-/**
- * Use bootstrap breakpoints
- */
-const bootstrapBreakPoints = {
-    [FormFactor.Mobile]: 576,
-    [FormFactor.Tablet]: 768,
-    [FormFactor.Desktop]: 992,
-    [FormFactor.DesktopL]: 1200,
-    [FormFactor.DesktopXL]: 1400
-}, orderedBps = Object.entries(bootstrapBreakPoints).sort((a, b) => -b[1] - a[1]), getFormFactor = width => {
-    if (!width || width <= 0) return FormFactor.Mobile;
-    for (const [formFactor, breakpoint] of orderedBps) if (width >= breakpoint) return formFactor;
-    return FormFactor.Mobile;
-}, initialSize = processWindowSize(), useWindowStore = 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"
-    };
-}
-
-export { FormFactor as F, useWindowStore as u };