@fiduswriter/bibliography-manager 0.1.7 → 0.1.9

package/src/database/{index.js → index.ts}

@@ -1,10 +1,23 @@
 import {activateWait, addAlert, deactivateWait} from "fwtoolkit"
 import {BibliographyDBServerConnector} from "./server_connector.js"
+import type {
+    BibCategory,
+    BibDBEntry,
+    BibliographyApp,
+    IdTranslation,
+    SaveCategoriesRequest,
+    ServerBibItem
+} from "../types/biblio.js"
 
 const FW_LOCALSTORAGE_VERSION = "1.2"
 
 export class BibliographyDB {
-    constructor(app) {
+    app: BibliographyApp
+    db: Record<number, BibDBEntry>
+    cats: BibCategory[]
+    sc: BibliographyDBServerConnector
+
+    constructor(app: BibliographyApp) {
         this.app = app
         this.db = {}
         this.cats = []
@@ -15,16 +28,16 @@ export class BibliographyDB {
      * @function getDB
      */
 
-    getDB() {
+    getDB(): Promise<void> {
         const localStorageVersion = window.localStorage.getItem("version")
         let lastModified = Number.parseInt(
-                window.localStorage.getItem("last_modified_biblist")
+                window.localStorage.getItem("last_modified_biblist") || ""
             ),
             numberOfEntries = Number.parseInt(
-                window.localStorage.getItem("number_of_entries")
+                window.localStorage.getItem("number_of_entries") || ""
             ),
             localStorageOwnerId = Number.parseInt(
-                window.localStorage.getItem("owner_id")
+                window.localStorage.getItem("owner_id") || ""
             )
 
         // A dictionary to look up bib fields by their fw type name.
@@ -54,35 +67,32 @@ export class BibliographyDB {
             .then(
                 ({bibCats, bibList, lastModified, numberOfEntries, userId}) => {
                     bibCats.forEach(bibCat => this.cats.push(bibCat))
+                    let bibListItems: ServerBibItem[]
                     if (bibList) {
-                        try {
-                            window.localStorage.setItem(
-                                "biblist",
-                                JSON.stringify(bibList)
-                            )
-                            window.localStorage.setItem(
-                                "last_modified_biblist",
-                                lastModified
-                            )
-                            window.localStorage.setItem(
-                                "number_of_entries",
-                                numberOfEntries
-                            )
-                            window.localStorage.setItem("owner_id", userId)
-                            window.localStorage.setItem(
-                                "version",
-                                FW_LOCALSTORAGE_VERSION
-                            )
-                        } catch (error) {
-                            // The local storage was likely too small
-                            throw error
-                        }
+                        bibListItems = bibList
+                        window.localStorage.setItem(
+                            "biblist",
+                            JSON.stringify(bibListItems)
+                        )
+                        window.localStorage.setItem(
+                            "last_modified_biblist",
+                            String(lastModified)
+                        )
+                        window.localStorage.setItem(
+                            "number_of_entries",
+                            String(numberOfEntries)
+                        )
+                        window.localStorage.setItem("owner_id", String(userId))
+                        window.localStorage.setItem(
+                            "version",
+                            FW_LOCALSTORAGE_VERSION
+                        )
                     } else {
-                        bibList = JSON.parse(
-                            window.localStorage.getItem("biblist")
+                        bibListItems = JSON.parse(
+                            window.localStorage.getItem("biblist") || "[]"
                         )
                     }
-                    bibList.forEach(({id, bibDBEntry}) => {
+                    bibListItems.forEach(({id, bibDBEntry}) => {
                         this.db[id] = bibDBEntry
                     })
                     deactivateWait()
@@ -100,7 +110,10 @@ export class BibliographyDB {
      * @function saveBibEntries
      * @param tmpDB The bibliography DB with temporary IDs to be send to the server.
      */
-    saveBibEntries(tmpDB, isNew) {
+    saveBibEntries(
+        tmpDB: Record<number, BibDBEntry>,
+        isNew: boolean
+    ): Promise<IdTranslation[]> {
         return this.sc
             .saveBibEntries(tmpDB, isNew)
             .then(idTranslations =>
@@ -121,10 +134,14 @@ export class BibliographyDB {
                 } else {
                     throw error
                 }
+                return []
             })
     }
 
-    updateLocalBibEntries(tmpDB, idTranslations) {
+    updateLocalBibEntries(
+        tmpDB: Record<number, BibDBEntry>,
+        idTranslations: IdTranslation[]
+    ): IdTranslation[] {
         idTranslations.forEach(bibTrans => {
             this.db[bibTrans[1]] = tmpDB[bibTrans[0]]
         })
@@ -136,7 +153,7 @@ export class BibliographyDB {
      * @function saveCategories
      * @param cats The category objects to add.
      */
-    saveCategories(cats) {
+    saveCategories(cats: SaveCategoriesRequest): Promise<BibCategory[]> {
         activateWait()
 
         return this.sc
@@ -147,7 +164,10 @@ export class BibliographyDB {
                     this.cats.pop()
                 }
                 while (bibCats.length > 0) {
-                    this.cats.push(bibCats.pop())
+                    const cat = bibCats.pop()
+                    if (cat) {
+                        this.cats.push(cat)
+                    }
                 }
                 addAlert("success", gettext("The categories have been updated"))
                 deactivateWait()
@@ -169,6 +189,7 @@ export class BibliographyDB {
                 } else {
                     throw error
                 }
+                return []
             })
     }
 
@@ -176,10 +197,10 @@ export class BibliographyDB {
      * @function deleteCategory
      * @param ids A list of ids to delete.
      */
-    deleteCategory(ids) {
+    deleteCategory(ids: number[]): Promise<number[]> {
         return this.sc.deleteCategory(ids).then(() => {
             const deletedPks = ids.slice()
-            const deletedBibCats = []
+            const deletedBibCats: BibCategory[] = []
             this.cats.forEach(bibCat => {
                 if (ids.indexOf(bibCat.id) !== -1) {
                     deletedBibCats.push(bibCat)
@@ -197,9 +218,9 @@ export class BibliographyDB {
      * @function deleteBibEntries
      * @param ids A list of bibliography item ids that are to be deleted.
      */
-    deleteBibEntries(ids) {
+    deleteBibEntries(ids: number[]): Promise<number[]> {
         activateWait()
-        ids = ids.map(id => Number.parseInt(id))
+        ids = ids.map(id => Number.parseInt(String(id)))
         return this.sc
             .deleteBibEntries(ids)
             .then(() => {
@@ -229,6 +250,7 @@ export class BibliographyDB {
                 } else {
                     throw error
                 }
+                return []
             })
     }
 }

package/src/database/server_connector.ts

@@ -0,0 +1,92 @@
+import {post, postJson} from "fwtoolkit/network"
+import type {
+    BibCategory,
+    BibDBEntry,
+    BiblistResponse,
+    DeleteBibEntriesRequest,
+    DeleteCategoryRequest,
+    IdTranslation,
+    SaveCategoriesRequest,
+    SaveCategoriesResponse,
+    SaveBibEntriesRequest,
+    ServerBibItem
+} from "../types/biblio.js"
+
+// class for server calls of BibliographyDB.
+export class BibliographyDBServerConnector {
+    constructor() {}
+
+    getDB(
+        lastModified: number,
+        numberOfEntries: number,
+        localStorageOwnerId: number
+    ): Promise<{
+        bibCats: BibCategory[]
+        bibList: ServerBibItem[] | false
+        lastModified: number
+        numberOfEntries: number
+        userId: number
+    }> {
+        return postJson("/api/bibliography/biblist/", {
+            last_modified: lastModified,
+            number_of_entries: numberOfEntries,
+            user_id: localStorageOwnerId
+        }).then(({json}) => {
+            const response = json as BiblistResponse
+            return {
+                bibCats: response["bib_categories"],
+                bibList: response.hasOwnProperty("bib_list")
+                    ? (response["bib_list"] as BibDBEntry[]).map(item =>
+                          this.serverBibItemToBibDB(item)
+                      )
+                    : false,
+                lastModified: response["last_modified"],
+                numberOfEntries: response["number_of_entries"],
+                userId: response["user_id"]
+            }
+        })
+    }
+
+    /** Converts a bibliography item as it arrives from the server to a BibDB object.
+     * @function serverBibItemToBibDB
+     * @param item The bibliography item from the server.
+     */
+    serverBibItemToBibDB(bibDBEntry: BibDBEntry): ServerBibItem {
+        return {
+            id: (bibDBEntry as BibDBEntry & {id: number}).id,
+            bibDBEntry
+        }
+    }
+
+    saveBibEntries(
+        tmpDB: Record<number, BibDBEntry>,
+        isNew: boolean
+    ): Promise<IdTranslation[]> {
+        return postJson("/api/bibliography/save/", {
+            is_new: isNew,
+            bibs: tmpDB
+        } as SaveBibEntriesRequest & Record<string, unknown>).then(
+            ({json}) => (json as {id_translations: IdTranslation[]})["id_translations"]
+        )
+    }
+
+    saveCategories(cats: SaveCategoriesRequest): Promise<BibCategory[]> {
+        return postJson("/api/bibliography/save_category/", cats as unknown as Record<string, unknown>).then(
+            ({json}) => {
+                return (json as SaveCategoriesResponse).entries
+            }
+        )
+    }
+
+    deleteCategory(ids: number[]): Promise<Response> {
+        return post("/api/bibliography/delete_category/", {
+            ids
+        } as DeleteCategoryRequest & Record<string, unknown>)
+    }
+
+    deleteBibEntries(ids: number[]): Promise<Response> {
+        return post("/api/bibliography/delete/", {
+            ids
+        } as DeleteBibEntriesRequest & Record<string, unknown>)
+    }
+}

package/src/export/{index.js → index.ts}

@@ -1,20 +1,27 @@
 import {ZipFileCreator} from "fwtoolkit/file/zip"
 import download from "downloadjs"
+import type {BibDBCollection} from "../types/biblio.js"
 
 export class BibLatexFileExporter {
-    constructor(bibDB, pks) {
+    pks: number[]
+    bibDB: BibDBCollection
+
+    constructor(bibDB: BibDBCollection, pks: number[]) {
         this.pks = pks // A list of pk values of the bibliography items to be exported.
         this.bibDB = bibDB // The bibliography database to export from.
     }
 
-    init() {
+    init(): void {
         import("bibliojson").then(({BibLatexExporter}) => {
-            const exporter = new BibLatexExporter(this.bibDB.db, this.pks)
+            const exporter = new BibLatexExporter(
+                this.bibDB.db,
+                this.pks.map(String)
+            )
 
             const zipper = new ZipFileCreator([
                 {
                     filename: "bibliography.bib",
-                    contents: exporter.output
+                    contents: (exporter as unknown as {output: string}).output
                 }
             ])
             zipper
@@ -25,3 +32,8 @@ export class BibLatexFileExporter {
         })
     }
 }
+
+export function exportBibFile(bibDB: BibDBCollection, pks: number[]): void {
+    const exporter = new BibLatexFileExporter(bibDB, pks)
+    exporter.init()
+}

package/src/form/{cats.js → cats.ts}

@@ -1,7 +1,15 @@
 import {CheckableList} from "fwtoolkit"
+import type {BibCategory} from "../types/biblio.js"
 
 export class CatsForm {
-    constructor(dom, initialValue = [], options = []) {
+    dom: HTMLElement
+    checkableList: CheckableList
+
+    constructor(
+        dom: HTMLElement,
+        initialValue: (string | number)[] = [],
+        options: BibCategory[] = []
+    ) {
         this.dom = dom
         this.checkableList = new CheckableList({
             dom,
@@ -14,11 +22,11 @@ export class CatsForm {
         })
     }
 
-    init() {
+    init(): void {
         // CheckableList is already rendered by the constructor.
     }
 
-    get value() {
+    get value(): (string | number)[] {
         return this.checkableList.value
     }
 }

package/src/form/fields/{date.js → date.ts}

@@ -1,23 +1,28 @@
 import {edtfParse} from "bibliojson"
 
 export class DateFieldForm {
-    constructor(dom, initialValue = "", placeHolder = "") {
+    dom: HTMLElement
+    initialValue: string
+    placeHolder: string
+
+    constructor(dom: HTMLElement, initialValue = "", placeHolder = "") {
         this.dom = dom
         this.initialValue = initialValue
         this.placeHolder = placeHolder
     }
 
-    init() {
+    init(): void {
         this.dom.innerHTML = `<input class="fw-date" type="text" value="${this.initialValue}" placeholder="${this.placeHolder}">`
     }
 
-    get value() {
-        const formValue = this.dom.querySelector("input.fw-date").value
+    get value(): string | false {
+        const formValue = (this.dom.querySelector("input.fw-date") as HTMLInputElement)
+            .value
         // If the form has not been filled out, don't consider this form
         return formValue.length > 0 ? formValue : false
     }
 
-    check() {
+    check(): boolean {
         const formValue = this.value
         if (formValue) {
             const checkValue = edtfParse(formValue).valid

package/src/form/fields/{key.js → key.ts}

@@ -1,9 +1,22 @@
 import {TypeSwitch} from "fwtoolkit"
 import {getBibOptionTitle} from "../strings.js"
 import {LiteralFieldForm} from "./literal.js"
+import type {BibFieldType} from "../../types/biblio.js"
 
 export class KeyFieldForm {
-    constructor(dom, initialValue, _unused, fieldType = undefined) {
+    currentValue: Record<string, unknown>
+    dom: HTMLElement
+    fieldType: BibFieldType | undefined
+    predefined: boolean
+    typeSwitch!: TypeSwitch
+    fields: Record<string, LiteralFieldForm> = {}
+
+    constructor(
+        dom: HTMLElement,
+        initialValue: unknown,
+        _unused?: unknown,
+        fieldType: BibFieldType | undefined = undefined
+    ) {
         this.currentValue = {}
         this.dom = dom
         this.fieldType = fieldType
@@ -17,13 +30,13 @@ export class KeyFieldForm {
         }
     }
 
-    init() {
+    init(): void {
         this.typeSwitch = new TypeSwitch({
             dom: this.dom,
             label1: gettext("From list"),
             label2: gettext("Custom"),
             initialMode: this.predefined ? 1 : 2,
-            disabled: this.fieldType.strict,
+            disabled: this.fieldType?.strict,
             beforeChange: () => {
                 const formValue = this.value
                 if (formValue) {
@@ -42,7 +55,7 @@ export class KeyFieldForm {
         this.drawForm()
     }
 
-    drawForm() {
+    drawForm(): void {
         if (this.predefined) {
             this.drawSelectionListForm()
         } else {
@@ -50,22 +63,24 @@ export class KeyFieldForm {
         }
     }
 
-    drawSelectionListForm() {
+    drawSelectionListForm(): void {
         this.typeSwitch.innerElement.innerHTML = `
                 <select class='key-selection'><option value=''></option></select>
                 <div class="fw-select-arrow fa fa-caret-down"></div>
             `
-        const selectEl =
-            this.typeSwitch.innerElement.querySelector(".key-selection")
-        if (Array.isArray(this.fieldType.options)) {
-            this.fieldType.options.forEach(option => {
+        const selectEl = this.typeSwitch.innerElement.querySelector(
+            ".key-selection"
+        ) as HTMLSelectElement
+        const options = this.fieldType?.options
+        if (Array.isArray(options)) {
+            options.forEach(option => {
                 selectEl.insertAdjacentHTML(
                     "beforeend",
                     `<option value="${option}">${getBibOptionTitle(option)}</option>`
                 )
             })
-        } else {
-            Object.keys(this.fieldType.options).forEach(option => {
+        } else if (options) {
+            Object.keys(options).forEach(option => {
                 selectEl.insertAdjacentHTML(
                     "beforeend",
                     `<option value="${option}">${getBibOptionTitle(option)}</option>`
@@ -74,24 +89,27 @@ export class KeyFieldForm {
         }
 
         if (this.currentValue["predefined"]) {
-            selectEl.value = this.currentValue["predefined"]
+            selectEl.value = String(this.currentValue["predefined"])
         }
     }
 
-    drawCustomInputForm() {
+    drawCustomInputForm(): void {
         this.fields = {}
         this.typeSwitch.innerElement.innerHTML = `<div class='custom-input field-part field-part-single'></div>`
         this.fields["custom"] = new LiteralFieldForm(
-            this.typeSwitch.innerElement.querySelector(".custom-input"),
-            this.currentValue["custom"]
+            this.typeSwitch.innerElement.querySelector(
+                ".custom-input"
+            ) as HTMLElement,
+            this.currentValue["custom"] as Record<string, unknown>[]
         )
         this.fields.custom.init()
     }
 
-    get value() {
+    get value(): string | Record<string, unknown>[] | false {
         if (this.predefined) {
-            const selectEl =
-                this.typeSwitch.innerElement.querySelector(".key-selection")
+            const selectEl = this.typeSwitch.innerElement.querySelector(
+                ".key-selection"
+            ) as HTMLSelectElement
             const selectionValue =
                 selectEl.options[selectEl.selectedIndex].value
             if (selectionValue === "") {
@@ -107,7 +125,7 @@ export class KeyFieldForm {
         }
     }
 
-    check() {
+    check(): boolean {
         return true
     }
 }

package/src/form/fields/{key_list.js → key_list.ts}

@@ -1,12 +1,23 @@
 import {InputList} from "fwtoolkit"
 import {KeyFieldForm} from "./key.js"
+import type {BibFieldType} from "../../types/biblio.js"
 
 export class KeyListForm {
-    constructor(dom, initialValue = [""], _unused, fieldType = undefined) {
+    dom: HTMLElement
+    fieldType: BibFieldType | undefined
+    fieldHandlers: WeakMap<HTMLElement, KeyFieldForm>
+    inputList: InputList<unknown>
+
+    constructor(
+        dom: HTMLElement,
+        initialValue: unknown[] = [""],
+        _unused?: unknown,
+        fieldType: BibFieldType | undefined = undefined
+    ) {
         this.dom = dom
         this.fieldType = fieldType
         this.fieldHandlers = new WeakMap()
-        this.inputList = new InputList({
+        this.inputList = new InputList<unknown>({
             dom,
             initialValues: initialValue,
             emptyValue: "",
@@ -14,7 +25,7 @@ export class KeyListForm {
                 html: `<div class="key-field"></div>`,
                 bind: el => {
                     const fieldHandler = new KeyFieldForm(
-                        el.firstElementChild,
+                        el.firstElementChild as HTMLElement,
                         value,
                         false,
                         this.fieldType
@@ -23,15 +34,15 @@ export class KeyListForm {
                     this.fieldHandlers.set(el, fieldHandler)
                 }
             }),
-            getValue: el => this.fieldHandlers.get(el).value
+            getValue: el => this.fieldHandlers.get(el)!.value
         })
     }
 
-    init() {
+    init(): void {
         // InputList is already rendered by the constructor.
     }
 
-    get value() {
+    get value(): unknown[] | false {
         const formValue = this.inputList.values.filter(value => value !== false)
         if (formValue.length === 0) {
             return false
@@ -39,7 +50,7 @@ export class KeyListForm {
         return formValue
     }
 
-    check() {
+    check(): boolean {
         return true
     }
 }

package/src/form/fields/{literal.js → literal.ts}

@@ -5,12 +5,18 @@ import {InlineInput, icon} from "fwtoolkit"
 import {litSchema} from "../../schema/literal.js"
 
 export class LiteralFieldForm {
-    constructor(dom, initialValue = [], placeHolder = false) {
+    inlineInput: InlineInput
+
+    constructor(
+        dom: HTMLElement,
+        initialValue: Record<string, unknown>[] = [],
+        placeHolder: string | false = false
+    ) {
         this.inlineInput = new InlineInput(dom, {
             schema: litSchema,
             nodeType: "literal",
             initialValue,
-            placeholder: placeHolder,
+            placeholder: placeHolder || undefined,
             tools: [
                 {
                     command: toggleMark(litSchema.marks.strong),
@@ -36,13 +42,13 @@ export class LiteralFieldForm {
         })
     }
 
-    init() {}
+    init(): void {}
 
-    get value() {
+    get value(): Record<string, unknown>[] | false {
         return this.inlineInput.value
     }
 
-    check() {
+    check(): boolean {
         return this.inlineInput.check()
     }
 }

package/src/form/fields/{literal_list.js → literal_list.ts}

@@ -2,41 +2,50 @@ import {InputList} from "fwtoolkit"
 import {LiteralFieldForm} from "./literal.js"
 
 export class LiteralListForm {
-    constructor(dom, initialValue = [[]]) {
+    dom: HTMLElement
+    fieldHandlers: WeakMap<HTMLElement, LiteralFieldForm>
+    inputList: InputList<unknown>
+
+    constructor(
+        dom: HTMLElement,
+        initialValue: Record<string, unknown>[][] = [[]]
+    ) {
         this.dom = dom
         this.fieldHandlers = new WeakMap()
-        this.inputList = new InputList({
+        this.inputList = new InputList<unknown>({
             dom,
-            initialValues: initialValue,
+            initialValues: initialValue as unknown[],
             emptyValue: [],
             renderItem: value => ({
                 html: `<div class="literal-field"></div>`,
                 bind: el => {
                     const fieldHandler = new LiteralFieldForm(
-                        el.firstElementChild,
-                        value
+                        el.firstElementChild as HTMLElement,
+                        value as Record<string, unknown>[]
                     )
                     fieldHandler.init()
                     this.fieldHandlers.set(el, fieldHandler)
                 }
             }),
-            getValue: el => this.fieldHandlers.get(el).value
+            getValue: el => this.fieldHandlers.get(el)!.value
         })
     }
 
-    init() {
+    init(): void {
         // InputList is already rendered by the constructor.
     }
 
-    get value() {
-        const formValue = this.inputList.values.filter(value => value !== false)
+    get value(): Record<string, unknown>[][] | false {
+        const formValue = this.inputList.values.filter(
+            value => value !== false
+        ) as Record<string, unknown>[][]
         if (formValue.length === 0) {
             return false
         }
         return formValue
     }
 
-    check() {
+    check(): boolean {
         return true
     }
 }