@pluv/addon-indexeddb 0.1.0

package/.eslintrc.js

@@ -0,0 +1,4 @@
+module.exports = {
+  root: true,
+  extends: ["pluv"],
+};

package/.turbo/turbo-build.log

@@ -0,0 +1,17 @@
+
+> @pluv/addon-indexeddb@0.1.0 build /home/runner/work/pluv/pluv/packages/addon-indexeddb
+> tsup src/index.ts --format esm,cjs --dts
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v7.0.0
+CLI Target: es6
+ESM Build start
+CJS Build start
+ESM dist/index.mjs 3.84 KB
+ESM ⚡️ Build success in 147ms
+CJS dist/index.js 4.87 KB
+CJS ⚡️ Build success in 148ms
+DTS Build start
+DTS ⚡️ Build success in 8280ms
+DTS dist/index.d.ts 728.00 B

package/CHANGELOG.md

@@ -0,0 +1,50 @@
+# @pluv/addon-indexeddb
+
+## 0.1.0
+
+### Minor Changes
+
+- 829d31b: Added support for defining persistant frontend storage for rooms via a new `addons` option on rooms.
+
+  This also introduces the first new addon `@pluv/addon-indexeddb`, which is more-or-less the equivalent to `y-indexeddb` which you can install like so:
+
+  ```
+  npm install @pluv/addon-indexeddb
+  ```
+
+  To use this new addon, simply pass it to options when creating a room:
+
+  ```ts
+  import { addonIndexedDB } from "@pluv/addon-indexeddb";
+  import { createClient } from "@pluv/client";
+
+  const client = createClient({
+    // ...
+  });
+
+  const room = client.createRoom("my-new-room", {
+    addons: [
+      // Define your addons in an array like so
+      addonIndexedDB(),
+    ],
+  });
+  ```
+
+  Or when using `@pluv/react`:
+
+  ```ts
+  const PluvRoom = createRoomBundle({
+    // ...
+    addons: [
+      // Define your addons in an array like so
+      addonIndexedDB(),
+    ],
+  });
+  ```
+
+### Patch Changes
+
+- 8d11672: bumped dependencies to latest
+- Updated dependencies [8d11672]
+- Updated dependencies [829d31b]
+  - @pluv/client@0.9.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Shoubhit Dash
+
+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/dist/index.d.ts

@@ -0,0 +1,10 @@
+import * as _pluv_types from '@pluv/types';
+import { IOLike, JsonObject } from '@pluv/types';
+import { AbstractType, PluvRoomAddon, PluvRoom } from '@pluv/client';
+
+interface AddonIndexedDBConfig<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}> {
+    enabled?: boolean | ((room: PluvRoom<TIO, TPresence, TStorage>) => boolean);
+}
+declare const addonIndexedDB: <TIO extends IOLike<_pluv_types.IOAuthorize<any, any>, {}, {}, {}, {}>, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}>(config?: AddonIndexedDBConfig<TIO, TPresence, TStorage> | undefined) => PluvRoomAddon<TIO, TPresence, TStorage>;
+
+export { addonIndexedDB };

package/dist/index.js

