@cripty2001/utils 0.0.175 → 0.0.177

package/dist/Appstorage.d.ts

@@ -0,0 +1,37 @@
+import { JSONEncodable } from '@cripty2001/utils';
+import { Whispr } from '@cripty2001/whispr';
+export type AppstorageData = Record<string, JSONEncodable>;
+export type AppstorageItemData<T extends AppstorageData> = {
+    key: string;
+    data: T;
+    rev: number;
+    deleted: boolean;
+};
+export declare class Appstorage {
+    private static readonly instances;
+    static getInstance(key: string): Appstorage;
+    readonly PREFIX: string;
+    index: Whispr<Record<string, AppstorageItem<any>>>;
+    private _setIndex;
+    private readonly refreshInterval;
+    private constructor();
+    add<T extends AppstorageData>(key: string, data: T): AppstorageItem<T>;
+    get<T extends AppstorageData>(key: string): AppstorageItem<T>;
+    private listData;
+    private refresh;
+}
+declare class AppstorageItem<T extends AppstorageData> {
+    readonly PREFIX: string;
+    private static readonly instances;
+    private static readonly refreshInterval;
+    readonly key: string;
+    readonly data: Whispr<AppstorageItemData<T>>;
+    readonly update: (data: T) => void;
+    readonly remove: () => void;
+    private _setData;
+    static get(PREFIX: string, key: string): AppstorageItem<any>;
+    private constructor();
+    private refresh;
+    private loadData;
+}
+export {};

package/dist/Appstorage.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Appstorage = void 0;
+const dispatcher_1 = require("@cripty2001/utils/dispatcher");
+const whispr_1 = require("@cripty2001/whispr");
+class Appstorage {
+    static instances = new Map();
+    static getInstance(key) {
+        if (!this.instances.has(key))
+            this.instances.set(key, new Appstorage(key));
+        return this.instances.get(key);
+    }
+    PREFIX;
+    index;
+    _setIndex;
+    refreshInterval = setInterval(() => {
+        this.refresh();
+    }, 200);
+    constructor(PREFIX) {
+        this.PREFIX = PREFIX;
+        [this.index, this._setIndex] = whispr_1.Whispr.create({});
+    }
+    add(key, data) {
+        const k = `${this.PREFIX}${key}`;
+        if (localStorage.getItem(k) !== null)
+            throw new Error(`${key} already exists in storage`);
+        localStorage.setItem(k, JSON.stringify({
+            key: k,
+            data: data,
+            rev: 0,
+            deleted: false
+        }));
+        return AppstorageItem.get(this.PREFIX, key);
+    }
+    get(key) {
+        return AppstorageItem.get(this.PREFIX, key);
+    }
+    listData() {
+        const toReturn = [];
+        for (let i = 0; i < localStorage.length; i++) {
+            const key = localStorage.key(i);
+            if (key === null || !key.startsWith(this.PREFIX))
+                continue;
+            toReturn.push(key.replace(this.PREFIX, ""));
+        }
+        return toReturn;
+    }
+    refresh() {
+        const newitems = this.listData()
+            .filter(key => this.index.value[key] === undefined)
+            .map(key => ({
+            key: key,
+            ref: this.get(key)
+        }))
+            .filter(item => !item.ref.data.value.deleted)
+            .reduce((acc, item) => {
+            acc[item.key] = item.ref;
+            return acc;
+        }, {});
+        if (Object.keys(newitems).length > 0) {
+            this._setIndex({
+                ...this.index.value,
+                ...newitems
+            });
+        }
+    }
+}
+exports.Appstorage = Appstorage;
+class AppstorageItem {
+    PREFIX;
+    static instances = new Map();
+    static refreshInterval = setInterval(() => {
+        this.instances.forEach(item => item.refresh());
+    }, 200);
+    key;
+    data;
+    update;
+    remove;
+    _setData;
+    static get(PREFIX, key) {
+        const k = `${PREFIX}${key}`;
+        if (!this.instances.has(k))
+            this.instances.set(k, new AppstorageItem(PREFIX, key));
+        return this.instances.get(k);
+    }
+    constructor(PREFIX, key) {
+        this.PREFIX = PREFIX;
+        this.key = key;
+        [this.data, this._setData] = whispr_1.Whispr.create(this.loadData());
+        this.update = (data) => {
+            this._setData({
+                key: `${this.PREFIX}${this.key}`,
+                rev: this.data.value.rev + 1,
+                deleted: false,
+                data: data
+            });
+        };
+        this.remove = () => {
+            this._setData({
+                key: `${this.PREFIX}${this.key}`,
+                rev: this.data.value.rev + 1,
+                deleted: true,
+                data: {}
+            });
+        };
+        new dispatcher_1.Dispatcher(this.data, async () => {
+            const curr = this.loadData();
+            if (this.data.value.rev > curr.rev) {
+                localStorage.setItem(`${this.PREFIX}${this.key}`, JSON.stringify(this.data.value));
+            }
+        }, 500);
+    }
+    refresh() {
+        const data = this.loadData();
+        if (data.rev > this.data.value.rev) {
+            console.log("Updating", this.data.value.rev, "->", data.rev);
+            this._setData(data);
+        }
+    }
+    loadData() {
+        const raw_data = localStorage.getItem(`${this.PREFIX}${this.key}`);
+        if (raw_data === null)
+            throw new Error(`${this.key} does not exist in storage`);
+        return JSON.parse(raw_data);
+    }
+}

package/dist/Searcher/index.js

@@ -7,10 +7,9 @@ class Searcher {
         this.data = data;
     }
     search(query, limit) {
-        if (query === "")
-            return this.data;
         return this.data
-            .filter(item => item.queries.some(q => q.includes(query.toLowerCase())))
+            .filter(item => query === '' ||
+            item.queries.some(q => q.includes(query.toLowerCase())))
             .sort((a, b) => a.order - b.order)
             .slice(0, limit);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cripty2001/utils",
-  "version": "0.0.175",
+  "version": "0.0.177",
   "description": "Internal Set of utils. If you need them use them, otherwise go to the next package ;)",
   "homepage": "https://github.com/cripty2001/utils#readme",
   "bugs": {
@@ -58,6 +58,10 @@
       "import": "./dist/Dispatcher.js",
       "types": "./dist/Dispatcher.d.ts"
     },
+    "./appstorage": {
+      "import": "./dist/AppStorage/index.js",
+      "types": "./dist/AppStorage/index.d.ts"
+    },
     "./searcher": {
       "import": "./dist/Searcher/index.js",
       "types": "./dist/Searcher/index.d.ts"