@jumentix/cana-react 0.1.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) XpertMinds
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,38 @@
+# @jumentix/cana-react
+
+React hooks and Redux-friendly helpers for `@jumentix/cana`.
+
+## Install
+
+```bash
+npm install @jumentix/cana @jumentix/cana-react react
+```
+
+## Hooks
+
+```ts
+import { useCanaLiveQuery } from '@jumentix/cana-react';
+
+const { records, status, reload } = useCanaLiveQuery<Task>({
+  client,
+  store: 'tasks',
+  query: { index: 'byCategory', equals: categoryId },
+  getKey: (task) => task.id
+});
+```
+
+`useCanaLiveQuery()` loads a Cana table and keeps it updated from committed
+`CanaChangeEvent` entries. When a query is present it reloads the table on
+matching events, so filtered views stay correct.
+
+## Redux bridge
+
+```ts
+import { connectCanaToRedux } from '@jumentix/cana-react/redux';
+
+const bridge = connectCanaToRedux({
+  client,
+  dispatch: store.dispatch,
+  mapEvent: (event) => ({ type: 'cana/eventCommitted', payload: event })
+});
+```

package/README.pt-BR.md

@@ -0,0 +1,39 @@
+# @jumentix/cana-react
+
+Hooks React e helpers para Redux sobre `@jumentix/cana`.
+
+## Instalação
+
+```bash
+npm install @jumentix/cana @jumentix/cana-react react
+```
+
+## Hooks
+
+```ts
+import { useCanaLiveQuery } from '@jumentix/cana-react';
+
+const { records, status, reload } = useCanaLiveQuery<Task>({
+  client,
+  store: 'tasks',
+  query: { index: 'byCategory', equals: categoryId },
+  getKey: (task) => task.id
+});
+```
+
+`useCanaLiveQuery()` carrega uma tabela Cana e mantém o estado atualizado a
+partir de entradas `CanaChangeEvent` confirmadas. Quando há uma query, o hook
+recarrega a tabela em eventos compatíveis, então visões filtradas continuam
+corretas.
+
+## Bridge Redux
+
+```ts
+import { connectCanaToRedux } from '@jumentix/cana-react/redux';
+
+const bridge = connectCanaToRedux({
+  client,
+  dispatch: store.dispatch,
+  mapEvent: (event) => ({ type: 'cana/eventCommitted', payload: event })
+});
+```

package/dist/collection.d.ts

@@ -0,0 +1,9 @@
+import type { CanaChangeEvent, CanaKey } from '@jumentix/cana';
+export type CanaRecordKeyReader<TRecord> = (record: TRecord) => CanaKey | undefined;
+export type CanaCollectionOptions<TRecord> = {
+    store: string;
+    getKey?: CanaRecordKeyReader<TRecord>;
+    sort?: (a: TRecord, b: TRecord) => number;
+};
+export declare function applyCanaEventToRecords<TRecord>(records: readonly TRecord[], event: CanaChangeEvent, options: CanaCollectionOptions<TRecord>): TRecord[];
+//# sourceMappingURL=collection.d.ts.map

package/dist/collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../src/collection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAE/D,MAAM,MAAM,mBAAmB,CAAC,OAAO,IAAI,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,GAAG,SAAS,CAAC;AAEpF,MAAM,MAAM,qBAAqB,CAAC,OAAO,IAAI;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,mBAAmB,CAAC,OAAO,CAAC,CAAC;IACtC,IAAI,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,KAAK,MAAM,CAAC;CAC3C,CAAC;AAuBF,wBAAgB,uBAAuB,CAAC,OAAO,EAC7C,OAAO,EAAE,SAAS,OAAO,EAAE,EAC3B,KAAK,EAAE,eAAe,EACtB,OAAO,EAAE,qBAAqB,CAAC,OAAO,CAAC,GACtC,OAAO,EAAE,CAgBX"}

