@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/esm/plugins/replication-websocket/websocket-server.js

@@ -0,0 +1,100 @@
+import { WebSocketServer } from 'ws';
+import { rxStorageInstanceToReplicationHandler } from "../../replication-protocol/index.js";
+import { PROMISE_RESOLVE_VOID, getFromMapOrCreate } from "../../plugins/utils/index.js";
+import { Subject } from 'rxjs';
+export function startSocketServer(options) {
+  var wss = new WebSocketServer(options);
+  var closed = false;
+  function closeServer() {
+    if (closed) {
+      return PROMISE_RESOLVE_VOID;
+    }
+    closed = true;
+    onConnection$.complete();
+    return new Promise((res, rej) => {
+      /**
+       * We have to close all client connections,
+       * otherwise wss.close() will never call the callback.
+       * @link https://github.com/websockets/ws/issues/1288#issuecomment-360594458
+       */
+      for (var ws of wss.clients) {
+        ws.close();
+      }
+      wss.close(err => {
+        if (err) {
+          rej(err);
+        } else {
+          res();
+        }
+      });
+    });
+  }
+  var onConnection$ = new Subject();
+  wss.on('connection', ws => onConnection$.next(ws));
+  return {
+    server: wss,
+    close: closeServer,
+    onConnection$: onConnection$.asObservable()
+  };
+}
+var REPLICATION_HANDLER_BY_COLLECTION = new Map();
+export function getReplicationHandlerByCollection(database, collectionName) {
+  if (!database.collections[collectionName]) {
+    throw new Error('collection ' + collectionName + ' does not exist');
+  }
+  var collection = database.collections[collectionName];
+  var handler = getFromMapOrCreate(REPLICATION_HANDLER_BY_COLLECTION, collection, () => {
+    return rxStorageInstanceToReplicationHandler(collection.storageInstance, collection.conflictHandler, database.token);
+  });
+  return handler;
+}
+export function startWebsocketServer(options) {
+  var {
+    database,
+    ...wsOptions
+  } = options;
+  var serverState = startSocketServer(wsOptions);
+
+  // auto close when the database gets closed
+  database.onClose.push(() => serverState.close());
+  serverState.onConnection$.subscribe(ws => {
+    var onCloseHandlers = [];
+    ws.onclose = () => {
+      onCloseHandlers.map(fn => fn());
+    };
+    ws.on('message', async messageString => {
+      var message = JSON.parse(messageString);
+      var handler = getReplicationHandlerByCollection(database, message.collection);
+      if (message.method === 'auth') {
+        return;
+      }
+      var method = handler[message.method];
+
+      /**
+       * If it is not a function,
+       * it means that the client requested the masterChangeStream$
+       */
+      if (typeof method !== 'function') {
+        var changeStreamSub = handler.masterChangeStream$.subscribe(ev => {
+          var streamResponse = {
+            id: 'stream',
+            collection: message.collection,
+            result: ev
+          };
+          ws.send(JSON.stringify(streamResponse));
+        });
+        onCloseHandlers.push(() => changeStreamSub.unsubscribe());
+        return;
+      }
+      var result = await method(...message.params);
+      var response = {
+        id: message.id,
+        collection: message.collection,
+        result
+      };
+      ws.send(JSON.stringify(response));
+    });
+  });
+  return serverState;
+}
+//# sourceMappingURL=websocket-server.js.map

