dolphin-client 1.0.0

package/dist/offline.d.ts

@@ -0,0 +1,24 @@
+export interface OfflineMutation {
+    id?: number;
+    method: string;
+    path: string;
+    payload: any;
+    timestamp: number;
+}
+export declare class DolphinOffline {
+    client: any;
+    db: any;
+    isOnline: boolean;
+    private memoryCache;
+    private memoryMutations;
+    constructor(client: any);
+    private initDB;
+    private setupNetworkListeners;
+    getCache(key: string): Promise<any>;
+    setCache(key: string, data: any): Promise<void>;
+    queueMutation(method: string, path: string, payload: any): Promise<void>;
+    getMutations(): Promise<OfflineMutation[]>;
+    removeMutation(id: number): Promise<void>;
+    syncMutations(): Promise<void>;
+}
+export declare function attachOffline(clientProto: any): void;

package/dist/pwa.d.ts

@@ -0,0 +1 @@
+export declare function attachPwa(clientProto: any): void;

package/dist/store.d.ts

@@ -0,0 +1,22 @@
+export declare class DolphinStore {
+    client: any;
+    data: Map<string, any>;
+    listeners: Set<any>;
+    subscribed: Set<string>;
+    /** @param {DolphinClient} client */
+    constructor(client: any);
+    /** @private */
+    _getCollection(name: any): any;
+    /** @private */
+    _fetchAndSync(name: any): Promise<void>;
+    /** @private */
+    _applyTransform(state: any): void;
+    /** @private */
+    _handleRemoteUpdate(collection: any, update: any): void;
+    /** Subscribe for React useSyncExternalStore */
+    subscribe(listener: any): () => boolean;
+    /** @param {string} collection */
+    getSnapshot(collection: any): any;
+    /** @private */
+    _notify(): void;
+}

package/dist/store.js

@@ -0,0 +1,131 @@
+export class DolphinStore {
+    /** @param {DolphinClient} client */
+    constructor(client) {
+        this.client = client;
+        /** @type {Map<string, any>} */
+        this.data = new Map();
+        /** @type {Set<function()>} */
+        this.listeners = new Set();
+        /** @type {Set<string>} */
+        this.subscribed = new Set();
+        return new Proxy(this, {
+            get: (target, prop) => {
+                if (prop in target)
+                    return target[prop];
+                if (typeof prop === 'string')
+                    return this._getCollection(prop);
+            }
+        });
+    }
+    /** @private */
+    _getCollection(name) {
+        if (!this.data.has(name)) {
+            const collection = {
+                _rawItems: [],
+                items: [],
+                loading: true,
+                error: null,
+                success: false,
+                _filter: null,
+                _sort: null,
+                where: (fn) => {
+                    collection._filter = fn;
+                    this._applyTransform(collection);
+                    return collection;
+                },
+                orderBy: (key, direction = 'asc') => {
+                    collection._sort = { key, direction };
+                    this._applyTransform(collection);
+                    return collection;
+                },
+                reset: () => {
+                    collection._filter = null;
+                    collection._sort = null;
+                    this._applyTransform(collection);
+                    return collection;
+                },
+            };
+            this.data.set(name, collection);
+            this._fetchAndSync(name);
+        }
+        return this.data.get(name);
+    }
+    /** @private */
+    async _fetchAndSync(name) {
+        const state = this.data.get(name);
+        try {
+            const res = await this.client.api.get(`/${name.toLowerCase()}`);
+            state._rawItems = Array.isArray(res) ? res : (res.data || []);
+            state.loading = false;
+            state.success = true;
+            state.error = null;
+            this._applyTransform(state);
+            if (!this.subscribed.has(name)) {
+                this.client.subscribe(`db:sync/${name.toLowerCase()}`, (update) => {
+                    this._handleRemoteUpdate(name, update);
+                });
+                this.subscribed.add(name);
+            }
+        }
+        catch (e) {
+            state.loading = false;
+            state.success = false;
+            state.error = e.data?.error || e.message || 'Fetch failed';
+            this._notify();
+        }
+    }
+    /** @private */
+    _applyTransform(state) {
+        let result = [...state._rawItems];
+        if (state._filter)
+            result = result.filter(state._filter);
+        if (state._sort) {
+            const { key, direction } = state._sort;
+            result.sort((a, b) => {
+                if (a[key] === b[key])
+                    return 0;
+                return (a[key] > b[key] ? 1 : -1) * (direction === 'asc' ? 1 : -1);
+            });
+        }
+        state.items = result;
+        this._notify();
+    }
+    /** @private */
+    _handleRemoteUpdate(collection, update) {
+        const state = this.data.get(collection);
+        if (!state)
+            return;
+        const { type, data } = update;
+        let items = state._rawItems;
+        if (type === 'create') {
+            items = [...items, data];
+        }
+        else if (type === 'update') {
+            items = items.map(i => (i.id === data.id || i._id === data._id) ? { ...i, ...data } : i);
+        }
+        else if (type === 'delete') {
+            items = items.filter(i => {
+                if (data.id != null && i.id === data.id)
+                    return false;
+                if (data._id != null && i._id === data._id)
+                    return false;
+                return true;
+            });
+        }
+        state._rawItems = items;
+        this._applyTransform(state);
+    }
+    /** Subscribe for React useSyncExternalStore */
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    /** @param {string} collection */
+    getSnapshot(collection) {
+        return this.data.get(collection) || { items: [], loading: false, error: null, success: false };
+    }
+    /** @private */
+    _notify() {
+        this.listeners.forEach(l => l());
+    }
+}