package/dist/collection.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyCanaEventToRecords = void 0;
+function defaultGetKey(record) {
+    if (record && typeof record === 'object' && 'id' in record) {
+        return record.id;
+    }
+    return undefined;
+}
+function sameKey(a, b) {
+    if (a instanceof Date && b instanceof Date)
+        return a.getTime() === b.getTime();
+    return Object.is(a, b);
+}
+function sorted(records, sort) {
+    const next = [...records];
+    if (sort)
+        next.sort(sort);
+    return next;
+}
+function applyCanaEventToRecords(records, event, options) {
+    if (event.store !== options.store)
+        return [...records];
+    if (event.type === 'cleared')
+        return [];
+    const getKey = options.getKey ?? defaultGetKey;
+    if (event.type === 'deleted') {
+        return records.filter((record) => !sameKey(getKey(record), event.key));
+    }
+    if (!event.record)
+        return [...records];
+    const record = event.record;
+    const recordKey = getKey(record);
+    const next = records.filter((item) => !sameKey(getKey(item), recordKey));
+    next.push(record);
+    return sorted(next, options.sort);
+}
+exports.applyCanaEventToRecords = applyCanaEventToRecords;

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+import type { CanaChangeEvent, CanaClient, CanaQuery } from '@jumentix/cana';
+import { applyCanaEventToRecords, type CanaCollectionOptions, type CanaRecordKeyReader } from './collection';
+export type { CanaCollectionOptions, CanaRecordKeyReader };
+export { applyCanaEventToRecords };
+export type CanaHookStatus = 'idle' | 'opening' | 'loading' | 'ready' | 'error';
+export type UseCanaClientResult<TClient extends CanaClient> = {
+    client: TClient | null;
+    status: CanaHookStatus;
+    error: unknown;
+};
+export declare function useCanaClient<TClient extends CanaClient>(create: () => TClient | Promise<TClient>, deps?: readonly unknown[]): UseCanaClientResult<TClient>;
+export type UseCanaSubscriptionOptions = {
+    enabled?: boolean;
+    sinceCursor?: number;
+    onError?: (error: unknown) => void;
+};
+export declare function useCanaSubscription(client: CanaClient | null | undefined, listener: (event: CanaChangeEvent) => void, options?: UseCanaSubscriptionOptions): void;
+export type UseCanaLiveQueryOptions<TRecord> = {
+    client: CanaClient | null | undefined;
+    store: string;
+    query?: CanaQuery;
+    enabled?: boolean;
+    getKey?: CanaRecordKeyReader<TRecord>;
+    sort?: (a: TRecord, b: TRecord) => number;
+    reloadOnEvent?: boolean;
+    onError?: (error: unknown) => void;
+};
+export type UseCanaLiveQueryResult<TRecord> = {
+    records: TRecord[];
+    status: CanaHookStatus;
+    error: unknown;
+    reload: () => Promise<TRecord[]>;
+};
+export declare function useCanaLiveQuery<TRecord>(options: UseCanaLiveQueryOptions<TRecord>): UseCanaLiveQueryResult<TRecord>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,eAAe,EACf,UAAU,EACV,SAAS,EACV,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,uBAAuB,EACvB,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,EACzB,MAAM,cAAc,CAAC;AAEtB,YAAY,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,CAAC;AAC3D,OAAO,EAAE,uBAAuB,EAAE,CAAC;AAEnC,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,GAAG,OAAO,CAAC;AAEhF,MAAM,MAAM,mBAAmB,CAAC,OAAO,SAAS,UAAU,IAAI;IAC5D,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;IACvB,MAAM,EAAE,cAAc,CAAC;IACvB,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,wBAAgB,aAAa,CAAC,OAAO,SAAS,UAAU,EACtD,MAAM,EAAE,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,EACxC,IAAI,GAAE,SAAS,OAAO,EAAO,GAC5B,mBAAmB,CAAC,OAAO,CAAC,CAuC9B;AAED,MAAM,MAAM,0BAA0B,GAAG;IACvC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACpC,CAAC;AAEF,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,UAAU,GAAG,IAAI,GAAG,SAAS,EACrC,QAAQ,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,EAC1C,OAAO,GAAE,0BAA+B,GACvC,IAAI,CAgBN;AAED,MAAM,MAAM,uBAAuB,CAAC,OAAO,IAAI;IAC7C,MAAM,EAAE,UAAU,GAAG,IAAI,GAAG,SAAS,CAAC;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,mBAAmB,CAAC,OAAO,CAAC,CAAC;IACtC,IAAI,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,KAAK,MAAM,CAAC;IAC1C,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,sBAAsB,CAAC,OAAO,IAAI;IAC5C,OAAO,EAAE,OAAO,EAAE,CAAC;IACnB,MAAM,EAAE,cAAc,CAAC;IACvB,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;CAClC,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,OAAO,EACtC,OAAO,EAAE,uBAAuB,CAAC,OAAO,CAAC,GACxC,sBAAsB,CAAC,OAAO,CAAC,CAqEjC"}

