Rewritten WS handling, file selections. Minor UI fixes.

cista-front/src/stores/documents.ts

@@ -30,10 +30,9 @@ export const useDocumentStore = defineStore({
     selected: new Set<FUID>(),
     uploadingDocuments: [],
     uploadCount: 0 as number,
-    wsWatch: undefined,
-    wsUpload: undefined,
     fileExplorer: null,
     error: '' as string,
+    connected: false,
     user: {
       username: '',
       privileged: false,
@@ -44,14 +43,16 @@ export const useDocumentStore = defineStore({
 
   actions: {
     updateRoot(root: DirEntry | null = null) {
-      root ??= this.root
+      if (!root) {
+        this.document = []
+        return
+      }
       // Transform tree data to flat documents array
       let loc = ""
       const mapper = ([name, attr]: [string, FileEntry | DirEntry]) => ({
+        ...attr,
         loc,
         name,
-        type: 'dir' in attr ? 'folder' : 'file' as 'folder' | 'file',
-        ...attr,
         sizedisp: formatSize(attr.size),
         modified: formatUnixDate(attr.mtime),
         haystack: haystackFormat(name),
@@ -61,17 +62,19 @@ export const useDocumentStore = defineStore({
       for (let doc; (doc = queue.shift()) !== undefined;) {
         docs.push(doc)
         if ("dir" in doc) {
+          // Recurse but replace recursive structure with boolean
           loc = doc.loc ? `${doc.loc}/${doc.name}` : doc.name
           queue.push(...Object.entries(doc.dir).map(mapper))
+          doc.dir = true
         }
+        else doc.dir = false
       }
       // Pre sort directory entries folders first then files, names in natural ordering
       docs.sort((a, b) =>
         // @ts-ignore
-        (a.type === "file") - (b.type === "file") ||
+        b.dir - a.dir ||
         collator.compare(a.name, b.name)
       )
-      this.root = root
       this.document = docs
     },
     updateUploadingDocuments(key: number, progress: number) {
@@ -119,53 +122,46 @@ export const useDocumentStore = defineStore({
       return ret
     },
     selectedFiles(): SelectedItems {
-      function traverseDir(data: DirEntry | FileEntry, path: string, relpath: string) {
-        if (!('dir' in data)) return
-        for (const [name, attr] of Object.entries(data.dir)) {
-          const fullname = path ? `${path}/${name}` : name
-          const key = attr.key
-          // Is this the file we are looking for? Ignore if nested within another selection.
-          let r = relpath
-          if (selected.has(key) && !relpath) {
-            ret.selected.add(key)
-            ret.rootdir[name] = attr
-            r = name
-          } else if (relpath) {
-            r = `${relpath}/${name}`
-          }
-          if (r) {
-            ret.entries[key] = attr
-            ret.fullpath[key] = fullname
-            ret.relpath[key] = r
-            ret.ids.push(key)
-            if (!('dir' in attr)) ret.url[key] = `/files/${fullname}`
-          }
-          traverseDir(attr, fullname, r)
+      const selected = this.selected
+      const found = new Set<FUID>()
+      const ret: SelectedItems = {
+        missing: new Set(),
+        docs: {},
+        keys: [],
+        recursive: [],
+      }
+      for (const doc of this.document) {
+        if (selected.has(doc.key)) {
+          found.add(doc.key)
+          ret.keys.push(doc.key)
+          ret.docs[doc.key] = doc
         }
       }
-      const selected = this.selected
-      const ret: SelectedItems = {
-        selected: new Set<FUID>(),
-        missing: new Set<FUID>(),
-        rootdir: {} as DirList,
-        entries: {} as Record<FUID, FileEntry | DirEntry>,
-        fullpath: {} as Record<FUID, string>,
-        relpath: {} as Record<FUID, string>,
-        url: {} as Record<FUID, string>,
-        ids: [] as FUID[]
-      }
-      traverseDir(this.root, '', '')
       // What did we not select?
-      for (const id of selected) {
-        if (!ret.selected.has(id)) ret.missing.add(id)
+      for (const key of selected) if (!found.has(key)) ret.missing.add(key)
+      // Build a flat list including contents recursively
+      const relnames = new Set<string>()
+      function add(rel: string, full: string, doc: Document) {
+        if (!doc.dir && relnames.has(rel)) throw Error(`Multiple selections conflict for: ${rel}`)
+        relnames.add(rel)
+        ret.recursive.push([rel, full, doc])
       }
-      // Sorted array of FUIDs for easy traversal
-      ret.ids.sort((a, b) =>
-        ret.relpath[a].localeCompare(ret.relpath[b], undefined, {
-          numeric: true,
-          sensitivity: 'base'
-        })
-      )
+      for (const key of ret.keys) {
+        const base = ret.docs[key]
+        const basepath = base.loc ? `${base.loc}/${base.name}` : base.name
+        const nremove = base.loc.length
+        add(base.name, basepath, base)
+        for (const doc of this.document) {
+          if (doc.loc === basepath || doc.loc.startsWith(basepath) && doc.loc[basepath.length] === '/') {
+            const full = doc.loc ? `${doc.loc}/${doc.name}` : doc.name
+            const rel = full.slice(nremove)
+            add(rel, full, doc)
+          }
+        }
+      }
+      // Sort by rel (name stored as on download)
+      ret.recursive.sort((a, b) => collator.compare(a[0], b[0]))
+
       return ret
     }
   }