@@ -0,0 +1,171 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  addonIndexedDB: () => addonIndexedDB
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/IndexedDBStorage.ts
+var import_client = require("@pluv/client");
+var import_idb = require("idb");
+var STORAGE_STORE_FLATTEN_THRESHOLD = 500;
+var UPGRADES_KEY = "__PLUV_UPDATES";
+var IndexedDBStorage = class extends import_client.AbstractStorageStore {
+  constructor(room) {
+    super(room);
+    this._db = null;
+    this._dbRef = 0;
+    this._dbSize = 0;
+    this.room = room;
+  }
+  addUpdate(update) {
+    return __async(this, null, function* () {
+      const db = this._db;
+      if (!db)
+        return;
+      yield db.add(UPGRADES_KEY, update);
+      this._dbSize += 1;
+    });
+  }
+  destroy() {
+    if (!this._db)
+      return Promise.resolve();
+    this._db.close();
+    this._db = null;
+    this._dbRef = 0;
+    this._dbSize = 0;
+    return Promise.resolve();
+  }
+  flatten(encodedState) {
+    return __async(this, null, function* () {
+      const db = this._db;
+      if (!db)
+        return;
+      yield db.add(UPGRADES_KEY, encodedState);
+      yield db.delete(UPGRADES_KEY, this._getUpperBound(this._dbRef, true));
+      this._dbSize = yield this._getSize();
+    });
+  }
+  getShouldFlatten() {
+    return __async(this, null, function* () {
+      const dbSize = yield this._getSize();
+      return dbSize >= STORAGE_STORE_FLATTEN_THRESHOLD;
+    });
+  }
+  getUpdates(start = 0) {
+    return __async(this, null, function* () {
+      const db = this._db;
+      if (!db)
+        return [];
+      const updates = yield db.getAll(
+        UPGRADES_KEY,
+        this._getLowerBound(start)
+      );
+      const lastKey = yield this._getLastKey();
+      this._dbRef = lastKey + 1;
+      return updates;
+    });
+  }
+  initialize() {
+    return __async(this, null, function* () {
+      const newDB = yield (0, import_idb.openDB)(this.room, void 0, {
+        upgrade: (db) => {
+          db.createObjectStore(UPGRADES_KEY, { autoIncrement: true });
+        }
+      });
+      newDB.addEventListener("versionchange", () => {
+        newDB.close();
+      });
+      if (typeof window !== "undefined") {
+        window.addEventListener("unload", () => {
+          newDB.close();
+        });
+      }
+      this._db = newDB;
+    });
+  }
+  _getLastKey() {
+    return __async(this, null, function* () {
+      var _a;
+      const db = this._db;
+      if (!db)
+        throw new Error("IndexedDB not initialized");
+      const store = db.transaction(UPGRADES_KEY).objectStore(UPGRADES_KEY);
+      const cursor = yield store.openCursor(null, "prev");
+      return (_a = cursor == null ? void 0 : cursor.key) != null ? _a : -1;
+    });
+  }
+  _getLowerBound(lower, open = false) {
+    return IDBKeyRange.lowerBound(lower, open);
+  }
+  _getSize() {
+    return __async(this, null, function* () {
+      if (this._dbSize)
+        return this._dbSize;
+      const db = this._db;
+      if (!db)
+        throw new Error("IndexedDB not initialized");
+      const store = db.transaction(UPGRADES_KEY).objectStore(UPGRADES_KEY);
+      return store.count();
+    });
+  }
+  _getUpperBound(upper, open = false) {
+    return IDBKeyRange.upperBound(upper, open);
+  }
+};
+
+// src/addonIndexedDB.ts
+var addonIndexedDB = (config) => {
+  const { enabled = true } = config != null ? config : {};
+  return ({ room }) => {
+    const _enabled = typeof enabled === "boolean" ? enabled : enabled(room);
+    if (!_enabled)
+      return {};
+    return {
+      storage: new IndexedDBStorage(room.id)
+    };
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addonIndexedDB
+});

package/dist/index.mjs

