hyperstack-react 0.2.5 → 0.3.1

package/dist/index.d.ts

@@ -1,53 +1,8 @@
 import React, { ReactNode } from 'react';
-import * as zustand from 'zustand';
+import { StorageAdapter, StorageAdapterConfig, UpdateCallback, RichUpdateCallback, Update, RichUpdate, ConnectionState, ConnectionManager, SubscriptionRegistry } from 'hyperstack-typescript';
+export { ConnectionManager, ConnectionState, DEFAULT_CONFIG, DEFAULT_MAX_ENTRIES_PER_VIEW, EntityFrame, Frame, FrameMode, FrameOp, FrameProcessor, FrameProcessorConfig, HyperStack, HyperStackConfig, HyperStackError, HyperStackOptions, HyperStackOptionsWithStorage, MemoryAdapter, RichUpdate, RichUpdateCallback, SnapshotEntity, SnapshotFrame, StorageAdapter, StorageAdapterConfig, Subscription, SubscriptionRegistry, Update, UpdateCallback, isSnapshotFrame, isValidFrame, parseFrame, parseFrameFromBlob } from 'hyperstack-typescript';
+import { UseBoundStore, StoreApi } from 'zustand';
 
-interface EntityFrame<T = unknown> {
-    mode: 'state' | 'append' | 'list';
-    entity: string;
-    op: 'create' | 'upsert' | 'patch' | 'delete' | 'snapshot';
-    key: string;
-    data: T;
-    append?: string[];
-}
-interface SnapshotEntity<T = unknown> {
-    key: string;
-    data: T;
-}
-interface SnapshotFrame<T = unknown> {
-    mode: 'state' | 'append' | 'list';
-    entity: string;
-    op: 'snapshot';
-    data: SnapshotEntity<T>[];
-}
-type Frame<T = unknown> = EntityFrame<T> | SnapshotFrame<T>;
-declare function isSnapshotFrame<T>(frame: Frame<T>): frame is SnapshotFrame<T>;
-interface Subscription {
-    view: string;
-    key?: string;
-    partition?: string;
-    filters?: Record<string, string>;
-}
-type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'error' | 'reconnecting';
-interface HyperState<T = unknown> {
-    connectionState: ConnectionState;
-    lastError?: string;
-    entities: Map<string, Map<string, T>>;
-    recentFrames: EntityFrame<T>[];
-}
-interface HyperSDKConfig {
-    websocketUrl?: string;
-    reconnectIntervals?: number[];
-    maxReconnectAttempts?: number;
-    initialSubscriptions?: Subscription[];
-    autoSubscribeDefault?: boolean;
-    maxEntriesPerView?: number | null;
-}
-declare const DEFAULT_CONFIG: HyperSDKConfig;
-declare class HyperStreamError extends Error {
-    code: string;
-    details?: unknown | undefined;
-    constructor(message: string, code: string, details?: unknown | undefined);
-}
 type ViewMode = 'state' | 'list';
 interface NetworkConfig {
     name: string;
@@ -83,6 +38,9 @@ interface HyperstackConfig {
     apiKey?: string;
     autoConnect?: boolean;
     wallet?: WalletAdapter;
+    reconnectIntervals?: number[];
+    maxReconnectAttempts?: number;
+    maxEntriesPerView?: number | null;
 }
 interface WalletAdapter {
     publicKey: string;
@@ -121,86 +79,41 @@ interface ListViewHook<T> {
     use: (params?: ListParams, options?: ViewHookOptions) => ViewHookResult<T[]>;
 }
 
-type FrameHandler = <T>(frame: Frame<T>) => void;
-type StateHandler = (state: ConnectionState, error?: string) => void;
-declare class ConnectionManager {
-    private ws;
-    private config;
-    private reconnectAttempts;
-    private reconnectTimeout;
-    private pingInterval;
-    private currentState;
-    private subscriptionQueue;
-    private activeSubscriptions;
-    private onFrame?;
-    private onStateChange?;
-    constructor(config?: Partial<HyperSDKConfig>);
-    setHandlers(handlers: {
-        onFrame?: FrameHandler;
-        onStateChange?: StateHandler;
-    }): void;
-    getState(): ConnectionState;
-    getConfig(): HyperSDKConfig;
-    connect(): void;
-    disconnect(): void;
-    updateConfig(newConfig: Partial<HyperSDKConfig>): void;
-    subscribe(subscription: Subscription): void;
-    unsubscribe(view: string, key?: string): void;
-    private makeSubKey;
-    private resubscribeActive;
-    private parseBinaryFrame;
-    private updateState;
-    private handleReconnect;
-    private clearReconnectTimeout;
-    private startPingInterval;
-    private stopPingInterval;
-}
-
-declare class ViewData<T = unknown> {
-    private entities;
-    private accessOrder;
-    get(key: string): T | undefined;
-    set(key: string, value: T): void;
-    delete(key: string): boolean;
-    has(key: string): boolean;
-    values(): IterableIterator<T>;
-    keys(): string[];
-    get size(): number;
-    touch(key: string): void;
-    evictOldest(): string | undefined;
-    toMap(): Map<string, T>;
-}
-type SubKey = string;
-interface SubscriptionTracker {
-    subscription: Subscription;
-    refCount: number;
-}
-interface ViewMetadata {
-    mode: ViewMode;
-    keys: string[];
-    lastArgs?: any;
-    lastUpdatedAt?: number;
+interface ZustandState {
+    entities: Map<string, Map<string, unknown>>;
+    connectionState: ConnectionState;
+    lastError?: string;
 }
-interface ViewCache {
-    [viewPath: string]: ViewMetadata;
+interface ZustandActions {
+    _set: <T>(viewPath: string, key: string, data: T) => void;
+    _delete: (viewPath: string, key: string) => void;
+    _clear: (viewPath?: string) => void;
+    _setConnectionState: (state: ConnectionState, error?: string) => void;
 }
-interface HyperStore extends HyperState {
-    handleFrame: <T>(frame: Frame<T>) => void;
-    _incRef: (subscription: Subscription) => void;
-    _decRef: (subscription: Subscription) => void;
-    _getRefCount: (subscription: Subscription) => number;
-    subscribe: (subscription: Subscription) => void;
-    unsubscribe: (entity: string, key?: string) => void;
-    connect: () => void;
-    disconnect: () => void;
-    updateConfig: (config: Partial<HyperSDKConfig>) => void;
-    subscriptionRefs: Map<SubKey, SubscriptionTracker>;
-    connectionManager: ConnectionManager;
-    viewCache: ViewCache;
-    viewDataMap: Map<string, ViewData<unknown>>;
-    maxEntriesPerView: number | null;
+type HyperStackStore = ZustandState & ZustandActions;
+declare class ZustandAdapter implements StorageAdapter {
+    private updateCallbacks;
+    private richUpdateCallbacks;
+    private accessOrder;
+    readonly store: UseBoundStore<StoreApi<HyperStackStore>>;
+    constructor(_config?: StorageAdapterConfig);
+    get<T>(viewPath: string, key: string): T | null;
+    getAll<T>(viewPath: string): T[];
+    getAllSync<T>(viewPath: string): T[] | undefined;
+    getSync<T>(viewPath: string, key: string): T | null | undefined;
+    has(viewPath: string, key: string): boolean;
+    keys(viewPath: string): string[];
+    size(viewPath: string): number;
+    set<T>(viewPath: string, key: string, data: T): void;
+    delete(viewPath: string, key: string): void;
+    clear(viewPath?: string): void;
+    evictOldest(viewPath: string): string | undefined;
+    onUpdate(callback: UpdateCallback): () => void;
+    onRichUpdate(callback: RichUpdateCallback): () => void;
+    notifyUpdate<T>(viewPath: string, key: string, update: Update<T>): void;
+    notifyRichUpdate<T>(viewPath: string, key: string, update: RichUpdate<T>): void;
+    setConnectionState(state: ConnectionState, error?: string): void;
 }
-declare function createHyperStore(config?: Partial<HyperSDKConfig>): zustand.UseBoundStore<zustand.StoreApi<HyperStore>>;
 
 interface SubscriptionHandle {
     view: string;
@@ -209,8 +122,10 @@ interface SubscriptionHandle {
     unsubscribe: () => void;
 }
 interface HyperstackRuntime {
-    store: ReturnType<typeof createHyperStore>;
+    zustandStore: UseBoundStore<StoreApi<HyperStackStore>>;
+    adapter: ZustandAdapter;
     connection: ConnectionManager;
+    subscriptionRegistry: SubscriptionRegistry;
     wallet?: WalletAdapter;
     subscribe(view: string, key?: string, filters?: Record<string, string>): SubscriptionHandle;
     unsubscribe(handle: SubscriptionHandle): void;
@@ -226,6 +141,8 @@ declare function HyperstackProvider({ children, ...config }: HyperstackConfig &
 }): React.JSX.Element;
 declare function useHyperstackContext(): HyperstackContextValue;
 declare function useConnectionState(): ConnectionState;
+declare function useView<T>(viewPath: string): T[];
+declare function useEntity<T>(viewPath: string, key: string): T | null;
 
 type BuildViewInterface<TViews extends Record<string, ViewGroup>> = {
     [K in keyof TViews]: TViews[K] extends {
@@ -261,10 +178,10 @@ type StackClient<TStack extends StackDefinition> = {
     } : {
         useMutation: () => UseMutationReturn;
     };
-    store: HyperstackRuntime['store'];
+    zustandStore: UseBoundStore<StoreApi<HyperStackStore>>;
     runtime: HyperstackRuntime;
 };
 declare function useHyperstack<TStack extends StackDefinition>(stack: TStack): StackClient<TStack>;
 
-export { ConnectionManager, DEFAULT_CONFIG, HyperStreamError, HyperstackProvider, createRuntime, isSnapshotFrame, useConnectionState, useHyperstack, useHyperstackContext };
-export type { ConnectionState, EntityFrame, Frame, HyperSDKConfig, HyperstackConfig, HyperstackRuntime, ListParams, ListViewHook, NetworkConfig, SnapshotEntity, SnapshotFrame, StackDefinition, StateViewHook, Subscription, SubscriptionHandle, TransactionDefinition, UseMutationReturn, ViewHookOptions, ViewHookResult, ViewMode, WalletAdapter };
+export { HyperstackProvider, ZustandAdapter, createRuntime, useConnectionState, useEntity, useHyperstack, useHyperstackContext, useView };
+export type { HyperStackStore, HyperstackConfig, HyperstackRuntime, ListParams, ListViewHook, NetworkConfig, StackDefinition, StateViewHook, SubscriptionHandle, TransactionDefinition, UseMutationReturn, ViewDef, ViewGroup, ViewHookOptions, ViewHookResult, ViewMode, WalletAdapter };