WIP: TS corpus chooser utils

app/scripts/components/corpus_chooser/corpus-chooser.js

@@ -6,7 +6,13 @@ import settings from "@/settings"
 import * as authenticationProxy from "@/components/auth/auth"
 import { html } from "@/util"
 import { loc } from "@/i18n"
-import * as treeUtil from "./util"
+import {
+    filterCorporaOnCredentials,
+    getAllSelected,
+    initCorpusStructure,
+    recalcFolderStatus,
+    updateLimitedAccess,
+} from "./util"
 import "@/components/corpus_chooser/corpus-time-graph"
 import "@/components/corpus_chooser/info-box"
 import "@/components/corpus_chooser/tree"
@@ -149,7 +155,7 @@ angular.module("korpApp").component("corpusChooser", {
                     return prev
                 }, {})
 
-                $ctrl.root = treeUtil.initCorpusStructure(ccCorpora, corpusIds)
+                $ctrl.root = initCorpusStructure(ccCorpora, corpusIds)
 
                 $ctrl.totalCount = Object.values(ccCorpora).length
                 $ctrl.totalNumberOfTokens = $ctrl.root.tokens
@@ -190,7 +196,7 @@ angular.module("korpApp").component("corpusChooser", {
             }
 
             $ctrl.onSelect = function () {
-                const currentCorpora = treeUtil.getAllSelected($ctrl.root)
+                const currentCorpora = getAllSelected($ctrl.root)
                 select(currentCorpora)
             }
 
@@ -208,13 +214,13 @@ angular.module("korpApp").component("corpusChooser", {
 
             $ctrl.updateLimitedAccess = function () {
                 if ($ctrl.root) {
-                    treeUtil.updateLimitedAccess($ctrl.root, $ctrl.credentials)
+                    updateLimitedAccess($ctrl.root, $ctrl.credentials)
                 }
             }
 
             function select(corporaIds, quiet = false) {
-                const selection = treeUtil.filterCorporaOnCredentials(settings.corpora, corporaIds, $ctrl.credentials)
-                treeUtil.recalcFolderStatus($ctrl.root)
+                const selection = filterCorporaOnCredentials(settings.corpora, corporaIds, $ctrl.credentials)
+                recalcFolderStatus($ctrl.root)
                 $ctrl.updateSelectedCount(selection)
                 // used when there is only one corpus selected to show name
                 if (selection.length == 1) {

app/scripts/components/corpus_chooser/tree.js

@@ -1,6 +1,6 @@
 /** @format */
 import angular from "angular"
-import * as treeUtil from "./util"
+import { getAllCorpora } from "./util"
 import settings from "@/settings"
 var collapsedImg = require("../../../img/collapsed.png")
 import { collatorSort, html } from "@/util"
@@ -97,7 +97,7 @@ angular.module("korpApp").component("ccTree", {
                     return
                 }
 
-                const corporaIds = treeUtil.getAllCorpora(folder)
+                const corporaIds = getAllCorpora(folder)
                 if (selectOnly(e)) {
                     $ctrl.selectOnly(corporaIds)
                 } else {

app/scripts/components/corpus_chooser/util.js → app/scripts/components/corpus_chooser/util.ts

@@ -1,81 +1,98 @@
 /** @format */
 import _ from "lodash"
 import settings from "@/settings"
+import { CorpusTransformed } from "@/settings/config-transformed.types"
+import { Folder } from "@/settings/config.types"
+
+type ChooserFolder = {
+    corpora: CorpusTransformed[]
+    numberOfChildren: number
+    tokens: number
+    sentences: number
+    subFolders: ChooserFolder[]
+    selected: "none" | "some" | "all"
+}
 
-export const initCorpusStructure = (collection, initialCorpusSelection) => {
+export const initCorpusStructure = (
+    collection: Record<string, CorpusTransformed>,
+    initialCorpusSelection: string[]
+) => {
     // first set the select status of all corpora
     for (const corpus of Object.values(collection)) {
         corpus.selected = initialCorpusSelection.includes(corpus.id)
 
-        const tokens = parseInt(corpus["info"]["Size"])
+        const tokens = parseInt(corpus.info.Size || "0")
         corpus.tokens = tokens
-        corpus.sentences = parseInt(corpus["info"]["Sentences"])
-        if (isNaN(corpus.sentences)) corpus.sentences = 0
+        corpus.sentences = parseInt(corpus.info.Sentences || "0")
     }
 
     /* recursive function to set the structure and compute
      * - select status of folders
      * - number of (total) children for each folder
      * propbably more stuff in the future
      */
-    function initFolders(folders) {
-        let totalCorporaIds = []
+    function initFolders(foldersRaw: Folder[]) {
+        const ids: string[] = []
         let totalTokens = 0
         let totalSentences = 0
 
-        for (const folder of folders) {
-            totalCorporaIds = totalCorporaIds.concat(folder.corpora || [])
-            folder.corpora = _.map(folder.corpora, (corpusId) => collection[corpusId])
-
-            const subFolders = []
-            _.map(folder["subfolders"], (value, key) => {
-                // this is needed for folder identity checks in chooser
-                value.id = key
-                subFolders.push(value)
-            })
-            folder.numberOfChildren = folder.corpora.length
-            folder.tokens = _.reduce(folder.corpora, (tokens, corpus) => tokens + corpus.tokens, 0)
-            folder.sentences = _.reduce(folder.corpora, (sentences, corpus) => sentences + corpus.sentences, 0)
-            folder.subFolders = subFolders
-            if (subFolders.length > 0) {
-                const [corporaIds, tokenCount, sentenceCount] = initFolders(subFolders)
-                totalCorporaIds = totalCorporaIds.concat(corporaIds)
-                folder.tokens += tokenCount
-                folder.sentences += sentenceCount
-                folder.numberOfChildren += corporaIds.length
+        const folders: ChooserFolder[] = foldersRaw.map((folder) => {
+            ids.push(...(folder.corpora || []))
+            const corpora = _.map(folder.corpora, (corpusId) => collection[corpusId])
+
+            // this is needed for folder identity checks in chooser
+            const subFoldersRaw = _.map(folder.subfolders || {}, (folder, id) => ({ ...folder, id }))
+            let nCorpora = corpora.length
+            let tokens = _.reduce(corpora, (tokens, corpus) => tokens + corpus.tokens!, 0)
+            let sentences = _.reduce(corpora, (sentences, corpus) => sentences + corpus.sentences!, 0)
+            let subFolders: ChooserFolder[] = []
+            if (subFoldersRaw.length > 0) {
+                const summary = initFolders(subFoldersRaw)
+                subFolders = summary.folders
+                ids.push(...summary.ids)
+                tokens += summary.tokens
+                sentences += summary.sentences
+                nCorpora += summary.ids.length
             }
-            folder.selected = getFolderSelectStatus(folder)
-
-            totalTokens += folder.tokens
-            totalSentences += folder.sentences
+            const selected = getFolderSelectStatus(folder)
+
+            totalTokens += tokens
+            totalSentences += sentences
+
+            return {
+                corpora,
+                numberOfChildren: nCorpora,
+                tokens,
+                sentences,
+                subFolders,
+                selected,
+            } satisfies ChooserFolder
+        })
+        return {
+            folders,
+            ids,
+            tokens: totalTokens,
+            sentences: totalSentences,
         }
-        return [totalCorporaIds, totalTokens, totalSentences]
     }
 
     // this is needed for folder identity checks in chooser
     for (const folderId of Object.keys(settings["folders"])) {
         settings["folders"][folderId].id = folderId
     }
 
-    const [totalCorporaIds, totalTokens, totalSentences] = initFolders(Object.values(settings["folders"]))
-    const topLevelCorpora = _.filter(collection, (corpus) => !totalCorporaIds.includes(corpus.id))
+    const { folders, ids, tokens, sentences } = initFolders(Object.values(settings["folders"]))
+    const topLevelCorpora = _.filter(collection, (corpus) => !ids.includes(corpus.id))
     const topLevelFolders = Object.values(settings["folders"])
 
     return {
         corpora: topLevelCorpora,
         subFolders: topLevelFolders,
-        tokens: _.reduce(topLevelCorpora, (tokens, corpus) => tokens + corpus.tokens, 0) + totalTokens,
+        tokens: _.reduce(topLevelCorpora, (tokensTop, corpus) => tokensTop + corpus.tokens!, 0) + tokens,
         isRoot: true,
     }
 }
 
-/*
- * Traverse entire tree to find list of all selected corpora
- */
-export const getAllSelected = (folder) => {
-    return getCorpora(folder, (corpus) => corpus.selected)
-}
-
 export const getAllCorpora = (folder) => {
     return getCorpora(folder)
 }
@@ -194,7 +211,7 @@ export const recalcFolderStatus = (folder) => {
     inner(folder)
 }
 
-function getFolderSelectStatus(folder) {
+function getFolderSelectStatus(folder): "none" | "some" | "all" {
     let selected = "none"
     let nothingFound = false
     for (const subFolder of folder.subFolders) {

app/scripts/settings/config-transformed.types.ts

@@ -33,4 +33,7 @@ export type CorpusTransformed = Omit<
     time?: Record<number, number>
     non_time?: number
     morphology?: string
+    selected?: boolean
+    tokens?: number
+    sentences?: number
 }