package/dist/index.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCanaLiveQuery = exports.useCanaSubscription = exports.useCanaClient = exports.applyCanaEventToRecords = void 0;
+const react_1 = require("react");
+const collection_1 = require("./collection");
+Object.defineProperty(exports, "applyCanaEventToRecords", { enumerable: true, get: function () { return collection_1.applyCanaEventToRecords; } });
+function useCanaClient(create, deps = []) {
+    const [client, setClient] = (0, react_1.useState)(null);
+    const [status, setStatus] = (0, react_1.useState)('idle');
+    const [error, setError] = (0, react_1.useState)(null);
+    (0, react_1.useEffect)(() => {
+        let alive = true;
+        let opened = null;
+        setStatus('opening');
+        setError(null);
+        Promise.resolve(create())
+            .then(async (next) => {
+            opened = next;
+            await next.open();
+            if (!alive) {
+                await next.close();
+                return;
+            }
+            setClient(next);
+            setStatus('ready');
+        })
+            .catch((err) => {
+            if (!alive)
+                return;
+            setError(err);
+            setStatus('error');
+        });
+        return () => {
+            alive = false;
+            setClient(null);
+            if (opened) {
+                opened.close().catch(() => undefined);
+            }
+        };
+    }, deps);
+    return { client, status, error };
+}
+exports.useCanaClient = useCanaClient;
+function useCanaSubscription(client, listener, options = {}) {
+    const listenerRef = (0, react_1.useRef)(listener);
+    listenerRef.current = listener;
+    (0, react_1.useEffect)(() => {
+        if (!client || options.enabled === false)
+            return undefined;
+        try {
+            return client.subscribe((event) => listenerRef.current(event), options.sinceCursor === undefined ? undefined : { sinceCursor: options.sinceCursor });
+        }
+        catch (error) {
+            options.onError?.(error);
+            return undefined;
+        }
+    }, [client, options.enabled, options.sinceCursor, options.onError]);
+}
+exports.useCanaSubscription = useCanaSubscription;
+function useCanaLiveQuery(options) {
+    const { client, store, enabled = true, getKey, sort, onError } = options;
+    const queryKey = JSON.stringify(options.query ?? null);
+    const query = (0, react_1.useMemo)(() => options.query, [queryKey]);
+    const reloadOnEvent = options.reloadOnEvent ?? Boolean(options.query);
+    const [records, setRecords] = (0, react_1.useState)([]);
+    const [status, setStatus] = (0, react_1.useState)('idle');
+    const [error, setError] = (0, react_1.useState)(null);
+    const reload = (0, react_1.useCallback)(async () => {
+        if (!client || !enabled)
+            return [];
+        setStatus('loading');
+        setError(null);
+        try {
+            const next = [...await client.table(store).query(query)];
+            if (sort)
+                next.sort(sort);
+            setRecords(next);
+            setStatus('ready');
+            return next;
+        }
+        catch (err) {
+            setError(err);
+            setStatus('error');
+            onError?.(err);
+            return [];
+        }
+    }, [client, enabled, onError, query, sort, store]);
+    (0, react_1.useEffect)(() => {
+        if (!client || !enabled)
+            return undefined;
+        let alive = true;
+        const safeReload = async () => {
+            if (!alive)
+                return;
+            await reload();
+        };
+        safeReload().catch((err) => onError?.(err));
+        const stop = client.subscribe((event) => {
+            if (event.store !== store)
+                return;
+            if (reloadOnEvent) {
+                safeReload().catch((err) => onError?.(err));
+                return;
+            }
+            const collectionOptions = {
+                store,
+                getKey,
+                sort
+            };
+            setRecords((current) => (0, collection_1.applyCanaEventToRecords)(current, event, collectionOptions));
+        });
+        return () => {
+            alive = false;
+            stop();
+        };
+    }, [client, enabled, getKey, reload, reloadOnEvent, sort, store]);
+    return {
+        records,
+        status,
+        error,
+        reload
+    };
+}
+exports.useCanaLiveQuery = useCanaLiveQuery;

package/dist/index.mjs

