change to vite and enabled typescript

src/scripts/wordsets.ts

@@ -0,0 +1,235 @@
+import { WordItem, WordSetInfo } from '@/types';
+import { v1 as uuidv1 } from 'uuid';
+
+// Add type declarations for the File System Access API
+declare global {
+  interface FileSystemWritableFileStream {
+    write(data: any): Promise<void>;
+    seek(position: number): Promise<void>;
+    truncate(size: number): Promise<void>;
+    close(): Promise<void>;
+  }
+
+  interface FileSystemFileHandle {
+    getFile(): Promise<File>;
+    createWritable(): Promise<FileSystemWritableFileStream>;
+  }
+
+  interface Window {
+    showSaveFilePicker(options?: {
+      types?: Array<{
+        description: string;
+        accept: Record<string, string[]>;
+      }>;
+    }): Promise<FileSystemFileHandle>;
+    
+    showOpenFilePicker(options?: {
+      multiple?: boolean;
+      types?: Array<{
+        description: string;
+        accept: Record<string, string[]>;
+      }>;
+    }): Promise<FileSystemFileHandle[]>;
+  }
+}
+
+export class Wordset {
+    private sets: {[className: string]: WordSetInfo[]};
+
+    constructor() {
+        this.sets = {};
+        let wordsets = localStorage.getItem("wordsets");
+        if (wordsets) {
+            this.sets = JSON.parse(wordsets);
+        }
+    }
+    
+    save(): void {
+        localStorage.setItem("wordsets", JSON.stringify(this.sets));
+    }
+    
+    get _inner(): {[className: string]: WordSetInfo[]} {
+        return this.sets;
+    }
+    
+    get _firstClass(): string | null {
+        return Object.keys(this.sets)[0] || null;
+    }
+    
+    get _allclass(): string[] {
+        return Object.keys(this.sets);
+    }
+    
+    get _allsets(): WordSetInfo[][] {
+        return Object.values(this.sets);
+    }
+    
+    getClass(class_name: string): WordSetInfo[] | null {
+        if (this.sets[class_name]) {
+            return this.sets[class_name];
+        }
+        else return null;
+    }
+    
+    getSetStatus(class_name: string, id: string): WordSetInfo | null {
+        let set_class = this.getClass(class_name);
+        if(set_class) {
+            for(let i of set_class) {
+                if(i.id === id) {
+                    return i;
+                }
+            }
+        }
+        return null;
+    }
+    
+    getId(class_name: string, id: string): number | undefined {
+        let set_class = this.sets[class_name];
+        for(let index in set_class) {
+            if(set_class[index].id === id) {
+                return Number(index);
+            }
+        }
+        return undefined;
+    }
+    
+    getSet(id: string): WordItem[] {
+        let sets = localStorage.getItem(id);
+        if (sets) {
+            return JSON.parse(sets);
+        }
+        else return [];
+    }
+    
+    delSet(class_name: string, index: number): boolean {
+        let set_class = this.sets[class_name];
+        if (set_class) {
+            if (set_class[index]) {
+                localStorage.removeItem(set_class[index].id);
+                this.sets[class_name].splice(index, 1);
+                if (!this.sets[class_name].length) {
+                    delete this.sets[class_name];
+                }
+                localStorage.setItem("wordsets", JSON.stringify(this.sets));
+                return true;
+            }
+        }
+        return false;
+    }
+    
+    addSet(class_name: string, name: string): string {
+        if (!this.sets[class_name]) {
+            this.sets[class_name] = [];
+        }
+        let id = uuidv1();
+        let time = (new Date()).getTime()
+        this.sets[class_name].push({
+            name: name,
+            id: id,
+            created: time,
+        });
+        localStorage.setItem(id, JSON.stringify([]));
+        this.save();
+        return id;
+    }
+    
+    saveSet(id: string, data: WordItem[]): void {
+        localStorage.setItem(id, JSON.stringify(data));
+    }
+    
+    renameSet(class_name: string, id: string, new_name: string): void {
+        let set_class = this.getClass(class_name);
+        if(set_class) {
+            for(let i of set_class) {
+                if(i.id === id) {
+                    i.name = new_name;
+                    this.save();
+                    return;
+                }
+            }
+        }
+    }
+    
+    addSetTo(origin_id: string, dest_id: string): number {
+        let origin_set = this.getSet(origin_id);
+        let dest_set = this.getSet(dest_id);
+        let set: {[word: string]: WordItem} = {};
+        origin_set.forEach(element => {
+            set[element.word] = element;
+        });
+        dest_set.forEach(element => {
+            set[element.word] = element;
+        });
+        let mergedSet = Object.values(set);
+        this.saveSet(dest_id, mergedSet);
+        return origin_set.length + dest_set.length - mergedSet.length;
+    }
+    
+    fromArray(arr: WordItem[], class_name: string, name: string): void {
+        let id = this.addSet(class_name, name);
+        this.saveSet(id, arr);
+    }
+    
+    async import_set(callback?: (count: number) => void): Promise<void> {
+        let [fileHandle] = await window.showOpenFilePicker({
+            types: [
+                {
+                    description: "JSON file",
+                    accept: {
+                        'text/json': ['.json'],
+                    },
+                },
+            ],
+        });
+        let file = await fileHandle.getFile();
+        let data = JSON.parse(await file.text());
+        let cnt = 0;
+        for (let i of Object.keys(data.wordsets)) {
+            for (let j of data.wordsets[i]) {
+                if (!localStorage.getItem(j.id)) {
+                    if (!this.sets[i]) this.sets[i] = [];
+                    this.sets[i].push(j);
+                    localStorage.setItem(j.id, data.words[j.id]);
+                    cnt++;
+                }
+            }
+        }
+        this.save();
+        if(typeof callback === "function") {
+            callback(cnt);
+        }
+    }
+    
+    async export_set(callback?: (count: number) => void): Promise<void> {
+        let fileHandle = await window.showSaveFilePicker({
+            types: [
+                {
+                    description: "JSON file",
+                    accept: {
+                        'text/json': ['.json'],
+                    },
+                },
+            ],
+        });
+        let writestream = await fileHandle.createWritable();
+        let data = {
+            wordsets: this.sets,
+            words: {} as {[id: string]: string}
+        };
+        let cnt = 0;
+        for (let i of Object.values(this.sets)) {
+            for (let j of i) {
+                let temp = localStorage.getItem(j.id);
+                if (temp) {
+                    data.words[j.id] = temp;
+                    cnt++;
+                }
+            }
+        }
+        await writestream.write(JSON.stringify(data));
+        await writestream.close();
+        if(typeof callback === "function") {
+            callback(cnt);
+        }
+    }
+}