package/dist/esm/plugins/replication-websocket/websocket-server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket-server.js","names":["WebSocketServer","rxStorageInstanceToReplicationHandler","PROMISE_RESOLVE_VOID","getFromMapOrCreate","Subject","startSocketServer","options","wss","closed","closeServer","onConnection$","complete","Promise","res","rej","ws","clients","close","err","on","next","server","asObservable","REPLICATION_HANDLER_BY_COLLECTION","Map","getReplicationHandlerByCollection","database","collectionName","collections","Error","collection","handler","storageInstance","conflictHandler","token","startWebsocketServer","wsOptions","serverState","onClose","push","subscribe","onCloseHandlers","onclose","map","fn","messageString","message","JSON","parse","method","changeStreamSub","masterChangeStream$","ev","streamResponse","id","result","send","stringify","unsubscribe","params","response"],"sources":["../../../../src/plugins/replication-websocket/websocket-server.ts"],"sourcesContent":["import type {\r\n    RxCollection,\r\n    RxDatabase,\r\n    RxReplicationHandler\r\n} from '../../types/index.d.ts';\r\n\r\nimport {\r\n    type WebSocket,\r\n    WebSocketServer,\r\n    type ServerOptions,\r\n} from 'ws';\r\n\r\nimport type {\r\n    WebsocketMessageResponseType,\r\n    WebsocketMessageType,\r\n    WebsocketServerOptions,\r\n    WebsocketServerState\r\n} from './websocket-types.ts';\r\nimport { rxStorageInstanceToReplicationHandler } from '../../replication-protocol/index.ts';\r\nimport {\r\n    PROMISE_RESOLVE_VOID, getFromMapOrCreate\r\n} from '../../plugins/utils/index.ts';\r\nimport { Subject } from 'rxjs';\r\n\r\nexport function startSocketServer(options: ServerOptions): WebsocketServerState {\r\n    const wss = new WebSocketServer(options);\r\n    let closed = false;\r\n    function closeServer() {\r\n        if (closed) {\r\n            return PROMISE_RESOLVE_VOID;\r\n        }\r\n        closed = true;\r\n        onConnection$.complete();\r\n        return new Promise<void>((res, rej) => {\r\n            /**\r\n             * We have to close all client connections,\r\n             * otherwise wss.close() will never call the callback.\r\n             * @link https://github.com/websockets/ws/issues/1288#issuecomment-360594458\r\n             */\r\n            for (const ws of wss.clients) {\r\n                ws.close();\r\n            }\r\n            wss.close((err: any) => {\r\n                if (err) {\r\n                    rej(err);\r\n                } else {\r\n                    res();\r\n                }\r\n            });\r\n        });\r\n    }\r\n\r\n    const onConnection$ = new Subject<WebSocket>();\r\n    wss.on('connection', (ws: any) => onConnection$.next(ws));\r\n\r\n    return {\r\n        server: wss,\r\n        close: closeServer,\r\n        onConnection$: onConnection$.asObservable()\r\n    };\r\n}\r\n\r\nconst REPLICATION_HANDLER_BY_COLLECTION: WeakMap<RxCollection, RxReplicationHandler<any, any>> = new Map();\r\nexport function getReplicationHandlerByCollection<RxDocType>(\r\n    database: RxDatabase<any>,\r\n    collectionName: string\r\n): RxReplicationHandler<RxDocType, any> {\r\n    if (!database.collections[collectionName]) {\r\n        throw new Error('collection ' + collectionName + ' does not exist');\r\n    }\r\n\r\n    const collection = database.collections[collectionName];\r\n    const handler = getFromMapOrCreate<RxCollection, RxReplicationHandler<RxDocType, any>>(\r\n        REPLICATION_HANDLER_BY_COLLECTION,\r\n        collection,\r\n        () => {\r\n            return rxStorageInstanceToReplicationHandler(\r\n                collection.storageInstance,\r\n                collection.conflictHandler,\r\n                database.token\r\n            );\r\n        }\r\n    );\r\n    return handler;\r\n}\r\n\r\nexport function startWebsocketServer(options: WebsocketServerOptions): WebsocketServerState {\r\n    const { database, ...wsOptions } = options;\r\n    const serverState = startSocketServer(wsOptions as any);\r\n\r\n    // auto close when the database gets closed\r\n    database.onClose.push(() => serverState.close());\r\n\r\n    serverState.onConnection$.subscribe((ws: WebSocket) => {\r\n        const onCloseHandlers: Function[] = [];\r\n        ws.onclose = () => {\r\n            onCloseHandlers.map(fn => fn());\r\n        };\r\n        ws.on('message', async (messageString: string) => {\r\n            const message: WebsocketMessageType = JSON.parse(messageString);\r\n            const handler = getReplicationHandlerByCollection(database, message.collection);\r\n            if (message.method === 'auth') {\r\n                return;\r\n            }\r\n            const method = handler[message.method];\r\n\r\n            /**\r\n             * If it is not a function,\r\n             * it means that the client requested the masterChangeStream$\r\n             */\r\n            if (typeof method !== 'function') {\r\n                const changeStreamSub = handler.masterChangeStream$.subscribe((ev: any) => {\r\n                    const streamResponse: WebsocketMessageResponseType = {\r\n                        id: 'stream',\r\n                        collection: message.collection,\r\n                        result: ev\r\n                    };\r\n                    ws.send(JSON.stringify(streamResponse));\r\n                });\r\n                onCloseHandlers.push(() => changeStreamSub.unsubscribe());\r\n                return;\r\n            }\r\n            const result = await (method as any)(...message.params);\r\n            const response: WebsocketMessageResponseType = {\r\n                id: message.id,\r\n                collection: message.collection,\r\n                result\r\n            };\r\n            ws.send(JSON.stringify(response));\r\n        });\r\n    });\r\n\r\n\r\n    return serverState;\r\n}\r\n"],"mappings":"AAMA,SAEIA,eAAe,QAEZ,IAAI;AAQX,SAASC,qCAAqC,QAAQ,qCAAqC;AAC3F,SACIC,oBAAoB,EAAEC,kBAAkB,QACrC,8BAA8B;AACrC,SAASC,OAAO,QAAQ,MAAM;AAE9B,OAAO,SAASC,iBAAiBA,CAACC,OAAsB,EAAwB;EAC5E,IAAMC,GAAG,GAAG,IAAIP,eAAe,CAACM,OAAO,CAAC;EACxC,IAAIE,MAAM,GAAG,KAAK;EAClB,SAASC,WAAWA,CAAA,EAAG;IACnB,IAAID,MAAM,EAAE;MACR,OAAON,oBAAoB;IAC/B;IACAM,MAAM,GAAG,IAAI;IACbE,aAAa,CAACC,QAAQ,CAAC,CAAC;IACxB,OAAO,IAAIC,OAAO,CAAO,CAACC,GAAG,EAAEC,GAAG,KAAK;MACnC;AACZ;AACA;AACA;AACA;MACY,KAAK,IAAMC,EAAE,IAAIR,GAAG,CAACS,OAAO,EAAE;QAC1BD,EAAE,CAACE,KAAK,CAAC,CAAC;MACd;MACAV,GAAG,CAACU,KAAK,CAAEC,GAAQ,IAAK;QACpB,IAAIA,GAAG,EAAE;UACLJ,GAAG,CAACI,GAAG,CAAC;QACZ,CAAC,MAAM;UACHL,GAAG,CAAC,CAAC;QACT;MACJ,CAAC,CAAC;IACN,CAAC,CAAC;EACN;EAEA,IAAMH,aAAa,GAAG,IAAIN,OAAO,CAAY,CAAC;EAC9CG,GAAG,CAACY,EAAE,CAAC,YAAY,EAAGJ,EAAO,IAAKL,aAAa,CAACU,IAAI,CAACL,EAAE,CAAC,CAAC;EAEzD,OAAO;IACHM,MAAM,EAAEd,GAAG;IACXU,KAAK,EAAER,WAAW;IAClBC,aAAa,EAAEA,aAAa,CAACY,YAAY,CAAC;EAC9C,CAAC;AACL;AAEA,IAAMC,iCAAwF,GAAG,IAAIC,GAAG,CAAC,CAAC;AAC1G,OAAO,SAASC,iCAAiCA,CAC7CC,QAAyB,EACzBC,cAAsB,EACc;EACpC,IAAI,CAACD,QAAQ,CAACE,WAAW,CAACD,cAAc,CAAC,EAAE;IACvC,MAAM,IAAIE,KAAK,CAAC,aAAa,GAAGF,cAAc,GAAG,iBAAiB,CAAC;EACvE;EAEA,IAAMG,UAAU,GAAGJ,QAAQ,CAACE,WAAW,CAACD,cAAc,CAAC;EACvD,IAAMI,OAAO,GAAG5B,kBAAkB,CAC9BoB,iCAAiC,EACjCO,UAAU,EACV,MAAM;IACF,OAAO7B,qCAAqC,CACxC6B,UAAU,CAACE,eAAe,EAC1BF,UAAU,CAACG,eAAe,EAC1BP,QAAQ,CAACQ,KACb,CAAC;EACL,CACJ,CAAC;EACD,OAAOH,OAAO;AAClB;AAEA,OAAO,SAASI,oBAAoBA,CAAC7B,OAA+B,EAAwB;EACxF,IAAM;IAAEoB,QAAQ;IAAE,GAAGU;EAAU,CAAC,GAAG9B,OAAO;EAC1C,IAAM+B,WAAW,GAAGhC,iBAAiB,CAAC+B,SAAgB,CAAC;;EAEvD;EACAV,QAAQ,CAACY,OAAO,CAACC,IAAI,CAAC,MAAMF,WAAW,CAACpB,KAAK,CAAC,CAAC,CAAC;EAEhDoB,WAAW,CAAC3B,aAAa,CAAC8B,SAAS,CAAEzB,EAAa,IAAK;IACnD,IAAM0B,eAA2B,GAAG,EAAE;IACtC1B,EAAE,CAAC2B,OAAO,GAAG,MAAM;MACfD,eAAe,CAACE,GAAG,CAACC,EAAE,IAAIA,EAAE,CAAC,CAAC,CAAC;IACnC,CAAC;IACD7B,EAAE,CAACI,EAAE,CAAC,SAAS,EAAE,MAAO0B,aAAqB,IAAK;MAC9C,IAAMC,OAA6B,GAAGC,IAAI,CAACC,KAAK,CAACH,aAAa,CAAC;MAC/D,IAAMd,OAAO,GAAGN,iCAAiC,CAACC,QAAQ,EAAEoB,OAAO,CAAChB,UAAU,CAAC;MAC/E,IAAIgB,OAAO,CAACG,MAAM,KAAK,MAAM,EAAE;QAC3B;MACJ;MACA,IAAMA,MAAM,GAAGlB,OAAO,CAACe,OAAO,CAACG,MAAM,CAAC;;MAEtC;AACZ;AACA;AACA;MACY,IAAI,OAAOA,MAAM,KAAK,UAAU,EAAE;QAC9B,IAAMC,eAAe,GAAGnB,OAAO,CAACoB,mBAAmB,CAACX,SAAS,CAAEY,EAAO,IAAK;UACvE,IAAMC,cAA4C,GAAG;YACjDC,EAAE,EAAE,QAAQ;YACZxB,UAAU,EAAEgB,OAAO,CAAChB,UAAU;YAC9ByB,MAAM,EAAEH;UACZ,CAAC;UACDrC,EAAE,CAACyC,IAAI,CAACT,IAAI,CAACU,SAAS,CAACJ,cAAc,CAAC,CAAC;QAC3C,CAAC,CAAC;QACFZ,eAAe,CAACF,IAAI,CAAC,MAAMW,eAAe,CAACQ,WAAW,CAAC,CAAC,CAAC;QACzD;MACJ;MACA,IAAMH,MAAM,GAAG,MAAON,MAAM,CAAS,GAAGH,OAAO,CAACa,MAAM,CAAC;MACvD,IAAMC,QAAsC,GAAG;QAC3CN,EAAE,EAAER,OAAO,CAACQ,EAAE;QACdxB,UAAU,EAAEgB,OAAO,CAAChB,UAAU;QAC9ByB;MACJ,CAAC;MACDxC,EAAE,CAACyC,IAAI,CAACT,IAAI,CAACU,SAAS,CAACG,QAAQ,CAAC,CAAC;IACrC,CAAC,CAAC;EACN,CAAC,CAAC;EAGF,OAAOvB,WAAW;AACtB","ignoreList":[]}

package/dist/esm/plugins/replication-websocket/websocket-types.js

@@ -0,0 +1,3 @@
+export {};
+export {};
+//# sourceMappingURL=websocket-types.js.map

package/dist/esm/plugins/replication-websocket/websocket-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket-types.js","names":[],"sources":["../../../../src/plugins/replication-websocket/websocket-types.ts"],"sourcesContent":["import type {\r\n    Observable,\r\n} from 'rxjs';\r\nimport type {\r\n    ServerOptions,\r\n    ClientOptions,\r\n    WebSocketServer,\r\n    WebSocket\r\n} from 'ws';\r\nimport type {\r\n    RxCollection,\r\n    RxDatabase,\r\n    RxReplicationHandler,\r\n    StringKeys\r\n} from '../../types/index.d.ts';\r\n\r\nexport type WebsocketServerOptions = {\r\n    database: RxDatabase<any, any, any>;\r\n} & ServerOptions;\r\n\r\nexport type WebsocketServerState = {\r\n    server: WebSocketServer;\r\n    close: () => Promise<void>;\r\n    onConnection$: Observable<WebSocket>;\r\n};\r\n\r\nexport type WebsocketClientOptions<RxDocType> = {\r\n    replicationIdentifier: string;\r\n    collection: RxCollection<RxDocType>;\r\n    url: string;\r\n    batchSize?: number;\r\n    live?: boolean;\r\n    headers?: { [k: string]: string; };\r\n} & ClientOptions;\r\n\r\nexport type WebsocketMessageType = {\r\n    id: string;\r\n    collection: string;\r\n    method: StringKeys<RxReplicationHandler<any, any>> | 'auth';\r\n    params: any[];\r\n};\r\n\r\nexport type WebsocketMessageResponseType = {\r\n    id: string;\r\n    collection: string;\r\n    result: any;\r\n};\r\n"],"mappings":"","ignoreList":[]}

package/dist/esm/plugins/state/helpers.js

@@ -0,0 +1,73 @@
+import { overwritable } from "../../overwritable.js";
+import { newRxError } from "../../rx-error.js";
+export var RX_STATE_SCHEMA_TITLE = 'RxStateCollection';
+export var RX_STATE_ID_LENGTH = 14;
+export var RX_STATE_COLLECTION_SCHEMA = {
+  title: RX_STATE_SCHEMA_TITLE,
+  primaryKey: 'id',
+  version: 0,
+  type: 'object',
+  properties: {
+    id: {
+      type: 'string',
+      /**
+       * We store numbers in string format like '0001'
+       * with a left-pad.
+       */
+      maxLength: RX_STATE_ID_LENGTH,
+      minLength: RX_STATE_ID_LENGTH,
+      pattern: '[0-9]+'
+    },
+    sId: {
+      type: 'string',
+      maxLength: 10,
+      minLength: 10
+    },
+    ops: {
+      type: 'array',
+      minItems: 1,
+      items: {
+        type: 'object',
+        properties: {
+          k: {
+            type: 'string'
+          },
+          v: {
+            /**
+             * Do not define a type for the value
+             * because anything is allowed.
+             */
+          }
+        },
+        required: ['k', 'v']
+      }
+    }
+  },
+  required: ['id', 'sId', 'ops']
+};
+export function nextRxStateId(lastId) {
+  if (!lastId) {
+    return ''.padStart(RX_STATE_ID_LENGTH, '0');
+  }
+  var parsed = parseInt(lastId, 10);
+  var next = parsed + 1;
+  var nextString = next.toString();
+  return nextString.padStart(RX_STATE_ID_LENGTH, '0');
+}
+
+/**
+ * Only non-primitives can be used as a key in WeakMap
+ */
+export function isValidWeakMapKey(key) {
+  // This method is slow and must only be used in dev-mode!
+  if (!overwritable.isDevMode()) {
+    throw newRxError('SNH');
+  }
+  try {
+    new WeakMap().set(key, {});
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+//# sourceMappingURL=helpers.js.map

package/dist/esm/plugins/state/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","names":["overwritable","newRxError","RX_STATE_SCHEMA_TITLE","RX_STATE_ID_LENGTH","RX_STATE_COLLECTION_SCHEMA","title","primaryKey","version","type","properties","id","maxLength","minLength","pattern","sId","ops","minItems","items","k","v","required","nextRxStateId","lastId","padStart","parsed","parseInt","next","nextString","toString","isValidWeakMapKey","key","isDevMode","WeakMap","set","err"],"sources":["../../../../src/plugins/state/helpers.ts"],"sourcesContent":["import { overwritable } from '../../overwritable.ts';\r\nimport { newRxError } from '../../rx-error.ts';\r\nimport type { DeepReadonly, RxJsonSchema } from '../../types';\r\nimport type { RxStateDocument } from './types';\r\n\r\nexport const RX_STATE_SCHEMA_TITLE = 'RxStateCollection';\r\nexport const RX_STATE_ID_LENGTH = 14;\r\nexport const RX_STATE_COLLECTION_SCHEMA: DeepReadonly<RxJsonSchema<RxStateDocument>> = {\r\n    title: RX_STATE_SCHEMA_TITLE,\r\n    primaryKey: 'id',\r\n    version: 0,\r\n    type: 'object',\r\n    properties: {\r\n        id: {\r\n            type: 'string',\r\n            /**\r\n             * We store numbers in string format like '0001'\r\n             * with a left-pad.\r\n             */\r\n            maxLength: RX_STATE_ID_LENGTH,\r\n            minLength: RX_STATE_ID_LENGTH,\r\n            pattern: '[0-9]+'\r\n        },\r\n        sId: {\r\n            type: 'string',\r\n            maxLength: 10,\r\n            minLength: 10\r\n        },\r\n        ops: {\r\n            type: 'array',\r\n            minItems: 1,\r\n            items: {\r\n                type: 'object',\r\n                properties: {\r\n                    k: {\r\n                        type: 'string'\r\n                    },\r\n                    v: {\r\n                        /**\r\n                         * Do not define a type for the value\r\n                         * because anything is allowed.\r\n                         */\r\n                    }\r\n                },\r\n                required: [\r\n                    'k',\r\n                    'v'\r\n                ]\r\n            }\r\n        }\r\n    },\r\n    required: [\r\n        'id',\r\n        'sId',\r\n        'ops'\r\n    ]\r\n} as const;\r\n\r\n\r\nexport function nextRxStateId(lastId?: string): string {\r\n    if (!lastId) {\r\n        return ''.padStart(RX_STATE_ID_LENGTH, '0');\r\n    }\r\n    const parsed = parseInt(lastId, 10);\r\n    const next = parsed + 1;\r\n    const nextString = next.toString();\r\n    return nextString.padStart(RX_STATE_ID_LENGTH, '0');\r\n}\r\n\r\n\r\n\r\n/**\r\n * Only non-primitives can be used as a key in WeakMap\r\n */\r\nexport function isValidWeakMapKey(key: any) {\r\n    // This method is slow and must only be used in dev-mode!\r\n    if (!overwritable.isDevMode()) {\r\n        throw newRxError('SNH');\r\n    }\r\n    try {\r\n        new WeakMap().set(key, {});\r\n        return true;\r\n    } catch (err) {\r\n        return false;\r\n    }\r\n}\r\n"],"mappings":"AAAA,SAASA,YAAY,QAAQ,uBAAuB;AACpD,SAASC,UAAU,QAAQ,mBAAmB;AAI9C,OAAO,IAAMC,qBAAqB,GAAG,mBAAmB;AACxD,OAAO,IAAMC,kBAAkB,GAAG,EAAE;AACpC,OAAO,IAAMC,0BAAuE,GAAG;EACnFC,KAAK,EAAEH,qBAAqB;EAC5BI,UAAU,EAAE,IAAI;EAChBC,OAAO,EAAE,CAAC;EACVC,IAAI,EAAE,QAAQ;EACdC,UAAU,EAAE;IACRC,EAAE,EAAE;MACAF,IAAI,EAAE,QAAQ;MACd;AACZ;AACA;AACA;MACYG,SAAS,EAAER,kBAAkB;MAC7BS,SAAS,EAAET,kBAAkB;MAC7BU,OAAO,EAAE;IACb,CAAC;IACDC,GAAG,EAAE;MACDN,IAAI,EAAE,QAAQ;MACdG,SAAS,EAAE,EAAE;MACbC,SAAS,EAAE;IACf,CAAC;IACDG,GAAG,EAAE;MACDP,IAAI,EAAE,OAAO;MACbQ,QAAQ,EAAE,CAAC;MACXC,KAAK,EAAE;QACHT,IAAI,EAAE,QAAQ;QACdC,UAAU,EAAE;UACRS,CAAC,EAAE;YACCV,IAAI,EAAE;UACV,CAAC;UACDW,CAAC,EAAE;YACC;AACxB;AACA;AACA;UAHwB;QAKR,CAAC;QACDC,QAAQ,EAAE,CACN,GAAG,EACH,GAAG;MAEX;IACJ;EACJ,CAAC;EACDA,QAAQ,EAAE,CACN,IAAI,EACJ,KAAK,EACL,KAAK;AAEb,CAAU;AAGV,OAAO,SAASC,aAAaA,CAACC,MAAe,EAAU;EACnD,IAAI,CAACA,MAAM,EAAE;IACT,OAAO,EAAE,CAACC,QAAQ,CAACpB,kBAAkB,EAAE,GAAG,CAAC;EAC/C;EACA,IAAMqB,MAAM,GAAGC,QAAQ,CAACH,MAAM,EAAE,EAAE,CAAC;EACnC,IAAMI,IAAI,GAAGF,MAAM,GAAG,CAAC;EACvB,IAAMG,UAAU,GAAGD,IAAI,CAACE,QAAQ,CAAC,CAAC;EAClC,OAAOD,UAAU,CAACJ,QAAQ,CAACpB,kBAAkB,EAAE,GAAG,CAAC;AACvD;;AAIA;AACA;AACA;AACA,OAAO,SAAS0B,iBAAiBA,CAACC,GAAQ,EAAE;EACxC;EACA,IAAI,CAAC9B,YAAY,CAAC+B,SAAS,CAAC,CAAC,EAAE;IAC3B,MAAM9B,UAAU,CAAC,KAAK,CAAC;EAC3B;EACA,IAAI;IACA,IAAI+B,OAAO,CAAC,CAAC,CAACC,GAAG,CAACH,GAAG,EAAE,CAAC,CAAC,CAAC;IAC1B,OAAO,IAAI;EACf,CAAC,CAAC,OAAOI,GAAG,EAAE;IACV,OAAO,KAAK;EAChB;AACJ","ignoreList":[]}

package/dist/esm/plugins/state/index.js

@@ -0,0 +1,20 @@
+import { getFromMapOrCreate } from "../utils/utils-map.js";
+import { createRxState } from "./rx-state.js";
+export * from "./helpers.js";
+var STATE_BY_DATABASE = new WeakMap();
+export async function addState(namespace = '') {
+  var stateCache = getFromMapOrCreate(STATE_BY_DATABASE, this, () => new Map());
+  var state = await getFromMapOrCreate(stateCache, namespace, () => createRxState(this, namespace));
+  this.states[namespace] = state;
+  return state;
+}
+export var RxDBStatePlugin = {
+  name: 'state',
+  rxdb: true,
+  prototypes: {
+    RxDatabase(proto) {
+      proto.addState = addState;
+    }
+  }
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/plugins/state/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["getFromMapOrCreate","createRxState","STATE_BY_DATABASE","WeakMap","addState","namespace","stateCache","Map","state","states","RxDBStatePlugin","name","rxdb","prototypes","RxDatabase","proto"],"sources":["../../../../src/plugins/state/index.ts"],"sourcesContent":["import type {\r\n    RxDatabase,\r\n    RxPlugin,\r\n    RxState\r\n} from '../../types/index.d.ts';\r\nimport { getFromMapOrCreate } from '../utils/utils-map.ts';\r\nimport { RxStateBase, createRxState } from './rx-state.ts';\r\n\r\nexport * from './helpers.ts';\r\n\r\ntype StateByPrefix = Map<string, Promise<RxStateBase<any>>>;\r\nconst STATE_BY_DATABASE = new WeakMap<RxDatabase, StateByPrefix>();\r\n\r\nexport async function addState<T>(\r\n    this: RxDatabase,\r\n    namespace: string = ''\r\n): Promise<RxState<T>> {\r\n    const stateCache = getFromMapOrCreate<RxDatabase, StateByPrefix>(\r\n        STATE_BY_DATABASE,\r\n        this,\r\n        () => new Map()\r\n    );\r\n    const state = await getFromMapOrCreate(\r\n        stateCache,\r\n        namespace,\r\n        () => createRxState<T>(this, namespace)\r\n    );\r\n    this.states[namespace] = state;\r\n    return state as any;\r\n}\r\n\r\nexport const RxDBStatePlugin: RxPlugin = {\r\n    name: 'state',\r\n    rxdb: true,\r\n    prototypes: {\r\n        RxDatabase(proto: any) {\r\n            proto.addState = addState;\r\n        }\r\n    }\r\n};\r\n"],"mappings":"AAKA,SAASA,kBAAkB,QAAQ,uBAAuB;AAC1D,SAAsBC,aAAa,QAAQ,eAAe;AAE1D,cAAc,cAAc;AAG5B,IAAMC,iBAAiB,GAAG,IAAIC,OAAO,CAA4B,CAAC;AAElE,OAAO,eAAeC,QAAQA,CAE1BC,SAAiB,GAAG,EAAE,EACH;EACnB,IAAMC,UAAU,GAAGN,kBAAkB,CACjCE,iBAAiB,EACjB,IAAI,EACJ,MAAM,IAAIK,GAAG,CAAC,CAClB,CAAC;EACD,IAAMC,KAAK,GAAG,MAAMR,kBAAkB,CAClCM,UAAU,EACVD,SAAS,EACT,MAAMJ,aAAa,CAAI,IAAI,EAAEI,SAAS,CAC1C,CAAC;EACD,IAAI,CAACI,MAAM,CAACJ,SAAS,CAAC,GAAGG,KAAK;EAC9B,OAAOA,KAAK;AAChB;AAEA,OAAO,IAAME,eAAyB,GAAG;EACrCC,IAAI,EAAE,OAAO;EACbC,IAAI,EAAE,IAAI;EACVC,UAAU,EAAE;IACRC,UAAUA,CAACC,KAAU,EAAE;MACnBA,KAAK,CAACX,QAAQ,GAAGA,QAAQ;IAC7B;EACJ;AACJ,CAAC","ignoreList":[]}

package/dist/esm/plugins/state/rx-state.js

@@ -0,0 +1,285 @@
+import { Subject, distinctUntilChanged, map, merge, shareReplay, startWith, tap } from 'rxjs';
+import { overwritable } from "../../overwritable.js";
+import { getChangedDocumentsSince } from "../../rx-storage-helper.js";
+import { RXJS_SHARE_REPLAY_DEFAULTS, getProperty, setProperty, PROMISE_RESOLVE_VOID, clone, randomToken, deepEqual, getFromMapOrCreate } from "../utils/index.js";
+import { RX_STATE_COLLECTION_SCHEMA, isValidWeakMapKey, nextRxStateId } from "./helpers.js";
+import { newRxError } from "../../rx-error.js";
+import { runPluginHooks } from "../../hooks.js";
+var debugId = 0;
+var deepFrozenCache = new WeakMap();
+
+/**
+ * RxDB internally used properties are
+ * prefixed with lodash _ to make them less
+ * likely to clash with actual state properties
+ * from the user.
+ */
+export var RxStateBase = /*#__PURE__*/function () {
+  // used for debugging
+
+  function RxStateBase(prefix, collection) {
+    this._id = debugId++;
+    this._state = {};
+    this._nonPersisted = [];
+    this._writeQueue = PROMISE_RESOLVE_VOID;
+    this._initDone = false;
+    this._instanceId = randomToken(RX_STATE_COLLECTION_SCHEMA.properties.sId.maxLength);
+    this._ownEmits$ = new Subject();
+    this.prefix = prefix;
+    this.collection = collection;
+    this.collection.onClose.push(() => this._writeQueue);
+    this._lastIdQuery = this.collection.findOne({
+      sort: [{
+        id: 'desc'
+      }]
+    });
+    // make it "hot" for better write performance
+    this._lastIdQuery.$.subscribe();
+    this.$ = merge(this._ownEmits$, this.collection.eventBulks$.pipe(tap(eventBulk => {
+      if (!this._initDone) {
+        return;
+      }
+      var events = eventBulk.events;
+      for (var index = 0; index < events.length; index++) {
+        var event = events[index];
+        if (event.operation === 'INSERT' && event.documentData.sId !== this._instanceId) {
+          this.mergeOperationsIntoState(event.documentData.ops);
+        }
+      }
+    }))).pipe(shareReplay(RXJS_SHARE_REPLAY_DEFAULTS), map(() => this._state));
+    // directly subscribe because of the tap() side effect
+    this.$.subscribe();
+  }
+  var _proto = RxStateBase.prototype;
+  _proto.set = async function set(path, modifier) {
+    this._nonPersisted.push({
+      path,
+      modifier
+    });
+    return this._triggerWrite();
+  }
+
+  /**
+   * To have deterministic writes,
+   * and to ensure that multiple js realms do not overwrite
+   * each other, the write happens with incremental ids
+   * that would throw conflict errors and trigger a retry.
+   */;
+  _proto._triggerWrite = function _triggerWrite() {
+    this._writeQueue = this._writeQueue.then(async () => {
+      if (this._nonPersisted.length === 0) {
+        return;
+      }
+      var useWrites = [];
+      var done = false;
+      while (!done) {
+        var lastIdDoc = await this._lastIdQuery.exec();
+        useWrites = useWrites.concat(this._nonPersisted);
+        this._nonPersisted = [];
+        var nextId = nextRxStateId(lastIdDoc ? lastIdDoc.id : undefined);
+        try {
+          /**
+           * TODO instead of a deep-clone we should
+           * only clone the parts where we know that they
+           * will be changed. This would improve performance.
+           */
+          var newState = clone(this._state);
+          var ops = [];
+          for (var index = 0; index < useWrites.length; index++) {
+            var writeRow = useWrites[index];
+            var value = getProperty(newState, writeRow.path);
+            var newValue = writeRow.modifier(value);
+            /**
+             * Here we have to clone the value because
+             * some storages like the memory storage
+             * make input data deep-frozen in dev-mode.
+             */
+            if (writeRow.path === '') {
+              newState = clone(newValue);
+            } else {
+              setProperty(newState, writeRow.path, clone(newValue));
+            }
+            ops.push({
+              k: writeRow.path,
+              /**
+               * Here we have to clone the value because
+               * some storages like the memory storage
+               * make input data deep-frozen in dev-mode.
+               */
+              v: clone(newValue)
+            });
+          }
+          await this.collection.insert({
+            id: nextId,
+            sId: this._instanceId,
+            ops
+          });
+          this._state = newState;
+          this._ownEmits$.next(this._state);
+          done = true;
+        } catch (err) {
+          if (err.code !== 'CONFLICT') {
+            throw err;
+          }
+        }
+      }
+    }).catch(error => {
+      throw newRxError('SNH', {
+        name: 'RxState WRITE QUEUE ERROR',
+        error
+      });
+    });
+    return this._writeQueue;
+  };
+  _proto.mergeOperationsIntoState = function mergeOperationsIntoState(operations) {
+    var state = clone(this._state);
+    for (var index = 0; index < operations.length; index++) {
+      var operation = operations[index];
+      if (operation.k === '') {
+        state = clone(operation.v);
+      } else {
+        setProperty(state, operation.k, clone(operation.v));
+      }
+    }
+    this._state = state;
+  };
+  _proto.get = function get(path) {
+    var ret;
+    if (!path) {
+      ret = this._state;
+    } else {
+      ret = getProperty(this._state, path);
+    }
+
+    /**
+     * In dev-mode we have to clone the value before deep-freezing
+     * it to not have an immutable subobject in the state value.
+     * But calling .get() with the same path multiple times,
+     * should return exactly the same object instance
+     * so it does not cause re-renders on react.
+     * So in dev-mode we have to 
+     */
+    if (overwritable.isDevMode() && isValidWeakMapKey(ret)) {
+      var frozen = getFromMapOrCreate(deepFrozenCache, ret, () => overwritable.deepFreezeWhenDevMode(clone(ret)));
+      return frozen;
+    }
+    return ret;
+  };
+  _proto.get$ = function get$(path) {
+    return this.$.pipe(map(() => this.get(path)), startWith(this.get(path)), distinctUntilChanged(deepEqual), shareReplay(RXJS_SHARE_REPLAY_DEFAULTS));
+  };
+  _proto.get$$ = function get$$(path) {
+    var obs = this.get$(path);
+    var reactivity = this.collection.database.getReactivityFactory();
+    return reactivity.fromObservable(obs, this.get(path), this.collection.database);
+  }
+
+  /**
+   * Merges the state operations into a single write row
+   * to store space and make recreating the state from
+   * disc faster.
+   */;
+  _proto._cleanup = async function _cleanup() {
+    var firstWrite = await this.collection.findOne({
+      sort: [{
+        id: 'asc'
+      }]
+    }).exec();
+    var lastWrite = await this._lastIdQuery.exec();
+    if (!firstWrite || !lastWrite) {
+      return;
+    }
+    var firstNr = parseInt(firstWrite.id, 10);
+    var lastNr = parseInt(lastWrite.id, 10);
+    if (lastNr - 5 < firstNr) {
+      // only run if more than 5 write rows
+      return;
+    }
+
+    // update whole state object
+    await this._writeQueue;
+    await this.set('', () => this._state);
+
+    // delete old ones
+    await this.collection.find({
+      selector: {
+        id: {
+          $lte: lastWrite.id
+        }
+      }
+    }).remove();
+  };
+  return RxStateBase;
+}();
+export async function createRxState(database, prefix) {
+  var collectionName = 'rx-state-' + prefix;
+  await database.addCollections({
+    [collectionName]: {
+      schema: RX_STATE_COLLECTION_SCHEMA
+    }
+  });
+  var collection = database.collections[collectionName];
+  var rxState = new RxStateBase(prefix, collection);
+
+  /**
+   * Directly get the state and put it into memory.
+   * This ensures we can do non-async accesses to the
+   * correct state.
+   */
+  var done = false;
+  var checkpoint = undefined;
+  while (!done) {
+    var result = await getChangedDocumentsSince(collection.storageInstance, 1000, checkpoint);
+    checkpoint = result.checkpoint;
+    var documents = result.documents;
+    if (documents.length === 0) {
+      done = true;
+    } else {
+      for (var index = 0; index < documents.length; index++) {
+        var document = documents[index];
+        mergeOperationsIntoState(rxState._state, document.ops);
+      }
+    }
+  }
+  rxState._initDone = true;
+  var proxy = new Proxy(rxState, {
+    get(target, property) {
+      if (typeof property !== 'string') {
+        return target[property];
+      }
+      if (rxState[property]) {
+        var ret = rxState[property];
+        if (typeof ret === 'function') {
+          return ret.bind(rxState);
+        } else {
+          return ret;
+        }
+      }
+      var lastChar = property.charAt(property.length - 1);
+      if (property.endsWith('$$')) {
+        var key = property.slice(0, -2);
+        return rxState.get$$(key);
+      } else if (lastChar === '$') {
+        var _key = property.slice(0, -1);
+        return rxState.get$(_key);
+      } else {
+        return rxState.get(property);
+      }
+    },
+    set(target, newValue, receiver) {
+      throw new Error('Do not write to RxState');
+    }
+  });
+  runPluginHooks('createRxState', {
+    collection,
+    state: proxy
+  });
+  return proxy;
+}
+export function mergeOperationsIntoState(state, operations) {
+  for (var index = 0; index < operations.length; index++) {
+    var operation = operations[index];
+    setProperty(state, operation.k, clone(operation.v));
+  }
+}
+//# sourceMappingURL=rx-state.js.map

package/dist/esm/plugins/state/rx-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rx-state.js","names":["Subject","distinctUntilChanged","map","merge","shareReplay","startWith","tap","overwritable","getChangedDocumentsSince","RXJS_SHARE_REPLAY_DEFAULTS","getProperty","setProperty","PROMISE_RESOLVE_VOID","clone","randomToken","deepEqual","getFromMapOrCreate","RX_STATE_COLLECTION_SCHEMA","isValidWeakMapKey","nextRxStateId","newRxError","runPluginHooks","debugId","deepFrozenCache","WeakMap","RxStateBase","prefix","collection","_id","_state","_nonPersisted","_writeQueue","_initDone","_instanceId","properties","sId","maxLength","_ownEmits$","onClose","push","_lastIdQuery","findOne","sort","id","$","subscribe","eventBulks$","pipe","eventBulk","events","index","length","event","operation","documentData","mergeOperationsIntoState","ops","_proto","prototype","set","path","modifier","_triggerWrite","then","useWrites","done","lastIdDoc","exec","concat","nextId","undefined","newState","writeRow","value","newValue","k","v","insert","next","err","code","catch","error","name","operations","state","get","ret","isDevMode","frozen","deepFreezeWhenDevMode","get$","get$$","obs","reactivity","database","getReactivityFactory","fromObservable","_cleanup","firstWrite","lastWrite","firstNr","parseInt","lastNr","find","selector","$lte","remove","createRxState","collectionName","addCollections","schema","collections","rxState","checkpoint","result","storageInstance","documents","document","proxy","Proxy","target","property","bind","lastChar","charAt","endsWith","key","slice","receiver","Error"],"sources":["../../../../src/plugins/state/rx-state.ts"],"sourcesContent":["import {\r\n    Observable,\r\n    Subject,\r\n    distinctUntilChanged,\r\n    map,\r\n    merge,\r\n    shareReplay,\r\n    startWith,\r\n    tap\r\n} from 'rxjs';\r\nimport { overwritable } from '../../overwritable.ts';\r\nimport { getChangedDocumentsSince } from '../../rx-storage-helper.ts';\r\nimport type {\r\n    RxChangeEventBulk,\r\n    RxCollection,\r\n    RxDatabase,\r\n    RxQuery,\r\n    RxDocument,\r\n    RxError,\r\n    Paths\r\n} from '../../types';\r\nimport {\r\n    RXJS_SHARE_REPLAY_DEFAULTS,\r\n    getProperty,\r\n    setProperty,\r\n    PROMISE_RESOLVE_VOID,\r\n    clone,\r\n    randomToken,\r\n    deepEqual,\r\n    getFromMapOrCreate\r\n} from '../utils/index.ts';\r\nimport {\r\n    RX_STATE_COLLECTION_SCHEMA,\r\n    isValidWeakMapKey,\r\n    nextRxStateId\r\n} from './helpers.ts';\r\nimport {\r\n    RxStateDocument,\r\n    RxStateOperation,\r\n    RxStateModifier\r\n} from './types.ts';\r\nimport { newRxError } from '../../rx-error.ts';\r\nimport { runPluginHooks } from '../../hooks.ts';\r\n\r\n\r\nlet debugId = 0;\r\n\r\n\r\nconst deepFrozenCache = new WeakMap<any, any>();\r\n\r\n/**\r\n * RxDB internally used properties are\r\n * prefixed with lodash _ to make them less\r\n * likely to clash with actual state properties\r\n * from the user.\r\n */\r\nexport class RxStateBase<T, Reactivity = unknown> {\r\n    // used for debugging\r\n    public _id: number = debugId++;\r\n    public _state: T | any = {};\r\n    public $: Observable<T>;\r\n    public _lastIdQuery: RxQuery<RxStateDocument, RxDocument<RxStateDocument, {}> | null>;\r\n    public _nonPersisted: {\r\n        path: string;\r\n        modifier: RxStateModifier;\r\n    }[] = [];\r\n    public _writeQueue = PROMISE_RESOLVE_VOID;\r\n    public _initDone = false;\r\n    public _instanceId = randomToken(RX_STATE_COLLECTION_SCHEMA.properties.sId.maxLength);\r\n    public _ownEmits$ = new Subject<T>();\r\n\r\n    constructor(\r\n        public readonly prefix: string,\r\n        public readonly collection: RxCollection<RxStateDocument>\r\n    ) {\r\n        this.collection.onClose.push(() => this._writeQueue);\r\n        this._lastIdQuery = this.collection.findOne({\r\n            sort: [\r\n                { id: 'desc' }\r\n            ]\r\n        });\r\n        // make it \"hot\" for better write performance\r\n        this._lastIdQuery.$.subscribe();\r\n\r\n        this.$ = merge(\r\n            this._ownEmits$,\r\n            this.collection.eventBulks$.pipe(\r\n                tap((eventBulk: RxChangeEventBulk<RxStateDocument>) => {\r\n                    if (!this._initDone) {\r\n                        return;\r\n                    }\r\n                    const events = eventBulk.events;\r\n                    for (let index = 0; index < events.length; index++) {\r\n                        const event = events[index];\r\n                        if (\r\n                            event.operation === 'INSERT' &&\r\n                            event.documentData.sId !== this._instanceId\r\n                        ) {\r\n                            this.mergeOperationsIntoState(event.documentData.ops);\r\n                        }\r\n                    }\r\n                })\r\n            )\r\n        ).pipe(\r\n            shareReplay(RXJS_SHARE_REPLAY_DEFAULTS),\r\n            map(() => this._state)\r\n        );\r\n        // directly subscribe because of the tap() side effect\r\n        this.$.subscribe();\r\n    }\r\n\r\n    async set(\r\n        path: Paths<T> | '',\r\n        modifier: RxStateModifier\r\n    ) {\r\n        this._nonPersisted.push({\r\n            path,\r\n            modifier\r\n        });\r\n        return this._triggerWrite();\r\n    }\r\n\r\n    /**\r\n     * To have deterministic writes,\r\n     * and to ensure that multiple js realms do not overwrite\r\n     * each other, the write happens with incremental ids\r\n     * that would throw conflict errors and trigger a retry.\r\n     */\r\n    _triggerWrite() {\r\n        this._writeQueue = this._writeQueue.then(async () => {\r\n            if (this._nonPersisted.length === 0) {\r\n                return;\r\n            }\r\n            let useWrites: typeof this._nonPersisted = [];\r\n            let done = false;\r\n            while (!done) {\r\n                const lastIdDoc = await this._lastIdQuery.exec();\r\n                useWrites = useWrites.concat(this._nonPersisted);\r\n                this._nonPersisted = [];\r\n                const nextId = nextRxStateId(lastIdDoc ? lastIdDoc.id : undefined);\r\n                try {\r\n                    /**\r\n                     * TODO instead of a deep-clone we should\r\n                     * only clone the parts where we know that they\r\n                     * will be changed. This would improve performance.\r\n                     */\r\n                    let newState = clone(this._state);\r\n                    const ops: RxStateOperation[] = [];\r\n                    for (let index = 0; index < useWrites.length; index++) {\r\n                        const writeRow = useWrites[index];\r\n                        const value = getProperty(newState, writeRow.path);\r\n                        const newValue = writeRow.modifier(value);\r\n                        /**\r\n                         * Here we have to clone the value because\r\n                         * some storages like the memory storage\r\n                         * make input data deep-frozen in dev-mode.\r\n                         */\r\n                        if (writeRow.path === '') {\r\n                            newState = clone(newValue);\r\n                        } else {\r\n                            setProperty(newState, writeRow.path, clone(newValue));\r\n                        }\r\n                        ops.push({\r\n                            k: writeRow.path,\r\n                            /**\r\n                             * Here we have to clone the value because\r\n                             * some storages like the memory storage\r\n                             * make input data deep-frozen in dev-mode.\r\n                             */\r\n                            v: clone(newValue)\r\n                        });\r\n                    }\r\n                    await this.collection.insert({\r\n                        id: nextId,\r\n                        sId: this._instanceId,\r\n                        ops\r\n                    });\r\n                    this._state = newState;\r\n                    this._ownEmits$.next(this._state);\r\n                    done = true;\r\n                } catch (err) {\r\n                    if ((err as RxError).code !== 'CONFLICT') {\r\n                        throw err;\r\n                    }\r\n                }\r\n            }\r\n        }).catch(error => {\r\n            throw newRxError('SNH', {\r\n                name: 'RxState WRITE QUEUE ERROR',\r\n                error\r\n            });\r\n        });\r\n        return this._writeQueue;\r\n    }\r\n\r\n    mergeOperationsIntoState(\r\n        operations: RxStateOperation[]\r\n    ) {\r\n        let state = clone(this._state);\r\n        for (let index = 0; index < operations.length; index++) {\r\n            const operation = operations[index];\r\n            if (operation.k === '') {\r\n                state = clone(operation.v);\r\n            } else {\r\n                setProperty(state, operation.k, clone(operation.v));\r\n            }\r\n        }\r\n        this._state = state;\r\n    }\r\n    get(path?: Paths<T>) {\r\n        let ret;\r\n        if (!path) {\r\n            ret = this._state;\r\n        } else {\r\n            ret = getProperty(this._state, path);\r\n        }\r\n\r\n        /**\r\n         * In dev-mode we have to clone the value before deep-freezing\r\n         * it to not have an immutable subobject in the state value.\r\n         * But calling .get() with the same path multiple times,\r\n         * should return exactly the same object instance\r\n         * so it does not cause re-renders on react.\r\n         * So in dev-mode we have to \r\n         */\r\n        if (overwritable.isDevMode() && isValidWeakMapKey(ret)) {\r\n            const frozen = getFromMapOrCreate(\r\n                deepFrozenCache,\r\n                ret,\r\n                () => overwritable.deepFreezeWhenDevMode(clone(ret))\r\n            );\r\n            return frozen;\r\n        }\r\n\r\n        return ret;\r\n    }\r\n    get$(path?: Paths<T>): Observable<any> {\r\n        return this.$.pipe(\r\n            map(() => this.get(path)),\r\n            startWith(this.get(path)),\r\n            distinctUntilChanged(deepEqual),\r\n            shareReplay(RXJS_SHARE_REPLAY_DEFAULTS),\r\n        );\r\n    }\r\n    get$$(path?: Paths<T>): Reactivity {\r\n        const obs = this.get$(path);\r\n        const reactivity = this.collection.database.getReactivityFactory();\r\n        return reactivity.fromObservable(\r\n            obs,\r\n            this.get(path),\r\n            this.collection.database\r\n        ) as any;\r\n    }\r\n\r\n    /**\r\n     * Merges the state operations into a single write row\r\n     * to store space and make recreating the state from\r\n     * disc faster.\r\n     */\r\n    async _cleanup() {\r\n        const firstWrite = await this.collection.findOne({\r\n            sort: [{ id: 'asc' }]\r\n        }).exec();\r\n        const lastWrite = await this._lastIdQuery.exec();\r\n\r\n        if (!firstWrite || !lastWrite) {\r\n            return;\r\n        }\r\n\r\n        const firstNr = parseInt(firstWrite.id, 10);\r\n        const lastNr = parseInt(lastWrite.id, 10);\r\n        if ((lastNr - 5) < firstNr) {\r\n            // only run if more than 5 write rows\r\n            return;\r\n        }\r\n\r\n        // update whole state object\r\n        await this._writeQueue;\r\n        await this.set('', () => this._state);\r\n\r\n        // delete old ones\r\n        await this.collection.find({\r\n            selector: {\r\n                id: {\r\n                    $lte: lastWrite.id\r\n                }\r\n            }\r\n        }).remove();\r\n    }\r\n}\r\n\r\n\r\nexport async function createRxState<T>(\r\n    database: RxDatabase,\r\n    prefix: string\r\n): Promise<RxStateBase<T>> {\r\n    const collectionName = 'rx-state-' + prefix;\r\n    await database.addCollections({\r\n        [collectionName]: {\r\n            schema: RX_STATE_COLLECTION_SCHEMA as any\r\n        }\r\n    });\r\n    const collection: RxCollection<RxStateDocument> = database.collections[collectionName];\r\n\r\n    const rxState = new RxStateBase<T>(\r\n        prefix,\r\n        collection\r\n    );\r\n\r\n\r\n    /**\r\n     * Directly get the state and put it into memory.\r\n     * This ensures we can do non-async accesses to the\r\n     * correct state.\r\n     */\r\n    let done = false;\r\n    let checkpoint: any = undefined;\r\n    while (!done) {\r\n        const result = await getChangedDocumentsSince<RxStateDocument, any>(\r\n            collection.storageInstance,\r\n            1000,\r\n            checkpoint\r\n        );\r\n        checkpoint = result.checkpoint;\r\n        const documents = result.documents;\r\n        if (documents.length === 0) {\r\n            done = true;\r\n        } else {\r\n            for (let index = 0; index < documents.length; index++) {\r\n                const document = documents[index];\r\n                mergeOperationsIntoState(rxState._state, document.ops);\r\n            }\r\n        }\r\n    }\r\n    rxState._initDone = true;\r\n\r\n    const proxy = new Proxy(\r\n        rxState as any,\r\n        {\r\n            get(target, property: any) {\r\n                if (typeof property !== 'string') {\r\n                    return target[property];\r\n                }\r\n                if ((rxState as any)[property]) {\r\n                    const ret = (rxState as any)[property];\r\n                    if (typeof ret === 'function') {\r\n                        return ret.bind(rxState);\r\n                    } else {\r\n                        return ret;\r\n                    }\r\n                }\r\n                const lastChar = property.charAt(property.length - 1);\r\n                if (property.endsWith('$$')) {\r\n                    const key = property.slice(0, -2);\r\n                    return rxState.get$$(key as any);\r\n                } else if (lastChar === '$') {\r\n                    const key = property.slice(0, -1);\r\n                    return rxState.get$(key as any);\r\n                } else {\r\n                    return rxState.get(property as any);\r\n                }\r\n            },\r\n            set(target, newValue, receiver) {\r\n                throw new Error('Do not write to RxState');\r\n            }\r\n        }\r\n    );\r\n\r\n    runPluginHooks('createRxState', {\r\n        collection,\r\n        state: proxy\r\n    });\r\n\r\n    return proxy;\r\n}\r\n\r\n\r\nexport function mergeOperationsIntoState<T>(\r\n    state: T,\r\n    operations: RxStateOperation[]\r\n) {\r\n    for (let index = 0; index < operations.length; index++) {\r\n        const operation = operations[index];\r\n        setProperty(state, operation.k, clone(operation.v));\r\n    }\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/plugins/state/types.js

@@ -0,0 +1,3 @@
+export {};
+export {};
+//# sourceMappingURL=types.js.map

package/dist/esm/plugins/state/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../../src/plugins/state/types.ts"],"sourcesContent":["import { DeepReadonly } from '../../types';\r\n\r\n/**\r\n * \r\n */\r\nexport type RxStateDocument = {\r\n    /**\r\n     * Ensures that when multiple\r\n     * javascript realms write at the same time,\r\n     * we do not overwrite each other but instead\r\n     * one write must conflict-error and retry.\r\n     * The clock value is also the primary key.\r\n     * The clock value contains incremental numbers\r\n     * in a string format like '0001', '0123'...\r\n     */\r\n    id: string;\r\n    /**\r\n     * Id of the JavaScript Instance of RxState\r\n     * that did the write. Used to optimise performance\r\n     * by not running these modifiers twice.\r\n     */\r\n    sId: string;\r\n    ops: RxStateOperation[]\r\n};\r\n\r\n\r\nexport type RxStateOperation = {\r\n    k: string;\r\n    v: any;\r\n};\r\n\r\nexport type RxStateModifier = (preValue: DeepReadonly<any>) => any;\r\n"],"mappings":"","ignoreList":[]}

package/dist/esm/plugins/storage-denokv/denokv-helper.js

@@ -0,0 +1,40 @@
+import { promiseWait } from "../utils/utils-promise.js";
+export var RX_STORAGE_NAME_DENOKV = 'denokv';
+export function getDenoKVIndexName(index) {
+  return index.join('|');
+}
+
+/**
+ * Used for non-index rows that contain the document data,
+ * not just a documentId
+ */
+export var DENOKV_DOCUMENT_ROOT_PATH = '||';
+export var CLEANUP_INDEX = ['_deleted', '_meta.lwt'];
+
+/**
+ * Get the global Deno variable from globalThis.Deno
+ * so that compiling with plain typescript does not fail.
+ * Deno has no way to just "download" the deno typings,
+ * so we have to use the "any" type here.
+ */
+export function getDenoGlobal() {
+  return globalThis.Deno;
+}
+export async function commitWithRetry(buildTx) {
+  var attempt = 0;
+  while (true) {
+    var tx = buildTx();
+    try {
+      return await tx.commit();
+    } catch (err) {
+      var locked = err && String(err.message).includes('database is locked');
+      if (locked && attempt < 10) {
+        attempt++;
+        await promiseWait(10 * attempt);
+        continue;
+      }
+      throw err;
+    }
+  }
+}
+//# sourceMappingURL=denokv-helper.js.map

package/dist/esm/plugins/storage-denokv/denokv-helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"denokv-helper.js","names":["promiseWait","RX_STORAGE_NAME_DENOKV","getDenoKVIndexName","index","join","DENOKV_DOCUMENT_ROOT_PATH","CLEANUP_INDEX","getDenoGlobal","globalThis","Deno","commitWithRetry","buildTx","attempt","tx","commit","err","locked","String","message","includes"],"sources":["../../../../src/plugins/storage-denokv/denokv-helper.ts"],"sourcesContent":["import { promiseWait } from '../utils/utils-promise.ts';\r\n\r\nexport const RX_STORAGE_NAME_DENOKV = 'denokv';\r\n\r\nexport function getDenoKVIndexName(index: string[]): string {\r\n    return index.join('|');\r\n}\r\n\r\n/**\r\n * Used for non-index rows that contain the document data,\r\n * not just a documentId\r\n */\r\nexport const DENOKV_DOCUMENT_ROOT_PATH = '||';\r\n\r\nexport const CLEANUP_INDEX: string[] = ['_deleted', '_meta.lwt'];\r\n\r\n\r\n/**\r\n * Get the global Deno variable from globalThis.Deno\r\n * so that compiling with plain typescript does not fail.\r\n * Deno has no way to just \"download\" the deno typings,\r\n * so we have to use the \"any\" type here.\r\n */\r\nexport function getDenoGlobal(): any {\r\n    return (globalThis as any).Deno;\r\n}\r\n\r\n\r\nexport async function commitWithRetry(buildTx: () => any) {\r\n    let attempt = 0;\r\n\r\n    while (true) {\r\n        const tx = buildTx();\r\n        try {\r\n            return await tx.commit();\r\n        } catch (err) {\r\n            const locked = err && String((err as any).message).includes('database is locked');\r\n            if (locked && attempt < 10) {\r\n                attempt++;\r\n                await promiseWait(10 * attempt);\r\n                continue;\r\n            }\r\n            throw err;\r\n        }\r\n    }\r\n}\r\n"],"mappings":"AAAA,SAASA,WAAW,QAAQ,2BAA2B;AAEvD,OAAO,IAAMC,sBAAsB,GAAG,QAAQ;AAE9C,OAAO,SAASC,kBAAkBA,CAACC,KAAe,EAAU;EACxD,OAAOA,KAAK,CAACC,IAAI,CAAC,GAAG,CAAC;AAC1B;;AAEA;AACA;AACA;AACA;AACA,OAAO,IAAMC,yBAAyB,GAAG,IAAI;AAE7C,OAAO,IAAMC,aAAuB,GAAG,CAAC,UAAU,EAAE,WAAW,CAAC;;AAGhE;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,aAAaA,CAAA,EAAQ;EACjC,OAAQC,UAAU,CAASC,IAAI;AACnC;AAGA,OAAO,eAAeC,eAAeA,CAACC,OAAkB,EAAE;EACtD,IAAIC,OAAO,GAAG,CAAC;EAEf,OAAO,IAAI,EAAE;IACT,IAAMC,EAAE,GAAGF,OAAO,CAAC,CAAC;IACpB,IAAI;MACA,OAAO,MAAME,EAAE,CAACC,MAAM,CAAC,CAAC;IAC5B,CAAC,CAAC,OAAOC,GAAG,EAAE;MACV,IAAMC,MAAM,GAAGD,GAAG,IAAIE,MAAM,CAAEF,GAAG,CAASG,OAAO,CAAC,CAACC,QAAQ,CAAC,oBAAoB,CAAC;MACjF,IAAIH,MAAM,IAAIJ,OAAO,GAAG,EAAE,EAAE;QACxBA,OAAO,EAAE;QACT,MAAMZ,WAAW,CAAC,EAAE,GAAGY,OAAO,CAAC;QAC/B;MACJ;MACA,MAAMG,GAAG;IACb;EACJ;AACJ","ignoreList":[]}