@@ -0,0 +1,172 @@
+// src/index.ts
+import {
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+
+// src/collection.ts
+function defaultGetKey(record) {
+  if (record && typeof record === "object" && "id" in record) {
+    return record.id;
+  }
+  return;
+}
+function sameKey(a, b) {
+  if (a instanceof Date && b instanceof Date)
+    return a.getTime() === b.getTime();
+  return Object.is(a, b);
+}
+function sorted(records, sort) {
+  const next = [...records];
+  if (sort)
+    next.sort(sort);
+  return next;
+}
+function applyCanaEventToRecords(records, event, options) {
+  if (event.store !== options.store)
+    return [...records];
+  if (event.type === "cleared")
+    return [];
+  const getKey = options.getKey ?? defaultGetKey;
+  if (event.type === "deleted") {
+    return records.filter((record2) => !sameKey(getKey(record2), event.key));
+  }
+  if (!event.record)
+    return [...records];
+  const record = event.record;
+  const recordKey = getKey(record);
+  const next = records.filter((item) => !sameKey(getKey(item), recordKey));
+  next.push(record);
+  return sorted(next, options.sort);
+}
+
+// src/index.ts
+function useCanaClient(create, deps = []) {
+  const [client, setClient] = useState(null);
+  const [status, setStatus] = useState("idle");
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    let alive = true;
+    let opened = null;
+    setStatus("opening");
+    setError(null);
+    Promise.resolve(create()).then(async (next) => {
+      opened = next;
+      await next.open();
+      if (!alive) {
+        await next.close();
+        return;
+      }
+      setClient(next);
+      setStatus("ready");
+    }).catch((err) => {
+      if (!alive)
+        return;
+      setError(err);
+      setStatus("error");
+    });
+    return () => {
+      alive = false;
+      setClient(null);
+      if (opened) {
+        opened.close().catch(() => {
+          return;
+        });
+      }
+    };
+  }, deps);
+  return { client, status, error };
+}
+function useCanaSubscription(client, listener, options = {}) {
+  const listenerRef = useRef(listener);
+  listenerRef.current = listener;
+  useEffect(() => {
+    if (!client || options.enabled === false)
+      return;
+    try {
+      return client.subscribe((event) => listenerRef.current(event), options.sinceCursor === undefined ? undefined : { sinceCursor: options.sinceCursor });
+    } catch (error) {
+      options.onError?.(error);
+      return;
+    }
+  }, [client, options.enabled, options.sinceCursor, options.onError]);
+}
+function useCanaLiveQuery(options) {
+  const {
+    client,
+    store,
+    enabled = true,
+    getKey,
+    sort,
+    onError
+  } = options;
+  const queryKey = JSON.stringify(options.query ?? null);
+  const query = useMemo(() => options.query, [queryKey]);
+  const reloadOnEvent = options.reloadOnEvent ?? Boolean(options.query);
+  const [records, setRecords] = useState([]);
+  const [status, setStatus] = useState("idle");
+  const [error, setError] = useState(null);
+  const reload = useCallback(async () => {
+    if (!client || !enabled)
+      return [];
+    setStatus("loading");
+    setError(null);
+    try {
+      const next = [...await client.table(store).query(query)];
+      if (sort)
+        next.sort(sort);
+      setRecords(next);
+      setStatus("ready");
+      return next;
+    } catch (err) {
+      setError(err);
+      setStatus("error");
+      onError?.(err);
+      return [];
+    }
+  }, [client, enabled, onError, query, sort, store]);
+  useEffect(() => {
+    if (!client || !enabled)
+      return;
+    let alive = true;
+    const safeReload = async () => {
+      if (!alive)
+        return;
+      await reload();
+    };
+    safeReload().catch((err) => onError?.(err));
+    const stop = client.subscribe((event) => {
+      if (event.store !== store)
+        return;
+      if (reloadOnEvent) {
+        safeReload().catch((err) => onError?.(err));
+        return;
+      }
+      const collectionOptions = {
+        store,
+        getKey,
+        sort
+      };
+      setRecords((current) => applyCanaEventToRecords(current, event, collectionOptions));
+    });
+    return () => {
+      alive = false;
+      stop();
+    };
+  }, [client, enabled, getKey, reload, reloadOnEvent, sort, store]);
+  return {
+    records,
+    status,
+    error,
+    reload
+  };
+}
+export {
+  useCanaSubscription,
+  useCanaLiveQuery,
+  useCanaClient,
+  applyCanaEventToRecords
+};

package/dist/redux.d.ts

@@ -0,0 +1,15 @@
+import type { CanaChangeEvent, CanaClient } from '@jumentix/cana';
+export type CanaReduxDispatch<TAction> = (action: TAction) => unknown;
+export type CanaReduxBridge = {
+    stop: () => void;
+    getLastCursor: () => number;
+};
+export type ConnectCanaToReduxOptions<TAction> = {
+    client: CanaClient;
+    dispatch: CanaReduxDispatch<TAction>;
+    mapEvent: (event: CanaChangeEvent) => TAction | readonly TAction[] | undefined;
+    sinceCursor?: number;
+    onError?: (error: unknown) => void;
+};
+export declare function connectCanaToRedux<TAction>(options: ConnectCanaToReduxOptions<TAction>): CanaReduxBridge;
+//# sourceMappingURL=redux.d.ts.map

