feat: phase 2

Newfound motivation

src/stores.ts

@@ -0,0 +1,106 @@
+import { defineStore } from 'pinia';
+import { invoke } from '@tauri-apps/api/core';
+import { listen } from '@tauri-apps/api/event';
+import { Package, Profile } from './types';
+import { pkgKey } from './util';
+
+type InstallStatus = {
+    pkg: string;
+};
+
+export const usePkgStore = defineStore('pkg', {
+    state: (): { pkg: { [key: string]: Package }; prf: Profile | null } => {
+        return {
+            pkg: {},
+            prf: null,
+        };
+    },
+    getters: {
+        fromDepString: (state) => (str: string) => state.pkg[str] ?? null,
+        fromName: (state) => (namespace: string, name: string) =>
+            state.pkg[`${namespace}-${name}`] ?? null,
+        all: (state) => Object.values(state),
+        allLocal: (state) => Object.values(state.pkg).filter((p) => p.loc),
+        allRemote: (state) => Object.values(state.pkg).filter((p) => p.rmt),
+        profile: (state) => state.prf,
+        isEnabled: (state) => (pkg: Package | undefined) =>
+            pkg !== undefined && state.prf?.mods.includes(pkgKey(pkg)),
+    },
+    actions: {
+        setupListeners() {
+            listen<InstallStatus>('install-start', async (ev) => {
+                await this.reload(ev.payload.pkg);
+            });
+
+            listen<InstallStatus>('install-end', async (ev) => {
+                await this.reload(ev.payload.pkg);
+                await this.reloadProfile();
+            });
+        },
+
+        async reloadAll() {
+            await invoke('reload_all_packages');
+            const data = (await invoke('get_all_packages')) as {
+                [key: string]: Package;
+            };
+
+            for (const k of Object.keys(this)) {
+                delete this.pkg[k];
+            }
+
+            Object.assign(this.pkg, data);
+
+            if (this.prf !== null)
+                for (const [k, v] of Object.entries(this)) {
+                    if (this.prf.mods.includes(k)) {
+                        if (v.loc) {
+                            v.loc.enabled = true;
+                        } else {
+                            console.error(`${k} enabled but not present`);
+                        }
+                    }
+                }
+        },
+
+        async reload(pkgOrKey: string | Package) {
+            const key =
+                typeof pkgOrKey === 'string' ? pkgOrKey : pkgKey(pkgOrKey);
+            const rv: Package = await invoke('get_package', {
+                key,
+            });
+            if (this.pkg[key] === undefined) {
+                this.pkg[key] = {} as Package;
+            } else {
+                this.pkg[key].loc = null;
+                this.pkg[key].rmt = null;
+            }
+            Object.assign(this.pkg[key], rv);
+        },
+
+        async initProfile(path: string) {
+            this.prf = await invoke('init_profile', { path });
+        },
+
+        async saveProfile() {
+            await invoke('save_profile');
+        },
+
+        async reloadProfile() {
+            this.prf = await invoke('get_current_profile');
+        },
+
+        async fetch() {
+            await invoke('fetch_listings');
+            await this.reloadAll();
+        },
+
+        async toggle(pkg: Package | undefined, enable: boolean) {
+            if (pkg === undefined) {
+                return;
+            }
+            await invoke('toggle_package', { key: pkgKey(pkg), enable });
+            await this.reload(pkg);
+            await this.saveProfile();
+        },
+    },
+});