@@ -0,0 +1,145 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/IndexedDBStorage.ts
+import { AbstractStorageStore } from "@pluv/client";
+import { openDB } from "idb";
+var STORAGE_STORE_FLATTEN_THRESHOLD = 500;
+var UPGRADES_KEY = "__PLUV_UPDATES";
+var IndexedDBStorage = class extends AbstractStorageStore {
+  constructor(room) {
+    super(room);
+    this._db = null;
+    this._dbRef = 0;
+    this._dbSize = 0;
+    this.room = room;
+  }
+  addUpdate(update) {
+    return __async(this, null, function* () {
+      const db = this._db;
+      if (!db)
+        return;
+      yield db.add(UPGRADES_KEY, update);
+      this._dbSize += 1;
+    });
+  }
+  destroy() {
+    if (!this._db)
+      return Promise.resolve();
+    this._db.close();
+    this._db = null;
+    this._dbRef = 0;
+    this._dbSize = 0;
+    return Promise.resolve();
+  }
+  flatten(encodedState) {
+    return __async(this, null, function* () {
+      const db = this._db;
+      if (!db)
+        return;
+      yield db.add(UPGRADES_KEY, encodedState);
+      yield db.delete(UPGRADES_KEY, this._getUpperBound(this._dbRef, true));
+      this._dbSize = yield this._getSize();
+    });
+  }
+  getShouldFlatten() {
+    return __async(this, null, function* () {
+      const dbSize = yield this._getSize();
+      return dbSize >= STORAGE_STORE_FLATTEN_THRESHOLD;
+    });
+  }
+  getUpdates(start = 0) {
+    return __async(this, null, function* () {
+      const db = this._db;
+      if (!db)
+        return [];
+      const updates = yield db.getAll(
+        UPGRADES_KEY,
+        this._getLowerBound(start)
+      );
+      const lastKey = yield this._getLastKey();
+      this._dbRef = lastKey + 1;
+      return updates;
+    });
+  }
+  initialize() {
+    return __async(this, null, function* () {
+      const newDB = yield openDB(this.room, void 0, {
+        upgrade: (db) => {
+          db.createObjectStore(UPGRADES_KEY, { autoIncrement: true });
+        }
+      });
+      newDB.addEventListener("versionchange", () => {
+        newDB.close();
+      });
+      if (typeof window !== "undefined") {
+        window.addEventListener("unload", () => {
+          newDB.close();
+        });
+      }
+      this._db = newDB;
+    });
+  }
+  _getLastKey() {
+    return __async(this, null, function* () {
+      var _a;
+      const db = this._db;
+      if (!db)
+        throw new Error("IndexedDB not initialized");
+      const store = db.transaction(UPGRADES_KEY).objectStore(UPGRADES_KEY);
+      const cursor = yield store.openCursor(null, "prev");
+      return (_a = cursor == null ? void 0 : cursor.key) != null ? _a : -1;
+    });
+  }
+  _getLowerBound(lower, open = false) {
+    return IDBKeyRange.lowerBound(lower, open);
+  }
+  _getSize() {
+    return __async(this, null, function* () {
+      if (this._dbSize)
+        return this._dbSize;
+      const db = this._db;
+      if (!db)
+        throw new Error("IndexedDB not initialized");
+      const store = db.transaction(UPGRADES_KEY).objectStore(UPGRADES_KEY);
+      return store.count();
+    });
+  }
+  _getUpperBound(upper, open = false) {
+    return IDBKeyRange.upperBound(upper, open);
+  }
+};
+
+// src/addonIndexedDB.ts
+var addonIndexedDB = (config) => {
+  const { enabled = true } = config != null ? config : {};
+  return ({ room }) => {
+    const _enabled = typeof enabled === "boolean" ? enabled : enabled(room);
+    if (!_enabled)
+      return {};
+    return {
+      storage: new IndexedDBStorage(room.id)
+    };
+  };
+};
+export {
+  addonIndexedDB
+};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@pluv/addon-indexeddb",
+  "version": "0.1.0",
+  "description": "@pluv/io indexeddb for client storage persistance",
+  "author": "leedavidcs",
+  "license": "MIT",
+  "homepage": "https://github.com/pluv-io/pluv",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pluv-io/pluv.git",
+    "directory": "packages/addon-indexeddb"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "idb": "^7.1.1",
+    "@pluv/client": "^0.9.0"
+  },
+  "devDependencies": {
+    "eslint": "^8.43.0",
+    "tsup": "^7.0.0",
+    "typescript": "^5.1.3",
+    "@pluv/tsconfig": "^0.1.7",
+    "@pluv/types": "^0.2.1",
+    "eslint-config-pluv": "^0.1.13"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "dev": "tsup src/index.ts --format esm,cjs --watch --dts",
+    "lint": "eslint src/**/*.ts* --fix",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
+  }
+}

package/src/IndexedDBStorage.ts

