@fiduswriter/bibliography-manager 0.1.6 → 0.1.8

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
     }
 }

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

@@ -5,7 +5,9 @@ import {InlineInput, icon} from "fwtoolkit"
 import {longLitSchema} from "../../schema/literal_long.js"
 
 export class LiteralLongFieldForm {
-    constructor(dom, initialValue = []) {
+    inlineInput: InlineInput
+
+    constructor(dom: HTMLElement, initialValue: Record<string, unknown>[] = []) {
         this.inlineInput = new InlineInput(dom, {
             schema: longLitSchema,
             nodeType: "longliteral",
@@ -35,13 +37,13 @@ export class LiteralLongFieldForm {
         })
     }
 
-    init() {}
+    init(): void {}
 
-    get value() {
+    get value(): Record<string, unknown>[] | false {
         return this.inlineInput.value
     }
 
-    check() {
+    check(): boolean {
         return this.inlineInput.check()
     }
 }