@parallax-rn/sdk 0.0.0-stage → 0.1.0-beta.2

package/dist/stores.d.ts

@@ -0,0 +1,25 @@
+import type { HostGlobal } from './host.js';
+import type { SdkLimits } from './limits.js';
+export interface StoreOptions {
+    /** Redux only: wraps `dispatch` to put the last action's `type` on the snapshot. Off by default because it changes the store object. */
+    readonly actions?: boolean;
+}
+export declare class StoreAdapters {
+    private readonly deps;
+    private readonly tracked;
+    private started;
+    constructor(deps: {
+        readonly emit: (source: string, data: unknown) => void;
+        readonly host: HostGlobal;
+        readonly limits: SdkLimits;
+    });
+    registerStore(name: string, store: unknown, options?: StoreOptions): () => void;
+    registerQueryClient(name: string, client: unknown): () => void;
+    /** Begins reading the registered stores (the SDK was started). */
+    start(): void;
+    stop(): void;
+    private checkName;
+    private queryCacheOf;
+    private add;
+}
+//# sourceMappingURL=stores.d.ts.map

package/dist/stores.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoreAdapters = void 0;
+// Store adapters (plan 0013, 13.9): `registerStore` takes anything with `getState()` and `subscribe(listener)` (Redux, Zustand, a hand-made store) and `registerQueryClient` a TanStack
+// Query client (`getQueryCache().getAll()` and `.subscribe`). Duck-typed: no store library is imported. Each becomes the source `state:<name>` / `query:<name>`; an entry is a masked, size-bounded
+// snapshot, at most one per `snapshotIntervalMs`, and none when nothing changed. A registration reads the app only while the SDK is started (never in a release build) and nothing it does throws into the app.
+const protocol_1 = require("@parallax-rn/protocol");
+const snapshot_js_1 = require("./snapshot.js");
+const isObjectLike = (value) => (typeof value === 'object' || typeof value === 'function') && value !== null;
+/** Calls whatever a `subscribe` returned to end the subscription: a function (Redux, Zustand) or an object with `unsubscribe` (observable style). */
+function unsubscribe(handle) {
+    try {
+        if (typeof handle === 'function')
+            handle();
+        else if (isObjectLike(handle) && typeof handle.unsubscribe === 'function')
+            handle.unsubscribe();
+    }
+    catch {
+        /* ending a subscription must never break the app */
+    }
+}
+class StoreAdapters {
+    constructor(deps) {
+        this.deps = deps;
+        this.tracked = new Map();
+        this.started = false;
+    }
+    registerStore(name, store, options = {}) {
+        const source = `state:${this.checkName(name)}`;
+        if (!isObjectLike(store) || typeof store.getState !== 'function' || typeof store.subscribe !== 'function') {
+            throw new TypeError(`registerStore("${name}"): expected a store with getState() and subscribe(listener), like Redux's store or Zustand's hook`);
+        }
+        const target = store;
+        let lastAction = '';
+        let restore = null;
+        return this.add(source, 'snapshot', () => target.getState(), listener => target.subscribe(listener), () => {
+            const original = target.dispatch;
+            if (!options.actions || typeof original !== 'function')
+                return;
+            const wrapper = function (action) {
+                if (isObjectLike(action) && typeof action.type === 'string')
+                    lastAction = action.type;
+                return original.call(target, action);
+            };
+            target.dispatch = wrapper;
+            restore = () => {
+                if (target.dispatch === wrapper)
+                    target.dispatch = original;
+            };
+        }, () => {
+            if (restore)
+                restore();
+            restore = null;
+        }, () => {
+            const action = lastAction;
+            lastAction = '';
+            return action;
+        });
+    }
+    registerQueryClient(name, client) {
+        const source = `query:${this.checkName(name)}`;
+        const cache = isObjectLike(client) && typeof client.getQueryCache === 'function' ? this.queryCacheOf(client) : null;
+        if (!isObjectLike(client) || cache === null) {
+            throw new TypeError(`registerQueryClient("${name}"): expected a TanStack Query client with getQueryCache().getAll() and .subscribe()`);
+        }
+        const { limits } = this.deps;
+        return this.add(source, 'query', () => {
+            const queries = client.getQueryCache().getAll();
+            return queries.map(query => queryItem(query, limits));
+        }, listener => client.getQueryCache().subscribe(listener), null, null, null);
+    }
+    /** Begins reading the registered stores (the SDK was started). */
+    start() {
+        if (this.started)
+            return;
+        this.started = true;
+        this.tracked.forEach(tracked => tracked.start());
+    }
+    stop() {
+        if (!this.started)
+            return;
+        this.started = false;
+        this.tracked.forEach(tracked => tracked.stop());
+    }
+    checkName(name) {
+        if (!(0, protocol_1.isSourceName)(`state:${name}`))
+            throw new TypeError(`a store name is 1 to 64 letters, digits, ".", "_" or "-", not "${String(name)}"`);
+        return name;
+    }
+    queryCacheOf(client) {
+        try {
+            const cache = client.getQueryCache();
+            return isObjectLike(cache) && typeof cache.getAll === 'function' && typeof cache.subscribe === 'function' ? cache : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    add(source, kind, read, subscribe, onStart, onStop, takeAction) {
+        var _a;
+        const { emit, host, limits } = this.deps;
+        let timer = null;
+        let handle = null;
+        let active = false;
+        let lastJson = '';
+        let last;
+        let lastItems = {};
+        const take = () => {
+            timer = null;
+            if (!active)
+                return;
+            try {
+                const snapshot = (0, snapshot_js_1.snapshotOf)(read(), limits.stateMaxChars, kind === 'query' ? limits.stateMaxDepth + 2 : limits.stateMaxDepth);
+                const json = JSON.stringify(snapshot.value);
+                const action = takeAction ? takeAction() : '';
+                if (json === lastJson && action === '')
+                    return;
+                const data = { kind, state: snapshot.value };
+                if (lastJson !== '') {
+                    if (kind === 'query') {
+                        const items = byHash(snapshot.value);
+                        data.changedKeys = Object.keys(items).filter(hash => items[hash] !== lastItems[hash]).slice(0, 30);
+                        lastItems = items;
+                    }
+                    else {
+                        data.changedKeys = (0, snapshot_js_1.changedPaths)(last, snapshot.value);
+                    }
+                }
+                else if (kind === 'query') {
+                    lastItems = byHash(snapshot.value);
+                }
+                if (action !== '')
+                    data.action = action.slice(0, 100);
+                if (snapshot.truncated)
+                    data.truncated = true;
+                lastJson = json;
+                last = snapshot.value;
+                emit(source, data);
+            }
+            catch {
+                /* a store that throws gives no snapshot this time; the next change tries again */
+            }
+        };
+        const schedule = () => {
+            if (timer !== null || !active)
+                return;
+            if (typeof host.setTimeout !== 'function')
+                take();
+            else
+                timer = host.setTimeout(take, limits.snapshotIntervalMs);
+        };
+        const tracked = {
+            start: () => {
+                if (active)
+                    return;
+                active = true;
+                try {
+                    if (onStart)
+                        onStart();
+                    handle = subscribe(schedule);
+                }
+                catch {
+                    /* a store whose subscribe throws is not followed */
+                }
+                take();
+            },
+            stop: () => {
+                if (!active)
+                    return;
+                active = false;
+                if (timer !== null && typeof host.clearTimeout === 'function')
+                    host.clearTimeout(timer);
+                timer = null;
+                unsubscribe(handle);
+                handle = null;
+                if (onStop)
+                    onStop();
+            },
+        };
+        (_a = this.tracked.get(source)) === null || _a === void 0 ? void 0 : _a.stop();
+        this.tracked.set(source, tracked);
+        if (this.started)
+            tracked.start();
+        return () => {
+            tracked.stop();
+            if (this.tracked.get(source) === tracked)
+                this.tracked.delete(source);
+        };
+    }
+}
+exports.StoreAdapters = StoreAdapters;
+/** One TanStack Query `Query` as a plain item: no function of the app is called, `data` is cut to its own budget. */
+function queryItem(query, limits) {
+    const q = isObjectLike(query) ? query : {};
+    const state = isObjectLike(q.state) ? q.state : {};
+    const error = isObjectLike(state.error) && typeof state.error.message === 'string' ? state.error.message : state.error;
+    const data = (0, snapshot_js_1.snapshotOf)(state.data, limits.queryDataMaxChars, limits.stateMaxDepth);
+    return {
+        hash: q.queryHash,
+        queryKey: q.queryKey,
+        status: state.status,
+        fetchStatus: state.fetchStatus,
+        dataUpdatedAt: state.dataUpdatedAt,
+        errorUpdateCount: state.errorUpdateCount,
+        ...(error === undefined || error === null ? {} : { error }),
+        ...(state.data === undefined ? {} : { data: data.value }),
+        ...(data.truncated ? { dataTruncated: true } : {}),
+    };
+}
+/** The per-query JSON of a snapshot's array, by hash, to tell which queries changed. */
+function byHash(state) {
+    const out = {};
+    if (!Array.isArray(state))
+        return out;
+    for (let i = 0; i < state.length; i++) {
+        const item = state[i];
+        out[typeof (item === null || item === void 0 ? void 0 : item.hash) === 'string' ? item.hash : String(i)] = JSON.stringify(item);
+    }
+    return out;
+}

package/dist/version.d.ts

@@ -0,0 +1,3 @@
+/** Version of this package, reported in the handshake for diagnostics. A test keeps it equal to package.json. */
+export declare const SDK_VERSION = "0.1.0-beta.2";
+//# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDK_VERSION = void 0;
+/** Version of this package, reported in the handshake for diagnostics. A test keeps it equal to package.json. */
+exports.SDK_VERSION = '0.1.0-beta.2';

package/package.json

@@ -1,6 +1,21 @@
 {
   "name": "@parallax-rn/sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-beta.2",
+  "description": "Dev-only in-app SDK for Parallax for React Native: ring buffers for logs and errors, push through a CDP binding, command registry. Tested on React Native 0.87.1 (no third-party dependencies).",
+  "license": "SEE LICENSE IN LICENSE",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "!dist/**/*.test.*",
+    "!dist/testing",
+    "!dist/*.tsbuildinfo",
+    "!dist/**/*.map"
+  ],
+  "engines": {
+    "node": "^20.19.4 || ^22.13.0 || ^24.3.0 || >=25.0.0"
+  },
+  "dependencies": {
+    "@parallax-rn/protocol": "0.1.0-beta.2"
+  }
+}