@@ -0,0 +1,134 @@
+import { AbstractStorageStore } from "@pluv/client";
+import { IDBPDatabase, openDB } from "idb";
+
+const STORAGE_STORE_FLATTEN_THRESHOLD = 500;
+const UPGRADES_KEY = "__PLUV_UPDATES";
+
+type IndexDBSchema = {
+    [UPGRADES_KEY]: {
+        key: number;
+        value: string;
+    };
+};
+
+type IndexedDB = IDBPDatabase<IndexDBSchema>;
+
+export class IndexedDBStorage extends AbstractStorageStore {
+    public room: string;
+
+    private _db: IndexedDB | null = null;
+    private _dbRef: number = 0;
+    private _dbSize: number = 0;
+
+    constructor(room: string) {
+        super(room);
+
+        this.room = room;
+    }
+
+    public async addUpdate(update: string): Promise<void> {
+        const db = this._db;
+
+        if (!db) return;
+
+        await db.add(UPGRADES_KEY, update);
+
+        this._dbSize += 1;
+    }
+
+    public destroy(): Promise<void> {
+        if (!this._db) return Promise.resolve();
+
+        this._db.close();
+        this._db = null;
+        this._dbRef = 0;
+        this._dbSize = 0;
+
+        return Promise.resolve();
+    }
+
+    public async flatten(encodedState: string): Promise<void> {
+        const db = this._db;
+
+        if (!db) return;
+
+        await db.add(UPGRADES_KEY, encodedState);
+        await db.delete(UPGRADES_KEY, this._getUpperBound(this._dbRef, true));
+
+        this._dbSize = await this._getSize();
+    }
+
+    public async getShouldFlatten(): Promise<boolean> {
+        const dbSize = await this._getSize();
+
+        return dbSize >= STORAGE_STORE_FLATTEN_THRESHOLD;
+    }
+
+    public async getUpdates(start: number = 0): Promise<readonly string[]> {
+        const db = this._db;
+
+        if (!db) return [];
+
+        const updates = await db.getAll(
+            UPGRADES_KEY,
+            this._getLowerBound(start)
+        );
+
+        const lastKey = await this._getLastKey();
+
+        this._dbRef = lastKey + 1;
+
+        return updates;
+    }
+
+    public async initialize(): Promise<void> {
+        const newDB = await openDB<IndexDBSchema>(this.room, undefined, {
+            upgrade: (db) => {
+                db.createObjectStore(UPGRADES_KEY, { autoIncrement: true });
+            },
+        });
+
+        newDB.addEventListener("versionchange", () => {
+            newDB.close();
+        });
+
+        if (typeof window !== "undefined") {
+            window.addEventListener("unload", () => {
+                newDB.close();
+            });
+        }
+
+        this._db = newDB;
+    }
+
+    private async _getLastKey(): Promise<number> {
+        const db = this._db;
+
+        if (!db) throw new Error("IndexedDB not initialized");
+
+        const store = db.transaction(UPGRADES_KEY).objectStore(UPGRADES_KEY);
+        const cursor = await store.openCursor(null, "prev");
+
+        return cursor?.key ?? -1;
+    }
+
+    private _getLowerBound(lower: number, open: boolean = false): IDBKeyRange {
+        return IDBKeyRange.lowerBound(lower, open);
+    }
+
+    private async _getSize(): Promise<number> {
+        if (this._dbSize) return this._dbSize;
+
+        const db = this._db;
+
+        if (!db) throw new Error("IndexedDB not initialized");
+
+        const store = db.transaction(UPGRADES_KEY).objectStore(UPGRADES_KEY);
+
+        return store.count();
+    }
+
+    private _getUpperBound(upper: number, open: boolean = false): IDBKeyRange {
+        return IDBKeyRange.upperBound(upper, open);
+    }
+}

package/src/addonIndexedDB.ts

@@ -0,0 +1,31 @@
+import type { AbstractType, PluvRoom, PluvRoomAddon } from "@pluv/client";
+import type { IOLike, JsonObject } from "@pluv/types";
+import { IndexedDBStorage } from "./IndexedDBStorage";
+
+export interface AddonIndexedDBConfig<
+    TIO extends IOLike,
+    TPresence extends JsonObject = {},
+    TStorage extends Record<string, AbstractType<any>> = {}
+> {
+    enabled?: boolean | ((room: PluvRoom<TIO, TPresence, TStorage>) => boolean);
+}
+
+export const addonIndexedDB = <
+    TIO extends IOLike,
+    TPresence extends JsonObject = {},
+    TStorage extends Record<string, AbstractType<any>> = {}
+>(
+    config?: AddonIndexedDBConfig<TIO, TPresence, TStorage>
+): PluvRoomAddon<TIO, TPresence, TStorage> => {
+    const { enabled = true } = config ?? {};
+
+    return ({ room }) => {
+        const _enabled = typeof enabled === "boolean" ? enabled : enabled(room);
+
+        if (!_enabled) return {};
+
+        return {
+            storage: new IndexedDBStorage(room.id),
+        };
+    };
+};

package/src/index.ts

@@ -0,0 +1 @@
+export { addonIndexedDB } from "./addonIndexedDB";

package/tsconfig.json

@@ -0,0 +1,5 @@
+{
+	"extends": "@pluv/tsconfig/frontend-generic.json",
+	"include": ["next-env.d.ts", "**/*.ts", "**/*.tsx"],
+	"exclude": ["node_modules"]
+}