package/dist/testing.d.ts

@@ -0,0 +1,20 @@
+export declare class DolphinTestUtils {
+    static render(html: string): {
+        container: any;
+        find: (sel: string) => any;
+        fireEvent: (el: any, eventType: string) => void;
+    };
+    static mockWebSocket(): {
+        readyState: number;
+        send: (data: string) => void;
+        close: jest.Mock<any, any, any>;
+        onopen: jest.Mock<any, any, any>;
+        onmessage: jest.Mock<any, any, any>;
+        onclose: jest.Mock<any, any, any>;
+        onerror: jest.Mock<any, any, any>;
+        sentMessages: string[];
+    };
+    static simulateClick(el: any): void;
+    static simulateChange(el: any, value: string): void;
+}
+export declare function attachTesting(clientProto: any): void;

package/dist/validation.d.ts

@@ -0,0 +1,2 @@
+export declare function validateField(value: string, rulesStr: string, allValues?: Record<string, string>): string | null;
+export declare function attachValidation(clientProto: any): void;

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "dolphin-client",
+  "version": "1.0.0",
+  "description": "HTML is back! Hookless, framework-agnostic real-time reactive DOM-binding client for Dolphin Server with WebSockets, WebRTC signaling, and offline REST API fallbacks.",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "npm run build:iife && npm run build:esm && npm run build:cjs && tsc",
+    "build:iife": "esbuild ./src/index.ts --bundle --outfile=dist/dolphin-client.js --format=iife --global-name=DolphinModule",
+    "build:esm": "esbuild ./src/index.ts --bundle --outfile=dist/index.js --format=esm",
+    "build:cjs": "esbuild ./src/index.ts --bundle --outfile=dist/index.cjs --format=cjs",
+    "test": "jest"
+  },
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node"
+  },
+  "keywords": [
+    "dolphin",
+    "client",
+    "realtime",
+    "hookless",
+    "reactive",
+    "dom-binding",
+    "websocket",
+    "webrtc",
+    "intercom"
+  ],
+  "author": "Shankar Phuyal",
+  "license": "ISC",
+  "dependencies": {},
+  "devDependencies": {
+    "esbuild": "^0.28.0",
+    "typescript": "^5.4.3",
+    "jest": "^29.7.0",
+    "@types/jest": "^29.5.12",
+    "ts-jest": "^29.1.2"
+  }
+}