merge: dev into master

Author: arildm

Diff for: CHANGELOG.md

@@ -2,6 +2,40 @@
 
 ## [Unreleased]
 
+## [9.9.0] - 2025-03-24
+
+### Added
+
+- Choose to show word picture by frequency or LMI [#433](https://github.com/spraakbanken/korp-frontend/issues/433)
+- Word picture help texts
+
+### Changed
+
+- Display options in Simple search as a form [#357](https://github.com/spraakbanken/korp-frontend/issues/357)
+- Load corpus timespan data in parallel when loading app [#437](https://github.com/spraakbanken/korp-frontend/issues/437)
+  - Instead of `settings.time_data`, use `import { timeData } from "./timedata"`
+  - Await `getTimeData()` before using `timeData` or `corpus.time`/`corpus.non_time`. The function is memoized, so repeated calls will not affect performance
+- Load Statistics and Word picture result when the tab is selected [#442](https://github.com/spraakbanken/korp-frontend/issues/442)
+- The "medial part" search option is logically linked to initial and final part [#443](https://github.com/spraakbanken/korp-frontend/issues/443)
+- The display options (hits per page, sort within corpora, compile based on) were moved into the KWIC and Statistics tab correspondingly
+  - When these are changed, the search is re-triggered automatically
+  - The "compile based on" input was relabeled as "group by"
+- The "word" group-by option no longer gets disabled if it's the only selected option
+- Moved "Show context" option to the new display options location and changed to checkbox
+- Better readability for hit counts in lemgram autocomplete
+- More space in word picture tables [#102](https://github.com/spraakbanken/korp-frontend/issues/102)
+
+### Fixed
+
+- Selecting a search history item used to reset params that were not part of the search
+- Trend diagram legend missing
+- Internal search links in sidebar does not activate relevant search/result tabs [#450](https://github.com/spraakbanken/korp-frontend/issues/450)
+- Comparison result not showing if a search is not done first [#413](https://github.com/spraakbanken/korp-frontend/issues/413)
+- Extended search: do not cache operator options across corpora [#409](https://github.com/spraakbanken/korp-frontend/issues/409)
+- Error when logging out while protected corpora are selected [#440](https://github.com/spraakbanken/korp-frontend/issues/440)
+- Error when loading with restricted corpora selected and then dismissing login dialog [#399](https://github.com/spraakbanken/korp-frontend/issues/399)
+- Cached translation files cause broken UI after releases [#435](https://github.com/spraakbanken/korp-frontend/issues/435)
+
 ## [9.8.5] - 2025-03-17
 
 ### Fixed
@@ -380,6 +414,7 @@
 - Lots of bug fixes for the sidebar
 
 [unreleased]: https://github.com/spraakbanken/korp-frontend/compare/master...dev
+[9.9.0]: https://github.com/spraakbanken/korp-frontend/releases/tag/v9.9.0
 [9.8.5]: https://github.com/spraakbanken/korp-frontend/releases/tag/v9.8.5
 [9.8.4]: https://github.com/spraakbanken/korp-frontend/releases/tag/v9.8.4
 [9.8.3]: https://github.com/spraakbanken/korp-frontend/releases/tag/v9.8.3

Diff for: app/markup/about.html

@@ -1,5 +1,5 @@
 <div class="modal-header">
-    <h2>Korp version 9.8.5</h2>
+    <h2>Korp version 9.9.0</h2>
     <span ng-click="clickX()" class="close-x">×</span>
 
 </div>

Diff for: app/scripts/app.ts

@@ -6,7 +6,6 @@ import {
     IComponentOptions,
     ILocaleService,
     ILocationProvider,
-    IQService,
     IScope,
     ITimeoutService,
     ui,
@@ -18,7 +17,7 @@ import * as authenticationProxy from "@/components/auth/auth"
 import { initLocales } from "@/data_init"
 import { RootScope } from "@/root-scope.types"
 import { CorpusTransformed } from "./settings/config-transformed.types"
-import { getService, html } from "@/util"
+import { deferOk, getService, html } from "@/util"
 import { loc, locObj } from "@/i18n"
 import "@/components/app-header"
 import "@/components/searchtabs"
@@ -30,6 +29,9 @@ import { LocationService } from "./urlparams"
 import { LocLangMap } from "@/i18n/types"
 import { getAllCorporaInFolders } from "./components/corpus-chooser/util"
 
+// @ts-ignore
+const BUILD_HASH = __webpack_hash__
+
 // Catch unhandled exceptions within Angular, see https://docs.angularjs.org/api/ng/service/$exceptionHandler
 korpApp.factory("$exceptionHandler", [
     function () {
@@ -89,7 +91,7 @@ authenticationProxy.initAngular(korpApp)
 korpApp.config([
     "tmhDynamicLocaleProvider",
     (tmhDynamicLocaleProvider: tmh.tmh.IDynamicLocaleProvider) =>
-        tmhDynamicLocaleProvider.localeLocationPattern("translations/angular-locale_{{locale}}.js"),
+        tmhDynamicLocaleProvider.localeLocationPattern(`translations/angular-locale_{{locale}}.${BUILD_HASH}.js`),
 ])
 
 korpApp.config([
@@ -121,7 +123,6 @@ korpApp.run([
     "$locale",
     "tmhDynamicLocale",
     "tmhDynamicLocaleCache",
-    "$q",
     "$timeout",
     "$uibModal",
     async function (
@@ -130,17 +131,24 @@ korpApp.run([
         $locale: ILocaleService,
         tmhDynamicLocale: tmh.tmh.IDynamicLocale,
         tmhDynamicLocaleCache: ICacheObject,
-        $q: IQService,
         $timeout: ITimeoutService,
         $uibModal: ui.bootstrap.IModalService
     ) {
         const s = $rootScope
 
         s.extendedCQP = null
         s.globalFilterData = {}
-
-        /** This deferred is used to signal that the filter feature is ready. */
-        s.globalFilterDef = $q.defer<never>()
+        $rootScope.globalFilterDef = deferOk()
+        $rootScope.langDef = deferOk()
+        $rootScope.wordpicSortProp = "mi"
+
+        /** Get CQP corresponding to the current search, if any. */
+        $rootScope.getActiveCqp = () => {
+            if (!$rootScope.activeSearch) return undefined
+            // Simple search puts CQP in `simpleCQP`. Extended/advanced puts it in `activeSearch.val`.
+            const isSimple = ["word", "lemgram"].includes($rootScope.activeSearch.type)
+            return isSimple ? $rootScope.simpleCQP : $rootScope.activeSearch.val
+        }
 
         // Listen to url changes like #?lang=swe
         s.$on("$locationChangeSuccess", () => {
@@ -185,22 +193,22 @@ korpApp.run([
             $rootScope.$apply(() => ($rootScope["loc_data"] = data))
         )
 
-        s.waitForLogin = false
+        /** Whether initial corpus selection is deferred because it depends on authentication. */
+        let waitForLogin = false
+
+        async function initializeCorpusSelection(ids: string[], skipLogin?: boolean): Promise<void> {
+            if (!ids || ids.length == 0) ids = settings["preselected_corpora"] || []
 
-        async function initializeCorpusSelection(selectedIds: string[]): Promise<void> {
             // Resolve any folder ids to the contained corpus ids
-            selectedIds = selectedIds.flatMap((id) => getAllCorporaInFolders(settings.folders, id))
+            ids = ids.flatMap((id) => getAllCorporaInFolders(settings.folders, id))
 
-            let loginNeededFor: CorpusTransformed[] = []
+            const hasAccess = (corpus: CorpusTransformed) => authenticationProxy.hasCredential(corpus.id.toUpperCase())
 
-            for (const corpusId of selectedIds) {
-                const corpusObj = settings.corpora[corpusId]
-                if (corpusObj && corpusObj.limited_access) {
-                    if (!authenticationProxy.hasCredential(corpusId.toUpperCase())) {
-                        loginNeededFor.push(corpusObj)
-                    }
-                }
-            }
+            const deniedCorpora = ids
+                .map((id) => settings.corpora[id])
+                .filter((corpus) => corpus?.limited_access && !hasAccess(corpus))
+
+            const allowedIds = ids.filter((id) => !deniedCorpora.find((corpus) => corpus.id == id))
 
             const allCorpusIds = settings.corpusListing.corpora.map((corpus) => corpus.id)
 
@@ -212,14 +220,14 @@ korpApp.run([
                     content: "<korp-error></korp-error>",
                     resolvable: false,
                 })
-            } else if (loginNeededFor.length != 0) {
+            } else if (deniedCorpora.length != 0) {
                 // check if user has access
                 const loginNeededHTML = () =>
-                    loginNeededFor.map((corpus) => `<span>${locObj(corpus.title)}</span>`).join(", ")
+                    deniedCorpora.map((corpus) => `<span>${locObj(corpus.title)}</span>`).join(", ")
 
                 if (authenticationProxy.isLoggedIn()) {
                     // access partly or fully denied to selected corpora
-                    if (settings.corpusListing.corpora.length == loginNeededFor.length) {
+                    if (settings.corpusListing.corpora.length == deniedCorpora.length) {
                         openErrorModal({
                             content: "{{'access_denied' | loc:$root.lang}}",
                             buttonText: "go_to_start",
@@ -233,38 +241,37 @@ korpApp.run([
                                 <div>${loginNeededHTML()}</div>
                                 <div>{{'access_partly_denied_continue' | loc:$root.lang}}</div>`,
                             onClose: () => {
-                                const neededIds = loginNeededFor.map((corpus) => corpus.id)
-                                const filtered = selectedIds.filter((corpusId) => !neededIds.includes(corpusId))
-                                const selected = filtered.length ? filtered : settings["preselected_corpora"] || []
-                                initializeCorpusSelection(selected)
+                                initializeCorpusSelection(allowedIds)
                             },
                         })
                     }
-                } else {
+                } else if (!skipLogin) {
                     // login needed before access can be checked
                     openErrorModal({
                         content: html`<span class="mr-1">{{'login_needed_for_corpora' | loc:$root.lang}}:</span
                             >${loginNeededHTML()}`,
                         onClose: () => {
-                            s.waitForLogin = true
-                            statemachine.send("LOGIN_NEEDED", { loginNeededFor })
+                            waitForLogin = true
+                            statemachine.send("LOGIN_NEEDED", { loginNeededFor: deniedCorpora })
                         },
                     })
+                } else {
+                    // Login dismissed, fall back to allowed corpora
+                    initializeCorpusSelection(allowedIds)
                 }
-            } else if (!selectedIds.every((r) => allCorpusIds.includes(r))) {
+            } else if (!ids.every((r) => allCorpusIds.includes(r))) {
                 // some corpora missing
                 openErrorModal({
                     content: `{{'corpus_not_available' | loc:$root.lang}}`,
                     onClose: () => {
-                        const validIds = selectedIds.filter((corpusId) => allCorpusIds.includes(corpusId))
-                        const newIds = validIds.length ? validIds : settings["preselected_corpora"] || []
-                        initializeCorpusSelection(newIds)
+                        const validIds = ids.filter((corpusId) => allCorpusIds.includes(corpusId))
+                        initializeCorpusSelection(validIds)
                     },
                 })
             } else {
                 // here $timeout must be used so that message is not sent before all controllers/componenters are initialized
-                settings.corpusListing.select(selectedIds)
-                $timeout(() => $rootScope.$broadcast("initialcorpuschooserchange", selectedIds), 0)
+                settings.corpusListing.select(ids)
+                $timeout(() => $rootScope.$broadcast("initialcorpuschooserchange", ids), 0)
             }
         }
 
@@ -318,19 +325,27 @@ korpApp.run([
             }
         }
 
-        function getCorporaFromHash(): string[] {
-            const corpus = $location.search().corpus
-            return corpus ? corpus.split(",") : settings["preselected_corpora"] || []
+        const getCorporaFromHash = (): string[] => {
+            const value = $location.search().corpus
+            return value ? value.split(",") : []
         }
 
-        statemachine.listen("login", function () {
-            if (s.waitForLogin) {
-                s.waitForLogin = false
-                initializeCorpusSelection(getCorporaFromHash())
-            }
+        initializeCorpusSelection(getCorporaFromHash())
+
+        // Retry initialization after login
+        statemachine.listen("login", () => {
+            if (!waitForLogin) return
+            waitForLogin = false
+            initializeCorpusSelection(getCorporaFromHash())
+        })
+
+        // Retry intialization after dismissing login
+        statemachine.listen("logout", () => {
+            if (!waitForLogin) return
+            waitForLogin = false
+            initializeCorpusSelection(getCorporaFromHash(), true)
         })
 
-        initializeCorpusSelection(getCorporaFromHash())
         await initLocalesPromise
     },
 ])
@@ -342,4 +357,4 @@ korpApp.filter("prettyNumber", [
     "$rootScope",
     ($rootScope) => (input: string, lang: string) => Number(input).toLocaleString(lang || $rootScope.lang),
 ])
-korpApp.filter("maxLength", () => (val: string) => val.length > 39 ? val.slice(0, 36) + "…" : val)
+korpApp.filter("maxLength", () => (val: unknown) => String(val).length > 39 ? String(val).slice(0, 36) + "…" : val)

Diff for: app/scripts/backend/backend.ts

@@ -9,6 +9,7 @@ import { WithinParameters } from "./types"
 import { QueryResponse } from "./types/query"
 import { CountParams } from "./types/count"
 
+// TODO Convert to object
 export type CompareResult = [CompareTables, number, SavedSearch, SavedSearch, string[]]
 
 export type CompareTables = { positive: CompareItem[]; negative: CompareItem[] }

Diff for: app/scripts/backend/kwic-proxy.ts

@@ -21,17 +21,18 @@ export class KwicProxy extends BaseProxy {
 
     async makeRequest(
         options: KorpQueryRequestOptions,
-        page: number | undefined,
+        page?: number,
         progressCallback?: (data: ProgressReport<"query">) => void,
         kwicCallback?: (data: QueryResponse) => void
     ): Promise<QueryResponse> {
         this.resetRequest()
         const abortSignal = this.abortController.signal
 
-        if (!options.ajaxParams.within) {
-            _.extend(options.ajaxParams, settings.corpusListing.getWithinParameters())
+        if (!options.within) {
+            _.extend(options, settings.corpusListing.getWithinParameters())
         }
 
+        /** Calculate start and end from page and hpp. Only works for main hits. Examples must provide start and end in param. */
         function getPageInterval(): { start: number; end: number } {
             const hpp = locationSearchGet("hpp")
             const itemsPerPage = Number(hpp) || settings.hits_per_page_default
@@ -40,12 +41,12 @@ export class KwicProxy extends BaseProxy {
             return { start, end }
         }
 
-        const command = options.ajaxParams.command || "query"
+        const command = options.command || "query"
 
         const params: QueryParams = {
             default_context: settings.default_overview_context,
             ...getPageInterval(),
-            ...options.ajaxParams,
+            ...options,
         }
 
         const show: string[] = []
@@ -111,11 +112,6 @@ export class KwicProxy extends BaseProxy {
 const kwicProxyFactory = new Factory(KwicProxy)
 export default kwicProxyFactory
 
-export type KorpQueryRequestOptions = {
-    // TODO Should start,end really exist here as well as under ajaxParams?
-    start?: number
-    end?: number
-    ajaxParams: QueryParams & {
-        command?: "query" | "relations_sentences"
-    }
+export type KorpQueryRequestOptions = QueryParams & {
+    command?: "query" | "relations_sentences"
 }

Diff for: app/scripts/backend/lemgram-proxy.ts

@@ -12,6 +12,7 @@ export class LemgramProxy extends BaseProxy {
     async makeRequest(
         word: string,
         type: string,
+        sort: RelationsParams["sort"],
         onProgress: ProgressHandler<"relations">
     ): Promise<RelationsResponse> {
         this.resetRequest()
@@ -22,6 +23,7 @@ export class LemgramProxy extends BaseProxy {
             corpus: settings.corpusListing.stringifySelected(),
             incremental: true,
             type,
+            sort,
             max: 1000,
         }
         this.prevParams = params