@koolbase/core 12.9.0 → 12.11.0

package/dist/cjs/collection-controller.d.ts

@@ -8,6 +8,13 @@ export interface CollectionQuery {
     orderDesc?: boolean;
     /** Page size; the server's default (20) when absent. */
     limit?: number;
+    /**
+     * Re-read page one, silently, when Koolbase realtime reports a record
+     * created, updated or deleted in this collection (debounced: a burst is one
+     * read). Realtime needs a signed-in user; until there is one, the list
+     * behaves as a normal list and goes live once the session exists.
+     */
+    live?: boolean;
 }
 export interface CollectionState {
     readonly status: CollectionStatus;
@@ -39,6 +46,8 @@ export declare class KoolbaseCollectionController {
     private laterPages;
     private nextOffset;
     private unregister;
+    private unlive;
+    private liveTimer;
     constructor(db: QueryReader, collection: string, query?: CollectionQuery);
     getState(): CollectionState;
     /** Called on every change. Returns the unsubscribe. */
@@ -53,6 +62,11 @@ export declare class KoolbaseCollectionController {
      * shown stays while it runs, and stays if it fails.
      */
     private refreshAfterWrite;
+    /**
+     * A change someone made, reported by realtime: page one again, silently, as
+     * after a write -- once per burst (250 ms), not once per event.
+     */
+    private scheduleLiveRefresh;
     /**
      * The next page, appended. Does nothing unless loaded with more to load.
      * If rows are added or removed on the server between pages, one can be

package/dist/cjs/collection-controller.js

@@ -25,6 +25,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KoolbaseCollectionController = exports.initialCollectionState = void 0;
 exports.collectionQueryKey = collectionQueryKey;
+const live_source_js_1 = require("./live-source.js");
 const query_refresh_js_1 = require("./query-refresh.js");
 exports.initialCollectionState = Object.freeze({
     status: 'loading',
@@ -49,6 +50,8 @@ function collectionQueryKey(collection, query = {}) {
         query.orderBy ?? null,
         query.orderDesc === true,
         query.limit ?? null,
+        // Only when live: every other query keeps the key it always had.
+        ...(query.live === true ? ['live'] : []),
     ]);
 }
 /** Page one, then the later pages without any record already shown. */
@@ -76,6 +79,9 @@ class KoolbaseCollectionController {
         this.nextOffset = 0;
         // A write to this collection re-runs this query (query-refresh.ts).
         this.unregister = null;
+        // A live list's realtime subscription, and its pending debounced re-read.
+        this.unlive = null;
+        this.liveTimer = null;
         this.db = db;
         this.collection = collection;
         this.spec = query;
@@ -97,6 +103,9 @@ class KoolbaseCollectionController {
         if (this.disposed)
             return;
         this.unregister ?? (this.unregister = (0, query_refresh_js_1.registerQueryRefresher)(this.collection, () => this.refreshAfterWrite()));
+        if (this.spec.live === true) {
+            this.unlive ?? (this.unlive = (0, live_source_js_1.liveSource)()?.subscribe(this.collection, () => this.scheduleLiveRefresh()) ?? null);
+        }
         await this.firstPage('default');
     }
     /** Page one again, from the server. What is shown stays while it runs, and stays if it fails. */
@@ -118,6 +127,20 @@ class KoolbaseCollectionController {
             return;
         await this.firstPage('network-only');
     }
+    /**
+     * A change someone made, reported by realtime: page one again, silently, as
+     * after a write -- once per burst (250 ms), not once per event.
+     */
+    scheduleLiveRefresh() {
+        if (this.disposed || this.liveTimer)
+            return;
+        this.liveTimer = setTimeout(() => {
+            this.liveTimer = null;
+            void this.refreshAfterWrite();
+        }, 250);
+        // A pending re-read must not be what keeps a Node process alive.
+        this.liveTimer.unref?.();
+    }
     /**
      * The next page, appended. Does nothing unless loaded with more to load.
      * If rows are added or removed on the server between pages, one can be
@@ -153,6 +176,12 @@ class KoolbaseCollectionController {
         this.disposed = true;
         this.unregister?.();
         this.unregister = null;
+        this.unlive?.();
+        this.unlive = null;
+        if (this.liveTimer) {
+            clearTimeout(this.liveTimer);
+            this.liveTimer = null;
+        }
         this.listeners.clear();
     }
     async firstPage(cache) {

package/dist/cjs/live-source.d.ts

@@ -0,0 +1,6 @@
+export interface LiveSource {
+    /** Calls back on every record event in the collection; returns the unsubscribe. */
+    subscribe(collection: string, callback: (event: unknown) => void): () => void;
+}
+export declare function setLiveSource(source: LiveSource | null): void;
+export declare function liveSource(): LiveSource | null;

package/dist/cjs/live-source.js

@@ -0,0 +1,16 @@
+"use strict";
+// The realtime client a live list subscribes through. KoolbaseRealtime
+// registers itself when it is created, as query-refresh.ts registers the
+// refreshers writes run: a list reaches realtime without the host packages
+// passing it in. None registered (realtime never created): a live list is
+// simply a list.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setLiveSource = setLiveSource;
+exports.liveSource = liveSource;
+let active = null;
+function setLiveSource(source) {
+    active = source;
+}
+function liveSource() {
+    return active;
+}

package/dist/cjs/react/index.d.ts

@@ -0,0 +1,2 @@
+export { createUseCollection, type UseCollectionResult } from './use-collection.js';
+export { createUseRecord, type UseRecordResult } from './use-record.js';

package/dist/cjs/react/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUseRecord = exports.createUseCollection = void 0;
+// React hooks over core's controllers: ONE implementation, exported to apps by
+// @koolbase/react-native (from its root, as always) and @koolbase/js/react.
+// React only -- nothing native, nothing DOM. Deliberately not exported from
+// core's root entry, so importing @koolbase/core never loads React.
+var use_collection_js_1 = require("./use-collection.js");
+Object.defineProperty(exports, "createUseCollection", { enumerable: true, get: function () { return use_collection_js_1.createUseCollection; } });
+var use_record_js_1 = require("./use-record.js");
+Object.defineProperty(exports, "createUseRecord", { enumerable: true, get: function () { return use_record_js_1.createUseRecord; } });

package/dist/cjs/react/use-collection.d.ts

@@ -0,0 +1,12 @@
+import { type CollectionQuery, type CollectionState, type KoolbaseDatabase } from '../index.js';
+export interface UseCollectionResult extends CollectionState {
+    /** Page one again, from the server. What is shown stays while it runs, and stays if it fails. */
+    refresh: () => Promise<void>;
+    /**
+     * The next page, appended, while hasMore. If rows are added or removed on
+     * the server between pages, one can be skipped until refresh(); none is
+     * ever shown twice.
+     */
+    loadMore: () => Promise<void>;
+}
+export declare function createUseCollection(getDb: () => Pick<KoolbaseDatabase, 'query'>): (collection: string, query?: CollectionQuery) => UseCollectionResult;

package/dist/cjs/react/use-collection.js

@@ -0,0 +1,39 @@
+"use strict";
+// useCollection: a Koolbase collection as React state.
+//
+// A thin wrapper. Everything about getting the records right lives in
+// @koolbase/core's KoolbaseCollectionController, which is tested there; this
+// file only ties one controller's lifetime to a component's.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUseCollection = createUseCollection;
+const react_1 = require("react");
+const index_js_1 = require("../index.js");
+const noop = () => { };
+const done = () => Promise.resolve();
+function createUseCollection(getDb) {
+    return function useCollection(collection, query = {}) {
+        // The query as a value: an inline `where` object is a new object every
+        // render, and must not start a new fetch every render.
+        const key = (0, index_js_1.collectionQueryKey)(collection, query);
+        const [current, setCurrent] = (0, react_1.useState)(null);
+        (0, react_1.useEffect)(() => {
+            // Created here, not during render. Under React strict mode an effect
+            // runs, cleans up and runs again; each run gets its own controller, so
+            // the one left running is never one that was already disposed.
+            const controller = new index_js_1.KoolbaseCollectionController(getDb(), collection, query);
+            setCurrent({ key, controller });
+            void controller.load();
+            return () => controller.dispose();
+            // Depends on key alone: key is collection + query, as a value.
+        }, [key]);
+        // A controller from the previous key reads as a fresh load, never as
+        // the previous query's records.
+        const controller = current?.key === key ? current.controller : null;
+        const subscribe = (0, react_1.useCallback)((onChange) => (controller ? controller.subscribe(onChange) : noop), [controller]);
+        const getSnapshot = (0, react_1.useCallback)(() => (controller ? controller.getState() : index_js_1.initialCollectionState), [controller]);
+        const state = (0, react_1.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+        const refresh = (0, react_1.useCallback)(() => (controller ? controller.refresh() : done()), [controller]);
+        const loadMore = (0, react_1.useCallback)(() => (controller ? controller.loadMore() : done()), [controller]);
+        return { ...state, refresh, loadMore };
+    };
+}

package/dist/cjs/react/use-record.d.ts

@@ -0,0 +1,6 @@
+import { type KoolbaseDatabase, type RecordState } from '../index.js';
+export interface UseRecordResult extends RecordState {
+    /** The record again, from the server. What is shown stays while it runs, and stays if it fails. */
+    refresh: () => Promise<void>;
+}
+export declare function createUseRecord(getDb: () => Pick<KoolbaseDatabase, 'get'>): (collection: string, id: string | null | undefined) => UseRecordResult;

package/dist/cjs/react/use-record.js

@@ -0,0 +1,35 @@
+"use strict";
+// useRecord: one Koolbase record, by id, as React state.
+//
+// A thin wrapper, like useCollection: everything about getting the record
+// right lives in @koolbase/core's KoolbaseRecordController, tested there;
+// this file only ties one controller's lifetime to a component's.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUseRecord = createUseRecord;
+const react_1 = require("react");
+const index_js_1 = require("../index.js");
+const noop = () => { };
+const done = () => Promise.resolve();
+function createUseRecord(getDb) {
+    return function useRecord(collection, id) {
+        const key = JSON.stringify([collection, id ?? '']);
+        const [current, setCurrent] = (0, react_1.useState)(null);
+        (0, react_1.useEffect)(() => {
+            // Created here, not during render: under React strict mode an effect
+            // runs, cleans up and runs again, and each run gets its own controller.
+            const controller = new index_js_1.KoolbaseRecordController(getDb(), collection, id ?? '');
+            setCurrent({ key, controller });
+            void controller.load();
+            return () => controller.dispose();
+            // Depends on key alone: key is collection + id, as a value.
+        }, [key]);
+        // A controller from the previous key reads as a fresh load, never as the
+        // previous record.
+        const controller = current?.key === key ? current.controller : null;
+        const subscribe = (0, react_1.useCallback)((onChange) => (controller ? controller.subscribe(onChange) : noop), [controller]);
+        const getSnapshot = (0, react_1.useCallback)(() => (controller ? controller.getState() : index_js_1.initialRecordState), [controller]);
+        const state = (0, react_1.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+        const refresh = (0, react_1.useCallback)(() => (controller ? controller.refresh() : done()), [controller]);
+        return { ...state, refresh };
+    };
+}

package/dist/cjs/realtime.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.KoolbaseRealtime = void 0;
 const cache_store_js_1 = require("./cache-store.js");
 const record_js_1 = require("./record.js");
+const live_source_js_1 = require("./live-source.js");
 const EVENT_TYPE_MAP = {
     'db.record.created': 'created',
     'db.record.updated': 'updated',
@@ -43,6 +44,8 @@ class KoolbaseRealtime {
         this.config = config;
         this.getToken = getToken;
         this.getUserId = getUserId;
+        // Live lists (CollectionQuery.live) subscribe through this client.
+        (0, live_source_js_1.setLiveSource)(this);
     }
     /** Files a record seen over the socket, if we know whose it is. */
     async cacheSeenRecord(collection, record) {

package/dist/esm/collection-controller.d.ts

@@ -8,6 +8,13 @@ export interface CollectionQuery {
     orderDesc?: boolean;
     /** Page size; the server's default (20) when absent. */
     limit?: number;
+    /**
+     * Re-read page one, silently, when Koolbase realtime reports a record
+     * created, updated or deleted in this collection (debounced: a burst is one
+     * read). Realtime needs a signed-in user; until there is one, the list
+     * behaves as a normal list and goes live once the session exists.
+     */
+    live?: boolean;
 }
 export interface CollectionState {
     readonly status: CollectionStatus;
@@ -39,6 +46,8 @@ export declare class KoolbaseCollectionController {
     private laterPages;
     private nextOffset;
     private unregister;
+    private unlive;
+    private liveTimer;
     constructor(db: QueryReader, collection: string, query?: CollectionQuery);
     getState(): CollectionState;
     /** Called on every change. Returns the unsubscribe. */
@@ -53,6 +62,11 @@ export declare class KoolbaseCollectionController {
      * shown stays while it runs, and stays if it fails.
      */
     private refreshAfterWrite;
+    /**
+     * A change someone made, reported by realtime: page one again, silently, as
+     * after a write -- once per burst (250 ms), not once per event.
+     */
+    private scheduleLiveRefresh;
     /**
      * The next page, appended. Does nothing unless loaded with more to load.
      * If rows are added or removed on the server between pages, one can be

package/dist/esm/collection-controller.js

@@ -21,6 +21,7 @@
 // Known limit: if rows are added or removed on the server between pages,
 // the pages shift and a row can be skipped until refresh(), which reloads
 // from page one. Duplicates are removed; a skipped row cannot be detected.
+import { liveSource } from './live-source.js';
 import { registerQueryRefresher } from './query-refresh.js';
 export const initialCollectionState = Object.freeze({
     status: 'loading',
@@ -45,6 +46,8 @@ export function collectionQueryKey(collection, query = {}) {
         query.orderBy ?? null,
         query.orderDesc === true,
         query.limit ?? null,
+        // Only when live: every other query keeps the key it always had.
+        ...(query.live === true ? ['live'] : []),
     ]);
 }
 /** Page one, then the later pages without any record already shown. */
@@ -72,6 +75,9 @@ export class KoolbaseCollectionController {
         this.nextOffset = 0;
         // A write to this collection re-runs this query (query-refresh.ts).
         this.unregister = null;
+        // A live list's realtime subscription, and its pending debounced re-read.
+        this.unlive = null;
+        this.liveTimer = null;
         this.db = db;
         this.collection = collection;
         this.spec = query;
@@ -93,6 +99,9 @@ export class KoolbaseCollectionController {
         if (this.disposed)
             return;
         this.unregister ?? (this.unregister = registerQueryRefresher(this.collection, () => this.refreshAfterWrite()));
+        if (this.spec.live === true) {
+            this.unlive ?? (this.unlive = liveSource()?.subscribe(this.collection, () => this.scheduleLiveRefresh()) ?? null);
+        }
         await this.firstPage('default');
     }
     /** Page one again, from the server. What is shown stays while it runs, and stays if it fails. */
@@ -114,6 +123,20 @@ export class KoolbaseCollectionController {
             return;
         await this.firstPage('network-only');
     }
+    /**
+     * A change someone made, reported by realtime: page one again, silently, as
+     * after a write -- once per burst (250 ms), not once per event.
+     */
+    scheduleLiveRefresh() {
+        if (this.disposed || this.liveTimer)
+            return;
+        this.liveTimer = setTimeout(() => {
+            this.liveTimer = null;
+            void this.refreshAfterWrite();
+        }, 250);
+        // A pending re-read must not be what keeps a Node process alive.
+        this.liveTimer.unref?.();
+    }
     /**
      * The next page, appended. Does nothing unless loaded with more to load.
      * If rows are added or removed on the server between pages, one can be
@@ -149,6 +172,12 @@ export class KoolbaseCollectionController {
         this.disposed = true;
         this.unregister?.();
         this.unregister = null;
+        this.unlive?.();
+        this.unlive = null;
+        if (this.liveTimer) {
+            clearTimeout(this.liveTimer);
+            this.liveTimer = null;
+        }
         this.listeners.clear();
     }
     async firstPage(cache) {

package/dist/esm/live-source.d.ts

@@ -0,0 +1,6 @@
+export interface LiveSource {
+    /** Calls back on every record event in the collection; returns the unsubscribe. */
+    subscribe(collection: string, callback: (event: unknown) => void): () => void;
+}
+export declare function setLiveSource(source: LiveSource | null): void;
+export declare function liveSource(): LiveSource | null;

package/dist/esm/live-source.js

@@ -0,0 +1,12 @@
+// The realtime client a live list subscribes through. KoolbaseRealtime
+// registers itself when it is created, as query-refresh.ts registers the
+// refreshers writes run: a list reaches realtime without the host packages
+// passing it in. None registered (realtime never created): a live list is
+// simply a list.
+let active = null;
+export function setLiveSource(source) {
+    active = source;
+}
+export function liveSource() {
+    return active;
+}

package/dist/esm/react/index.d.ts

@@ -0,0 +1,2 @@
+export { createUseCollection, type UseCollectionResult } from './use-collection.js';
+export { createUseRecord, type UseRecordResult } from './use-record.js';

package/dist/esm/react/index.js

@@ -0,0 +1,6 @@
+// React hooks over core's controllers: ONE implementation, exported to apps by
+// @koolbase/react-native (from its root, as always) and @koolbase/js/react.
+// React only -- nothing native, nothing DOM. Deliberately not exported from
+// core's root entry, so importing @koolbase/core never loads React.
+export { createUseCollection } from './use-collection.js';
+export { createUseRecord } from './use-record.js';

package/dist/esm/react/use-collection.d.ts

@@ -0,0 +1,12 @@
+import { type CollectionQuery, type CollectionState, type KoolbaseDatabase } from '../index.js';
+export interface UseCollectionResult extends CollectionState {
+    /** Page one again, from the server. What is shown stays while it runs, and stays if it fails. */
+    refresh: () => Promise<void>;
+    /**
+     * The next page, appended, while hasMore. If rows are added or removed on
+     * the server between pages, one can be skipped until refresh(); none is
+     * ever shown twice.
+     */
+    loadMore: () => Promise<void>;
+}
+export declare function createUseCollection(getDb: () => Pick<KoolbaseDatabase, 'query'>): (collection: string, query?: CollectionQuery) => UseCollectionResult;

package/dist/esm/react/use-collection.js

@@ -0,0 +1,36 @@
+// useCollection: a Koolbase collection as React state.
+//
+// A thin wrapper. Everything about getting the records right lives in
+// @koolbase/core's KoolbaseCollectionController, which is tested there; this
+// file only ties one controller's lifetime to a component's.
+import { useCallback, useEffect, useState, useSyncExternalStore } from 'react';
+import { KoolbaseCollectionController, collectionQueryKey, initialCollectionState, } from '../index.js';
+const noop = () => { };
+const done = () => Promise.resolve();
+export function createUseCollection(getDb) {
+    return function useCollection(collection, query = {}) {
+        // The query as a value: an inline `where` object is a new object every
+        // render, and must not start a new fetch every render.
+        const key = collectionQueryKey(collection, query);
+        const [current, setCurrent] = useState(null);
+        useEffect(() => {
+            // Created here, not during render. Under React strict mode an effect
+            // runs, cleans up and runs again; each run gets its own controller, so
+            // the one left running is never one that was already disposed.
+            const controller = new KoolbaseCollectionController(getDb(), collection, query);
+            setCurrent({ key, controller });
+            void controller.load();
+            return () => controller.dispose();
+            // Depends on key alone: key is collection + query, as a value.
+        }, [key]);
+        // A controller from the previous key reads as a fresh load, never as
+        // the previous query's records.
+        const controller = current?.key === key ? current.controller : null;
+        const subscribe = useCallback((onChange) => (controller ? controller.subscribe(onChange) : noop), [controller]);
+        const getSnapshot = useCallback(() => (controller ? controller.getState() : initialCollectionState), [controller]);
+        const state = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+        const refresh = useCallback(() => (controller ? controller.refresh() : done()), [controller]);
+        const loadMore = useCallback(() => (controller ? controller.loadMore() : done()), [controller]);
+        return { ...state, refresh, loadMore };
+    };
+}

package/dist/esm/react/use-record.d.ts

@@ -0,0 +1,6 @@
+import { type KoolbaseDatabase, type RecordState } from '../index.js';
+export interface UseRecordResult extends RecordState {
+    /** The record again, from the server. What is shown stays while it runs, and stays if it fails. */
+    refresh: () => Promise<void>;
+}
+export declare function createUseRecord(getDb: () => Pick<KoolbaseDatabase, 'get'>): (collection: string, id: string | null | undefined) => UseRecordResult;

package/dist/esm/react/use-record.js

@@ -0,0 +1,32 @@
+// useRecord: one Koolbase record, by id, as React state.
+//
+// A thin wrapper, like useCollection: everything about getting the record
+// right lives in @koolbase/core's KoolbaseRecordController, tested there;
+// this file only ties one controller's lifetime to a component's.
+import { useCallback, useEffect, useState, useSyncExternalStore } from 'react';
+import { KoolbaseRecordController, initialRecordState, } from '../index.js';
+const noop = () => { };
+const done = () => Promise.resolve();
+export function createUseRecord(getDb) {
+    return function useRecord(collection, id) {
+        const key = JSON.stringify([collection, id ?? '']);
+        const [current, setCurrent] = useState(null);
+        useEffect(() => {
+            // Created here, not during render: under React strict mode an effect
+            // runs, cleans up and runs again, and each run gets its own controller.
+            const controller = new KoolbaseRecordController(getDb(), collection, id ?? '');
+            setCurrent({ key, controller });
+            void controller.load();
+            return () => controller.dispose();
+            // Depends on key alone: key is collection + id, as a value.
+        }, [key]);
+        // A controller from the previous key reads as a fresh load, never as the
+        // previous record.
+        const controller = current?.key === key ? current.controller : null;
+        const subscribe = useCallback((onChange) => (controller ? controller.subscribe(onChange) : noop), [controller]);
+        const getSnapshot = useCallback(() => (controller ? controller.getState() : initialRecordState), [controller]);
+        const state = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+        const refresh = useCallback(() => (controller ? controller.refresh() : done()), [controller]);
+        return { ...state, refresh };
+    };
+}

package/dist/esm/realtime.js

@@ -1,5 +1,6 @@
 import { cacheRecord, removeCachedRecord } from './cache-store.js';
 import { recordFromWire } from './record.js';
+import { setLiveSource } from './live-source.js';
 const EVENT_TYPE_MAP = {
     'db.record.created': 'created',
     'db.record.updated': 'updated',
@@ -40,6 +41,8 @@ export class KoolbaseRealtime {
         this.config = config;
         this.getToken = getToken;
         this.getUserId = getUserId;
+        // Live lists (CollectionQuery.live) subscribe through this client.
+        setLiveSource(this);
     }
     /** Files a record seen over the socket, if we know whose it is. */
     async cacheSeenRecord(collection, record) {

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@koolbase/core",
-  "version": "12.9.0",
+  "version": "12.11.0",
   "description": "Koolbase SDK core \u2014 shared behaviour behind @koolbase/react-native and @koolbase/js. Install one of those, not this.",
   "main": "./dist/cjs/index.js",
   "types": "./dist/esm/index.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "react"
   ],
   "scripts": {
     "build": "node ../../scripts/build-package.js core",
@@ -39,7 +40,25 @@
         "default": "./dist/cjs/index.js"
       }
     },
+    "./react": {
+      "import": {
+        "types": "./dist/esm/react/index.d.ts",
+        "default": "./dist/esm/react/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/react/index.d.ts",
+        "default": "./dist/cjs/react/index.js"
+      }
+    },
     "./package.json": "./package.json"
   },
-  "sideEffects": false
+  "sideEffects": false,
+  "peerDependencies": {
+    "react": ">=18.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  }
 }

package/react/package.json

@@ -0,0 +1,7 @@
+{
+  "//": "For resolvers that ignore \"exports\" (TypeScript node10, older bundlers): the ./react entry.",
+  "main": "../dist/cjs/react/index.js",
+  "module": "../dist/esm/react/index.js",
+  "types": "../dist/cjs/react/index.d.ts",
+  "sideEffects": false
+}