[fix] fixed save again

src/ts/drive/drive.ts

@@ -245,7 +245,7 @@ async function backupDrive(ACCESS_TOKEN:string) {
         }
     }
 
-    const dbData = encodeRisuSave(get(DataBase))
+    const dbData = encodeRisuSave(get(DataBase), 'compression')
 
     alertStore.set({
         type: "wait",
@@ -402,7 +402,7 @@ async function loadDrive(ACCESS_TOKEN:string, mode: 'backup'|'sync'):Promise<voi
             }
         }
         db.didFirstSetup = true
-        const dbData = encodeRisuSave(db)
+        const dbData = encodeRisuSave(db, 'compression')
 
         if(isTauri){
             await writeBinaryFile('database/database.bin', dbData, {dir: BaseDirectory.AppData})

src/ts/storage/globalApi.ts

@@ -203,6 +203,7 @@ export async function saveDb(){
     })
     while(true){
         if(changed){
+            changed = false
             const dbData = encodeRisuSave(get(DataBase))
             if(isTauri){
                 await writeBinaryFile('database/database.bin', dbData, {dir: BaseDirectory.AppData})

src/ts/storage/risuSave.ts

@@ -1,4 +1,4 @@
-import { Packr, decode } from "msgpackr";
+import { Packr, Unpackr, decode } from "msgpackr";
 import pako from "pako";
 import { isTauri } from "./globalApi";
 
@@ -6,31 +6,84 @@ const packr = new Packr({
     useRecords:true
 });
 
-export function encodeRisuSave(data:any){
-    const encoded = packr.encode(data)
-    if(isTauri){
-        return pako.deflate(encoded)
+const unpackr = new Unpackr({
+    int64AsType: 'number',
+    useRecords:true
+})
+
+const magicHeader = new Uint8Array([0, 82, 73, 83, 85, 83, 65, 86, 69, 0, 7]); 
+const magicCompressedHeader = new Uint8Array([0, 82, 73, 83, 85, 83, 65, 86, 69, 0, 8]); 
+
+export function encodeRisuSave(data:any, compression:'noCompression'|'compression' = 'noCompression'){
+    let encoded:Uint8Array = packr.encode(data)
+    if(isTauri || compression === 'compression'){
+        encoded = pako.deflate(encoded)
+        const result = new Uint8Array(encoded.length + magicCompressedHeader.length);
+        result.set(magicCompressedHeader, 0)
+        result.set(encoded, magicCompressedHeader.length)
+        return result
+    }
+    else{
+        const result = new Uint8Array(encoded.length + magicHeader.length);
+        result.set(magicHeader, 0)
+        result.set(encoded, magicHeader.length)
+        return result
     }
-    return encoded
 }
 
 export function decodeRisuSave(data:Uint8Array){
     try {
-        return decode(data)   
+        switch(checkHeader(data)){
+            case "compressed":
+                data = data.slice(magicCompressedHeader.length)
+                return decode(pako.inflate(data))
+            case "raw":
+                data = data.slice(magicHeader.length)
+                return unpackr.decode(data)
+        }
+        return unpackr.decode(data)
     }
     catch (error) {
         try {
             const risuSaveHeader = new Uint8Array(Buffer.from("\u0000\u0000RISU",'utf-8'))
             const realData = data.subarray(risuSaveHeader.length)
-            const dec = decode(realData)
+            const dec = unpackr.decode(realData)
             return dec   
         } catch (error) {
             const buf = Buffer.from(pako.inflate(Buffer.from(data)))
             try {
                 return JSON.parse(buf.toString('utf-8'))                            
             } catch (error) {
-                return decode(buf)
+                return unpackr.decode(buf)
             }
         }
     }
-}
+}
+
+function checkHeader(data: Uint8Array) {
+
+    let header:'none'|'compressed'|'raw' = 'raw'
+
+    if (data.length < magicHeader.length) {
+      return false;
+    }
+  
+    for (let i = 0; i < magicHeader.length; i++) {
+      if (data[i] !== magicHeader[i]) {
+        header = 'none'
+        break
+      }
+    }
+
+    if(header === 'none'){
+        header = 'compressed'
+        for (let i = 0; i < magicCompressedHeader.length; i++) {
+            if (data[i] !== magicCompressedHeader[i]) {
+                header = 'none'
+                break
+            }
+        }
+    }  
+    // All bytes matched
+    return header;
+  }