package/dist/redux.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redux.d.ts","sourceRoot":"","sources":["../src/redux.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAElE,MAAM,MAAM,iBAAiB,CAAC,OAAO,IAAI,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,CAAC;AAEtE,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,aAAa,EAAE,MAAM,MAAM,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,yBAAyB,CAAC,OAAO,IAAI;IAC/C,MAAM,EAAE,UAAU,CAAC;IACnB,QAAQ,EAAE,iBAAiB,CAAC,OAAO,CAAC,CAAC;IACrC,QAAQ,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,OAAO,GAAG,SAAS,OAAO,EAAE,GAAG,SAAS,CAAC;IAC/E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACpC,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,OAAO,EACxC,OAAO,EAAE,yBAAyB,CAAC,OAAO,CAAC,GAC1C,eAAe,CAyBjB"}

package/dist/redux.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectCanaToRedux = void 0;
+function connectCanaToRedux(options) {
+    let lastCursor = options.sinceCursor ?? 0;
+    let stop = () => { };
+    try {
+        stop = options.client.subscribe((event) => {
+            const mapped = options.mapEvent(event);
+            if (Array.isArray(mapped)) {
+                for (const action of mapped) {
+                    options.dispatch(action);
+                }
+            }
+            else if (mapped !== undefined) {
+                options.dispatch(mapped);
+            }
+            lastCursor = event.cursor;
+        }, options.sinceCursor === undefined ? undefined : { sinceCursor: options.sinceCursor });
+    }
+    catch (error) {
+        options.onError?.(error);
+        throw error;
+    }
+    return {
+        stop,
+        getLastCursor: () => lastCursor
+    };
+}
+exports.connectCanaToRedux = connectCanaToRedux;

package/dist/redux.mjs

@@ -0,0 +1,28 @@
+// src/redux.ts
+function connectCanaToRedux(options) {
+  let lastCursor = options.sinceCursor ?? 0;
+  let stop = () => {};
+  try {
+    stop = options.client.subscribe((event) => {
+      const mapped = options.mapEvent(event);
+      if (Array.isArray(mapped)) {
+        for (const action of mapped) {
+          options.dispatch(action);
+        }
+      } else if (mapped !== undefined) {
+        options.dispatch(mapped);
+      }
+      lastCursor = event.cursor;
+    }, options.sinceCursor === undefined ? undefined : { sinceCursor: options.sinceCursor });
+  } catch (error) {
+    options.onError?.(error);
+    throw error;
+  }
+  return {
+    stop,
+    getLastCursor: () => lastCursor
+  };
+}
+export {
+  connectCanaToRedux
+};

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@jumentix/cana-react",
+  "version": "0.1.0",
+  "description": "React hooks and Redux-friendly helpers for @jumentix/cana.",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "default": "./dist/index.mjs"
+    },
+    "./redux": {
+      "types": "./dist/redux.d.ts",
+      "import": "./dist/redux.mjs",
+      "require": "./dist/redux.js",
+      "default": "./dist/redux.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md",
+    "README.pt-BR.md",
+    "LICENSE.md"
+  ],
+  "peerDependencies": {
+    "@jumentix/cana": "^0.1.0",
+    "react": ">=18.0.0 || >=19.0.0"
+  },
+  "devDependencies": {
+    "@jumentix/cana": "0.1.0",
+    "@types/react": "19.2.18",
+    "@types/react-test-renderer": "19.3.0",
+    "react": "19.2.8",
+    "react-test-renderer": "19.3.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json --noEmit false && bun run build:esm",
+    "clean": "rm -rf dist",
+    "build:esm": "bun build src/index.ts --outfile dist/index.mjs --format esm --target browser --external react --external @jumentix/cana && bun build src/redux.ts --outfile dist/redux.mjs --format esm --target browser --external @jumentix/cana",
+    "test": "bun test --isolate test",
+    "lint": "echo \"cana-react: covered by the root eslint run\"",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "prepublishOnly": "bun run clean && bun run build"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/web2solutions/Jumentix.git",
+    "directory": "packages/cana-react"
+  },
+  "homepage": "https://jumentix-website.vercel.app",
+  "bugs": {
+    "url": "https://github.com/web2solutions/Jumentix/issues"
+  },
+  "keywords": [
+    "indexeddb",
+    "offline-first",
+    "react",
+    "redux",
+    "jumentix",
+    "cana"
+  ]
+}