@fiduswriter/bibliography-manager 0.1.7 → 0.1.9

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

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

@@ -1,14 +1,21 @@
 import {TypeSwitch, getFocusIndex, setFocusIndex} from "fwtoolkit"
 import {LiteralFieldForm} from "./literal.js"
+import type {NameDictObject, NodeArray} from "../../types/biblio.js"
 
 // There are only name lists, no name fields in the data format. The separation
 // between NameFieldForm and NameListForm is for keeping consistency with other fields
 // and lists.
 
 export class NameFieldForm {
+    currentValue: NameDictObject
+    dom: HTMLElement
+    realPerson: boolean
+    typeSwitch!: TypeSwitch
+    fields: Record<string, LiteralFieldForm> = {}
+
     constructor(
-        dom,
-        initialValue = {
+        dom: HTMLElement,
+        initialValue: NameDictObject = {
             given: [],
             family: [],
             prefix: [],
@@ -27,7 +34,7 @@ export class NameFieldForm {
         }
     }
 
-    init() {
+    init(): void {
         this.typeSwitch = new TypeSwitch({
             dom: this.dom,
             label1: gettext("Person"),
@@ -49,7 +56,7 @@ export class NameFieldForm {
         this.drawForm()
     }
 
-    drawForm() {
+    drawForm(): void {
         if (this.realPerson) {
             this.drawPersonForm()
         } else {
@@ -57,7 +64,7 @@ export class NameFieldForm {
         }
     }
 
-    drawPersonForm() {
+    drawPersonForm(): void {
         this.fields = {}
         this.typeSwitch.innerElement.innerHTML = `
                 <div class='given field-part field-part-long'></div>
@@ -71,82 +78,89 @@ export class NameFieldForm {
                 </div>
             `
         this.fields["given"] = new LiteralFieldForm(
-            this.typeSwitch.innerElement.querySelector(".given"),
-            this.currentValue.given,
+            this.typeSwitch.innerElement.querySelector(".given") as HTMLElement,
+            this.currentValue.given as unknown as unknown as Record<string, unknown>[],
             gettext("First name")
         )
         this.fields.given.init()
         this.fields["prefix"] = new LiteralFieldForm(
-            this.typeSwitch.innerElement.querySelector(".prefix"),
-            this.currentValue.prefix,
+            this.typeSwitch.innerElement.querySelector(
+                ".prefix"
+            ) as HTMLElement,
+            this.currentValue.prefix as unknown as Record<string, unknown>[],
             gettext("Prefix")
         )
         this.fields.prefix.init()
         this.fields["family"] = new LiteralFieldForm(
-            this.typeSwitch.innerElement.querySelector(".family"),
-            this.currentValue.family,
+            this.typeSwitch.innerElement.querySelector(
+                ".family"
+            ) as HTMLElement,
+            this.currentValue.family as unknown as Record<string, unknown>[],
             gettext("Last name")
         )
         this.fields.family.init()
         this.fields["suffix"] = new LiteralFieldForm(
-            this.typeSwitch.innerElement.querySelector(".suffix"),
-            this.currentValue.suffix,
+            this.typeSwitch.innerElement.querySelector(
+                ".suffix"
+            ) as HTMLElement,
+            this.currentValue.suffix as unknown as Record<string, unknown>[],
             gettext("Suffix")
         )
         this.fields.suffix.init()
     }
 
-    drawOrganizationForm() {
+    drawOrganizationForm(): void {
         this.fields = {}
         this.typeSwitch.innerElement.innerHTML = `<div class='literal-text field-part field-part-single'></div>`
         this.fields["literal"] = new LiteralFieldForm(
-            this.typeSwitch.innerElement.querySelector(".literal-text"),
-            this.currentValue.literal,
+            this.typeSwitch.innerElement.querySelector(
+                ".literal-text"
+            ) as HTMLElement,
+            this.currentValue.literal as unknown as Record<string, unknown>[],
             gettext("Organization name")
         )
         this.fields.literal.init()
     }
 
-    get value() {
+    get value(): NameDictObject | false {
         if (this.realPerson) {
-            if (
-                !this.fields.family.value &&
-                !this.fields.given.value &&
-                !this.fields.prefix.value &&
-                !this.fields.suffix.value
-            ) {
+            const familyValue = this.fields.family.value as NodeArray | false
+            const givenValue = this.fields.given.value as NodeArray | false
+            const prefixValue = this.fields.prefix.value as NodeArray | false
+            const suffixValue = this.fields.suffix.value as NodeArray | false
+            if (!familyValue && !givenValue && !prefixValue && !suffixValue) {
                 return false
             }
-            const returnObject = {
-                family: this.fields.family.value
-                    ? this.fields.family.value
-                    : [],
-                given: this.fields.given.value ? this.fields.given.value : []
+            const returnObject: NameDictObject = {
+                family: familyValue ? familyValue : [],
+                given: givenValue ? givenValue : []
             }
-            if (this.fields.prefix.value) {
-                returnObject["prefix"] = this.fields.prefix.value
-                returnObject["useprefix"] =
+            if (prefixValue) {
+                returnObject["prefix"] = prefixValue
+                returnObject["useprefix"] = (
                     this.typeSwitch.innerElement.querySelector(
                         "input.useprefix"
-                    ).checked
-                        ? true
-                        : false
+                    ) as HTMLInputElement
+                ).checked
+                    ? true
+                    : false
             }
-            if (this.fields.suffix.value) {
-                returnObject["suffix"] = this.fields.suffix.value
+            if (suffixValue) {
+                returnObject["suffix"] = suffixValue
             }
             return returnObject
         } else {
-            if (!this.fields.literal.value) {
+            const literalValue = this.fields.literal.value as NodeArray | false
+            if (!literalValue) {
                 return false
             }
             return {
-                literal: this.fields.literal.value
+                literal: literalValue
             }
         }
     }
 
-    check() {
+    check(): boolean {
         return true
     }
 }

package/src/form/fields/name_list.ts

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

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

@@ -1,12 +1,19 @@
 import {TypeSwitch, getFocusIndex, setFocusIndex} from "fwtoolkit"
 import {LiteralFieldForm} from "./literal.js"
+import type {NodeArray, RangeArray} from "../../types/biblio.js"
 
 // There are only range lists, no range fields in the data format. The separation
 // between RangeFieldForm and RangeListForm is for keeping consistency with other fields
 // and lists.
 
 export class RangeFieldForm {
-    constructor(dom, initialValue = [[]]) {
+    currentValue: NodeArray[]
+    dom: HTMLElement
+    range: boolean
+    typeSwitch!: TypeSwitch
+    fields: Record<string, LiteralFieldForm> = {}
+
+    constructor(dom: HTMLElement, initialValue: NodeArray[] = [[]]) {
         this.currentValue = initialValue
         this.dom = dom
         // We set the mode based on whether there is one or two initial values.
@@ -17,7 +24,7 @@ export class RangeFieldForm {
         }
     }
 
-    init() {
+    init(): void {
         this.typeSwitch = new TypeSwitch({
             dom: this.dom,
             label1: gettext("Single value"),
@@ -39,7 +46,7 @@ export class RangeFieldForm {
         this.drawForm()
     }
 
-    drawForm() {
+    drawForm(): void {
         if (this.range) {
             this.drawRangeForm()
         } else {
@@ -47,58 +54,63 @@ export class RangeFieldForm {
         }
     }
 
-    drawSingleValueForm() {
+    drawSingleValueForm(): void {
         this.fields = {}
         this.typeSwitch.innerElement.innerHTML = `<div class='single-value field-part field-part-single'></div>`
         this.fields["single"] = new LiteralFieldForm(
-            this.typeSwitch.innerElement.querySelector(".single-value"),
-            this.currentValue[0]
+            this.typeSwitch.innerElement.querySelector(
+                ".single-value"
+            ) as HTMLElement,
+            this.currentValue[0] as unknown as Record<string, unknown>[]
         )
         this.fields.single.init()
     }
 
-    drawRangeForm() {
+    drawRangeForm(): void {
         this.fields = {}
         this.typeSwitch.innerElement.innerHTML = `
                 <div class='range-from field-part field-part-huge'></div>
                 <div class='range-to field-part field-part-huge'></div>
             `
         this.fields["from"] = new LiteralFieldForm(
-            this.typeSwitch.innerElement.querySelector(".range-from"),
-            this.currentValue[0],
+            this.typeSwitch.innerElement.querySelector(
+                ".range-from"
+            ) as HTMLElement,
+            this.currentValue[0] as unknown as Record<string, unknown>[],
             gettext("From")
         )
         this.fields.from.init()
         this.fields["to"] = new LiteralFieldForm(
-            this.typeSwitch.innerElement.querySelector(".range-to"),
-            this.currentValue[1],
+            this.typeSwitch.innerElement.querySelector(
+                ".range-to"
+            ) as HTMLElement,
+            this.currentValue[1] as unknown as Record<string, unknown>[],
             gettext("To")
         )
         this.fields.to.init()
     }
 
-    get value() {
+    get value(): RangeArray | false {
         if (this.range) {
-            if (!this.fields.from.value && !this.fields.to.value) {
+            const fromValue = this.fields.from.value as NodeArray | false
+            const toValue = this.fields.to.value as NodeArray | false
+            if (!fromValue && !toValue) {
                 return false
             }
             return [
-                this.fields.from.value
-                    ? this.fields.from.value
-                    : [{type: "text", text: ""}],
-                this.fields.to.value
-                    ? this.fields.to.value
-                    : [{type: "text", text: ""}]
+                fromValue ? fromValue : ([{type: "text", text: ""}] as NodeArray),
+                toValue ? toValue : ([{type: "text", text: ""}] as NodeArray)
             ]
         } else {
-            if (!this.fields.single.value) {
+            const singleValue = this.fields.single.value as NodeArray | false
+            if (!singleValue) {
                 return false
             }
-            return [this.fields.single.value]
+            return [singleValue]
         }
     }
 
-    check() {
+    check(): boolean {
         return true
     }
 }

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

@@ -1,42 +1,49 @@
 import {InputList} from "fwtoolkit"
 import {RangeFieldForm} from "./range.js"
+import type {NodeArray, RangeArray} from "../../types/biblio.js"
 
 export class RangeListForm {
-    constructor(dom, initialValue = [[]]) {
+    dom: HTMLElement
+    fieldHandlers: WeakMap<HTMLElement, RangeFieldForm>
+    inputList: InputList<unknown>
+
+    constructor(dom: HTMLElement, initialValue: NodeArray[][] = [[]]) {
         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="range-field"></div>`,
                 bind: el => {
                     const fieldHandler = new RangeFieldForm(
-                        el.firstElementChild,
-                        value
+                        el.firstElementChild as HTMLElement,
+                        value as NodeArray[]
                     )
                     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(): RangeArray[] | false {
+        const formValue = this.inputList.values.filter(
+            value => value !== false
+        ) as RangeArray[]
         if (formValue.length === 0) {
             return false
         }
         return formValue
     }
 
-    check() {
+    check(): boolean {
         return true
     }
 }

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

@@ -1,15 +1,19 @@
 import TokenField from "tokenfield"
 
 export class TagListForm {
-    constructor(dom, initialValue = []) {
+    dom: HTMLElement
+    initialValue: string[]
+    tokenInput!: TokenField
+
+    constructor(dom: HTMLElement, initialValue: string[] = []) {
         this.dom = dom
         this.initialValue = initialValue
     }
 
-    init() {
+    init(): void {
         this.dom.innerHTML = '<input class="tags" type="text">'
         this.tokenInput = new TokenField({
-            el: this.dom.querySelector(".tags"),
+            el: this.dom.querySelector(".tags") as HTMLInputElement,
             setItems: this.initialValue.map((key, index) => {
                 return {id: index, name: key}
             }),
@@ -19,7 +23,7 @@ export class TagListForm {
         })
     }
 
-    get value() {
+    get value(): string[] | false {
         const formValue = this.tokenInput.getItems().map(item => {
             return item.name
         })
@@ -27,7 +31,7 @@ export class TagListForm {
         return formValue.length > 0 ? formValue : false
     }
 
-    check() {
+    check(): boolean {
         return true
     }
 }

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

@@ -5,7 +5,9 @@ import {InlineInput, icon} from "fwtoolkit"
 import {titleSchema} from "../../schema/title.js"
 
 export class TitleFieldForm {
-    constructor(dom, initialValue) {
+    inlineInput: InlineInput
+
+    constructor(dom: HTMLElement, initialValue: Record<string, unknown>[]) {
         this.inlineInput = new InlineInput(dom, {
             schema: titleSchema,
             nodeType: "literal",
@@ -39,13 +41,13 @@ export class TitleFieldForm {
         })
     }
 
-    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/{uri.js → uri.ts}

@@ -1,7 +1,7 @@
 // Simple regex to check for a basic URL structure
 const simpleUrlRegex = /^(https?:\/\/)?[\w.-]+\.[a-z]{2,}(\/\S*)?$/i
 
-function isValidUrl(string) {
+function isValidUrl(string: string): boolean {
     if (simpleUrlRegex.test(string)) {
         try {
             new URL(string)
@@ -14,23 +14,28 @@ function isValidUrl(string) {
 }
 
 export class URIFieldForm {
-    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="uri" type="text" value="${this.initialValue}" placeholder="${this.placeHolder}">`
     }
 
-    get value() {
-        const formValue = this.dom.querySelector("input.uri").value
+    get value(): string | false {
+        const formValue = (this.dom.querySelector("input.uri") 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) {
             if (!isValidUrl(formValue)) {

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

@@ -1,21 +1,26 @@
 export class VerbatimFieldForm {
-    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="verbatim" type="text" value="${this.initialValue}" placeholder="${this.placeHolder}">`
     }
 
-    get value() {
-        const formValue = this.dom.querySelector("input.verbatim").value
+    get value(): string | false {
+        const formValue = (this.dom.querySelector("input.verbatim") 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 {
         return true
     }
 }