@apple-pie/slice 0.1.1 → 0.1.3

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

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

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

@@ -1,4 +1,4 @@
-import type { ToolTip } from '../../uikit/sharedTypes';
+import type { ToolTip } from '../../components/sharedTypes';
 export interface TipStore {
     tip: ToolTip | null;
     actions: {

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

@@ -1,4 +1,4 @@
-import type { ToastType } from '../../uikit/Toast';
+import type { ToastType } from '../../components/Toast';
 export type Toast = {
     message: string | null;
     duration?: number;

package/dist/types/utils/functions/colors.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Create a tint value from a hex color
+ */
+export declare const tintFromColor: (hex: string, percent: number) => string;
+/**
+ * Adds the desired opacity level to a hex or RGB color string
+ */
+export declare const addOpacity: (color: string, opacity: number) => string;

package/dist/types/{util → utils/functions}/files.d.ts

@@ -2,7 +2,7 @@ export declare function nameAndExtension(fileName: string): {
     name: string;
     ext: string;
 };
-export declare function fileIconName(extension: string): "other" | "text" | "sheet" | "image" | "pdf" | "code" | "md" | "preso" | "audio" | "video" | "clipboard";
+export declare function fileIconName(extension: string): "other" | "text" | "sheet" | "image" | "video" | "audio" | "pdf" | "code" | "md" | "preso" | "clipboard";
 /**
  * Create a text file from clipboard content placing a clipboard file extension
  */

package/dist/types/{util/utils.d.ts → utils/functions/misc.d.ts}

@@ -48,6 +48,6 @@ export declare function setStyle(value: string | number | undefined, defaultVal?
  */
 export declare const copyToClipboard: (rawContent: string) => Promise<boolean>;
 /**
- * Create a tint value from a hex color
+ * Get normalized percent value from number or string
  */
-export declare const tintFromColor: (hex: string, percent: number) => string;
+export declare function normalizedPercent(value: number | string): number;

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

@@ -0,0 +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';

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@apple-pie/slice",
-	"version": "0.1.1",
+	"version": "0.1.3",
 	"main": "dist/cjs/index.js",
 	"module": "dist/esm/index.mjs",
 	"exports": {
@@ -78,10 +78,20 @@
 			"import": "./dist/esm/theme/themes.mjs",
 			"require": "./dist/cjs/theme/themes.js"
 		},
-		"./uikit/*": {
-			"types": "./dist/types/uikit/*/index.d.ts",
-			"import": "./dist/esm/uikit/*/index.mjs",
-			"require": "./dist/cjs/uikit/*/index.js"
+		"./utils": {
+			"types": "./dist/types/utils/index.d.ts",
+			"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",
+			"require": "./dist/cjs/components/*/index.js"
 		}
 	},
 	"files": ["dist", "README.md", "scripts/copy-assets.mjs"],