@fiduswriter/editor 0.1.19 → 0.1.21

package/src/documents/access_rights/{templates.js → templates.ts}

@@ -1,6 +1,38 @@
 import {avatarTemplate, escapeText} from "fwtoolkit"
 
-export const peopleTabTemplate = ({contacts, collaborators}) =>
+interface Contact {
+    id: number | string
+    type: string
+    name: string
+}
+
+interface CollaboratorHolder {
+    id: number | string
+    type: string
+    name: string
+}
+
+interface Collaborator {
+    holder: CollaboratorHolder
+    rights: string
+    count?: number
+}
+
+interface ShareToken {
+    id: number | string
+    expires_at?: string
+    note?: string
+    rights: string
+    share_url: string
+}
+
+export const peopleTabTemplate = ({
+    contacts,
+    collaborators
+}: {
+    contacts: Contact[]
+    collaborators: Collaborator[]
+}) =>
     `<div id="my-contacts" class="fw-ar-container">
         <h3 class="fw-green-title">${gettext("My contacts")}</h3>
         <table class="fw-data-table">
@@ -36,7 +68,7 @@ export const shareLinkTabTemplate = () =>
     </button>`
 
 /** The list of active share-link tokens for a single document */
-export const shareTokenListTemplate = ({tokens}) => {
+export const shareTokenListTemplate = ({tokens}: {tokens: ShareToken[]}) => {
     if (!tokens.length) {
         return `<p class="fw-ar-no-tokens">${gettext("No active share links yet.")}</p>`
     }
@@ -44,7 +76,7 @@ export const shareTokenListTemplate = ({tokens}) => {
 }
 
 /** A single share-link token row */
-export const shareTokenRowTemplate = ({token}) => {
+export const shareTokenRowTemplate = ({token}: {token: ShareToken}) => {
     const expiry = token.expires_at
         ? escapeText(token.expires_at.slice(0, 10))
         : gettext("never")
@@ -125,7 +157,7 @@ export const createShareTokenDialogTemplate = (
     </table>`
 
 /** The template for an individual row in the left hand side list of users (all contacts) of the access rights dialogue. */
-export const contactsTemplate = ({contacts}) =>
+export const contactsTemplate = ({contacts}: {contacts: Contact[]}) =>
     contacts
         .map(
             contact =>
@@ -147,7 +179,11 @@ export const contactsTemplate = ({contacts}) =>
         .join("")
 
 /** The template for the right hand side list of users (the collaborators of the current document) of the access rights dialogue. */
-export const collaboratorsTemplate = ({collaborators}) =>
+export const collaboratorsTemplate = ({
+    collaborators
+}: {
+    collaborators: Collaborator[]
+}) =>
     collaborators
         .map(
             collaborator =>

package/src/e2ee/{snapshot-manager.js → snapshot-manager.ts}

@@ -14,11 +14,27 @@
  * The server stores the encrypted snapshot as opaque data and notifies
  * other clients via an "e2ee_snapshot_received" message.
  */
+import type {Editor} from "../types.js"
+
+interface SnapshotPayload {
+    content: string
+    comments: string
+    bibliography: string
+    title: string
+    e2ee_salt?: string
+    e2ee_iterations?: number
+    v?: number
+}
+
 export class E2EESnapshotManager {
+    editor: Editor
+    pendingSave: boolean
+    key: CryptoKey | null
+
     /**
-     * @param {Editor} editor - The Fidus Writer editor instance
+     * @param editor - The Fidus Writer editor instance
      */
-    constructor(editor) {
+    constructor(editor: Editor) {
         this.editor = editor
         this.pendingSave = false
         this.key = null
@@ -28,25 +44,25 @@ export class E2EESnapshotManager {
      * Set the encryption key for this document.
      * Called after the user enters the password and the key is derived.
      *
-     * @param {CryptoKey} key - An AES-GCM key (from E2EEKeyManager.deriveKey)
+     * @param key - An AES-GCM key (from E2EEKeyManager.deriveKey)
      */
-    setKey(key) {
+    setKey(key: CryptoKey): void {
         this.key = key
     }
 
     /**
      * Clear the encryption key (e.g., when the document is closed).
      */
-    clearKey() {
+    clearKey(): void {
         this.key = null
     }
 
     /**
      * Check whether the snapshot manager has a key set.
      *
-     * @returns {boolean}
+     * @returns boolean
      */
-    get hasKey() {
+    get hasKey(): boolean {
         return this.key !== null
     }
 
@@ -57,16 +73,16 @@ export class E2EESnapshotManager {
      * non-collaborative mode where snapshots are sent via REST instead
      * of WebSocket.
      *
-     * @returns {Object|null} The encrypted snapshot payload or null if no key.
+     * @returns The encrypted snapshot payload or null if no key.
      */
-    async getEncryptedSnapshot() {
+    async getEncryptedSnapshot(): Promise<SnapshotPayload | null> {
         if (!this.key) {
             return null
         }
-        const content = this.editor.view.docView.node.toJSON()
-        const comments = this.editor.docInfo.comments || {}
-        const bibliography = this.editor.docInfo.bibliography || {}
-        const {title} = this.editor.getDoc()
+        const content = ((this.editor.view as any).docView as any).node.toJSON()
+        const comments = (this.editor.docInfo as any).comments || {}
+        const bibliography = (this.editor.docInfo as any).bibliography || {}
+        const {title} = this.editor.getDoc() as {title: string} as {title: string}
 
         const {E2EEEncryptor} = await import("fwtoolkit/e2ee/encryptor")
 
@@ -89,8 +105,8 @@ export class E2EESnapshotManager {
             comments: encryptedComments,
             bibliography: encryptedBibliography,
             title: encryptedTitle,
-            e2ee_salt: this.editor.e2ee.encryptionSalt,
-            e2ee_iterations: this.editor.e2ee.encryptionIterations,
+            e2ee_salt: this.editor.e2ee?.encryptionSalt,
+            e2ee_iterations: this.editor.e2ee?.encryptionIterations,
             v: this.editor.docInfo.version
         }
     }
@@ -102,10 +118,10 @@ export class E2EESnapshotManager {
      * an encrypted snapshot (typically after DOC_SAVE_INTERVAL diffs).
      * Only write-capable clients should respond.
      *
-     * @param {Object} request - The request_snapshot message
-     * @param {number} request.v - The server's current document version
+     * @param request - The request_snapshot message
+     * @param request.v - The server's current document version
      */
-    async handleRequestSnapshot(_request) {
+    async handleRequestSnapshot(_request: {v?: number}): Promise<void> {
         if (this.pendingSave) {
             return
         }
@@ -121,12 +137,12 @@ export class E2EESnapshotManager {
         const docInfo = this.editor.docInfo
 
         // Get the current document content as JSON
-        const content = this.editor.view.docView.node.toJSON()
-        const comments = docInfo.comments || {}
-        const bibliography = docInfo.bibliography || {}
+        const content = ((this.editor.view as any).docView as any).node.toJSON()
+        const comments = (docInfo as any).comments || {}
+        const bibliography = (docInfo as any).bibliography || {}
 
         // Extract the current title from the editor
-        const {title} = this.editor.getDoc()
+        const {title} = this.editor.getDoc() as {title: string}
 
         // Dynamically import to avoid circular dependencies
         const {E2EEEncryptor} = await import("fwtoolkit/e2ee/encryptor")
@@ -147,13 +163,13 @@ export class E2EESnapshotManager {
         const encryptedTitle = await E2EEEncryptor.encrypt(title, this.key)
 
         // Send snapshot to server
-        this.editor.ws.send(() => ({
+        this.editor.ws!.send(() => ({
             type: "e2ee_snapshot",
             v: docInfo.version,
             content: encryptedContent,
             comments: encryptedComments,
             bibliography: encryptedBibliography,
-            e2ee_salt: this.editor.e2ee.encryptionSalt,
+            e2ee_salt: this.editor.e2ee?.encryptionSalt,
             title: encryptedTitle
         }))
         this.pendingSave = false
@@ -168,24 +184,30 @@ export class E2EESnapshotManager {
      * since they already have the latest state from the diffs they've
      * been receiving.
      *
-     * @param {Object} message - The e2ee_snapshot_received message
-     * @param {number} message.v - The version of the saved snapshot
+     * @param message - The e2ee_snapshot_received message
+     * @param message.v - The version of the saved snapshot
      */
-    async handleSnapshotReceived(message) {
+    async handleSnapshotReceived(message: {
+        v?: number
+        e2ee_salt?: string
+        e2ee_iterations?: number
+    }): Promise<void> {
         // Informational — no action needed for regular snapshots.
         // If the server included new KDF params, the password was changed
         // by another client. Update local state so that if we re-fetch
         // we use the new salt.
         if (message.e2ee_salt) {
-            this.editor.e2ee.encryptionSalt = message.e2ee_salt
-            this.editor.e2ee.encryptionIterations = message.e2ee_iterations
-            this.editor.e2ee.key = null
+            if (this.editor.e2ee) {
+                this.editor.e2ee.encryptionSalt = message.e2ee_salt
+                this.editor.e2ee.encryptionIterations = message.e2ee_iterations
+                this.editor.e2ee.key = undefined
+            }
             this.clearKey()
             // Clear cached password and key from sessionStorage so the user
             // is prompted for the new password on next access.
             const {E2EEKeyManager} = await import("fwtoolkit/e2ee/key-manager")
-            E2EEKeyManager.clearKeyFromSession(this.editor.docInfo.id)
-            E2EEKeyManager.clearPasswordFromSession(this.editor.docInfo.id)
+            E2EEKeyManager.clearKeyFromSession(this.editor.docInfo.id as number)
+            E2EEKeyManager.clearPasswordFromSession(this.editor.docInfo.id as number)
             // Notify the user that the password has changed.
             const {showSystemMessage} = await import("fwtoolkit")
             showSystemMessage(
@@ -203,12 +225,17 @@ export class E2EESnapshotManager {
      * the template) needs to be encrypted and saved as the first snapshot.
      * This method handles that initial save.
      *
-     * @param {Object} content - The document content (ProseMirror JSON)
-     * @param {Object} comments - The comments object (usually empty {})
-     * @param {Object} bibliography - The bibliography object (usually {})
-     * @param {number} version - The document version (usually 0)
+     * @param content - The document content (ProseMirror JSON)
+     * @param comments - The comments object (usually empty {})
+     * @param bibliography - The bibliography object (usually {})
+     * @param version - The document version (usually 0)
      */
-    async sendInitialSnapshot(content, comments, bibliography, version) {
+    async sendInitialSnapshot(
+        content: any,
+        comments: any,
+        bibliography: any,
+        version: number
+    ): Promise<void> {
         if (!this.key) {
             return
         }
@@ -229,16 +256,16 @@ export class E2EESnapshotManager {
         )
 
         // Extract the current title from the editor
-        const {title} = this.editor.getDoc()
+        const {title} = this.editor.getDoc() as {title: string}
         const encryptedTitle = await E2EEEncryptor.encrypt(title, this.key)
 
-        this.editor.ws.send(() => ({
+        this.editor.ws!.send(() => ({
             type: "e2ee_snapshot",
             v: version,
             content: encryptedContent,
             comments: encryptedComments,
             bibliography: encryptedBibliography,
-            e2ee_salt: this.editor.e2ee.encryptionSalt,
+            e2ee_salt: this.editor.e2ee?.encryptionSalt,
             title: encryptedTitle
         }))
     }
@@ -251,23 +278,27 @@ export class E2EESnapshotManager {
      * that by collecting the current document state, encrypting it with
      * the new key, and sending a snapshot.
      *
-     * @param {CryptoKey} newKey - The new AES-GCM key derived from the new password
-     * @param {string} newSaltBase64 - The new salt (Base64-encoded) to send to the server
-     * @param {number} newIterations - The new iteration count
+     * @param newKey - The new AES-GCM key derived from the new password
+     * @param newSaltBase64 - The new salt (Base64-encoded) to send to the server
+     * @param newIterations - The new iteration count
      */
-    async reEncryptWithNewKey(newKey, newSaltBase64, newIterations) {
+    async reEncryptWithNewKey(
+        newKey: CryptoKey,
+        newSaltBase64: string,
+        newIterations: number
+    ): Promise<void> {
         if (this.pendingSave) {
             return
         }
         this.pendingSave = true
 
         const docInfo = this.editor.docInfo
-        const content = this.editor.view.docView.node.toJSON()
-        const comments = docInfo.comments || {}
-        const bibliography = docInfo.bibliography || {}
+        const content = ((this.editor.view as any).docView as any).node.toJSON()
+        const comments = (docInfo as any).comments || {}
+        const bibliography = (docInfo as any).bibliography || {}
 
         // Extract the current title from the editor
-        const {title} = this.editor.getDoc()
+        const {title} = this.editor.getDoc() as {title: string}
 
         const {E2EEEncryptor} = await import("fwtoolkit/e2ee/encryptor")
 
@@ -290,7 +321,7 @@ export class E2EESnapshotManager {
         this.key = newKey
 
         // Send the re-encrypted snapshot along with the new KDF parameters
-        this.editor.ws.send(() => ({
+        this.editor.ws!.send(() => ({
             type: "e2ee_snapshot",
             v: docInfo.version,
             content: encryptedContent,

package/src/exporter/native/copy.ts

@@ -0,0 +1,302 @@
+import type {
+    BibDB,
+    ExportDoc,
+    ImageDB,
+    ImageDBEntry,
+    SaveCopyE2EE,
+    Template,
+    User
+} from "@fiduswriter/document"
+import {SaveCopy as GenericSaveCopy} from "@fiduswriter/document/exporter/native"
+import {NativeImporter} from "@fiduswriter/document/importer/native"
+import {addAlert, addProgress, gettext, postJson, shortFileTitle} from "fwtoolkit"
+import {E2EEEncryptor} from "fwtoolkit/e2ee/encryptor"
+import {E2EEKeyManager} from "fwtoolkit/e2ee/key-manager"
+
+type ProgressCallback = (message: string, percentage?: number | null) => void
+
+type ImportDocument = (
+    doc: Record<string, unknown>,
+    bibDB: BibDB,
+    imageDB: ImageDB,
+    httpIncludes: Array<{url: string; filename: string}>,
+    options: Record<string, unknown>
+) => Promise<{doc: Record<string, unknown>; docInfo: Record<string, unknown>}>
+
+interface ImageEntry extends ImageDBEntry {
+    file?: Blob
+    checksum?: string
+    original_file_type?: string
+    image: string
+}
+
+interface E2EEOptions {
+    enabled?: boolean
+    key?: CryptoKey
+    sourceKey?: CryptoKey
+    targetE2EE?: boolean
+    targetPassword?: string
+    salt?: string
+    iterations?: number
+}
+
+interface CreateDocumentResult {
+    id: number
+    path: string
+    e2ee?: boolean
+    template?: string
+}
+
+interface SaveDocumentResult {
+    added: number
+    updated: number
+}
+
+interface NativeImporterBackend {
+    createDoc: (
+        template: Template,
+        importId: string | number | null,
+        requestedPath: string,
+        e2eeOptions: E2EEOptions | null,
+        files: Record<string, File[]>
+    ) => Promise<CreateDocumentResult>
+    saveImages: (
+        images: ImageDB,
+        docId: number,
+        e2eeOptions: E2EEOptions | null
+    ) => Promise<Record<number | string, number>>
+    saveDocument: (
+        saveData: Record<string, unknown>,
+        e2eeOptions: E2EEOptions | null
+    ) => Promise<SaveDocumentResult>
+    encryptImage: (file: Blob, key: CryptoKey) => Promise<Blob>
+    encryptObject: (obj: unknown, key: CryptoKey) => Promise<unknown>
+    encrypt: (text: string, key: CryptoKey) => Promise<unknown>
+    storeKeyInSession: (docId: number, key: CryptoKey) => Promise<void>
+}
+
+interface ImportDocumentOptions extends Record<string, unknown> {
+    user: User
+    importId?: string | number | null
+    requestedPath?: string
+    e2eeOptions?: E2EEOptions | null
+}
+
+async function maybeDecryptImage(
+    imageEntry: ImageEntry,
+    sourceKey: CryptoKey | undefined
+): Promise<void> {
+    if (!sourceKey || !imageEntry.file) {
+        return
+    }
+    if (imageEntry.file_type !== "application/octet-stream") {
+        return
+    }
+    const fileBuffer = await imageEntry.file.arrayBuffer()
+    const bytes = new Uint8Array(fileBuffer)
+    let binary = ""
+    const chunkSize = 65536
+    for (let i = 0; i < bytes.length; i += chunkSize) {
+        const chunk = bytes.subarray(i, i + chunkSize)
+        binary += String.fromCharCode.apply(null, Array.from(chunk))
+    }
+    const base64 = btoa(binary)
+    const decrypted = await E2EEEncryptor.decryptBufferToBase64(base64, sourceKey)
+    const mime = imageEntry.original_file_type || "image/png"
+    const byteCharacters = atob(decrypted)
+    const byteNumbers = new Array<number>(byteCharacters.length)
+    for (let i = 0; i < byteCharacters.length; i++) {
+        byteNumbers[i] = byteCharacters.charCodeAt(i)
+    }
+    const byteArray = new Uint8Array(byteNumbers)
+    imageEntry.file = new Blob([byteArray], {type: mime})
+    imageEntry.file_type = mime
+}
+
+function createNativeImporterBackend(
+    _user: User,
+    _e2eeOptions: E2EEOptions | null
+): NativeImporterBackend {
+    return {
+        createDoc: (template, importId, path, e2ee, files) => {
+            const jsonData: Record<string, unknown> = {
+                template: template.content,
+                export_templates: template.exportTemplates,
+                document_styles: template.documentStyles,
+                import_id: importId
+                    ? importId
+                    : (template.content.attrs as Record<string, unknown> | undefined)
+                          ?.import_id,
+                template_title: (template.content.attrs as Record<string, unknown> | undefined)
+                    ?.template,
+                path
+            }
+            if (e2ee?.enabled) {
+                jsonData.e2ee = true
+                if (e2ee.salt) {
+                    jsonData.e2ee_salt = e2ee.salt
+                }
+                if (e2ee.iterations) {
+                    jsonData.e2ee_iterations = e2ee.iterations
+                }
+            }
+            return postJson("/api/document/import/create/", jsonData, files)
+                .then(({json}) => {
+                    const data = json as Record<string, unknown>
+                    return {
+                        id: data.id as number,
+                        path: data.path as string,
+                        e2ee: data.e2ee as boolean | undefined,
+                        template: data.template as string | undefined
+                    }
+                })
+                .catch(error => {
+                    addAlert("error", gettext("Could not create document"))
+                    throw error
+                })
+        },
+        saveImages: async (images, docId, e2ee) => {
+            const isE2EE = e2ee?.enabled
+            const endpoint = isE2EE
+                ? "/api/document/e2ee_image/"
+                : "/api/document/import/image/"
+            const imageTranslationTable: Record<number | string, number> = {}
+            await Promise.all(
+                Object.values(images.db).map(async imageEntry => {
+                    const entry = imageEntry as ImageEntry
+                    await maybeDecryptImage(entry, e2ee?.sourceKey)
+                    const encryptedFile =
+                        e2ee?.enabled && e2ee.key
+                            ? await E2EEEncryptor.encryptImage(
+                                  entry.file as Blob,
+                                  e2ee.key
+                              )
+                            : entry.file
+                    const jsonData: Record<string, unknown> = {
+                        doc_id: docId,
+                        title: entry.title,
+                        copyright: entry.copyright,
+                        checksum: entry.checksum
+                    }
+                    const files = {
+                        image: {
+                            file: encryptedFile as Blob,
+                            filename: entry.image.split("/").pop() as string
+                        }
+                    }
+                    const {json} = await postJson(endpoint, jsonData, files)
+                    const response = json as Record<string, unknown>
+                    imageTranslationTable[entry.id] = response.id as number
+                })
+            )
+            return imageTranslationTable
+        },
+        saveDocument: async (saveData, e2ee) => {
+            if (e2ee?.enabled && e2ee.key) {
+                saveData.content = await E2EEEncryptor.encryptObject(
+                    saveData.content as object,
+                    e2ee.key
+                )
+                saveData.comments = await E2EEEncryptor.encryptObject(
+                    saveData.comments || {},
+                    e2ee.key
+                )
+                saveData.bibliography = await E2EEEncryptor.encryptObject(
+                    saveData.bibliography as object,
+                    e2ee.key
+                )
+                saveData.title = await E2EEEncryptor.encrypt(
+                    saveData.title as string,
+                    e2ee.key
+                )
+            }
+            return postJson("/api/document/import/", saveData)
+                .then(({json}) => {
+                    const data = json as Record<string, unknown>
+                    return {
+                        added: data.added as number,
+                        updated: data.updated as number
+                    }
+                })
+                .catch(error => {
+                    addAlert(
+                        "error",
+                        `${gettext("Could not save ")} ${shortFileTitle(
+                            saveData.title as string,
+                            ""
+                        )}`
+                    )
+                    throw error
+                })
+        },
+        encryptImage: (file, key) => E2EEEncryptor.encryptImage(file, key),
+        encryptObject: (obj, key) => E2EEEncryptor.encryptObject(obj as object, key),
+        encrypt: (text, key) => E2EEEncryptor.encrypt(text, key),
+        storeKeyInSession: (docId, key) => E2EEKeyManager.storeKeyInSession(docId, key)
+    }
+}
+
+export class SaveCopy extends GenericSaveCopy {
+    constructor(
+        doc: Record<string, unknown> | ExportDoc,
+        bibDB: BibDB,
+        imageDB: ImageDB,
+        newUser: User,
+        importId: string | number | null = null,
+        e2eeOptions: E2EEOptions | null = null
+    ) {
+        const title = shortFileTitle(doc.title as string, (doc.path as string) || "")
+        const task = addProgress(
+            "info",
+            `${title}: ${gettext("Creating copy...")}`,
+            {autoClose: 6000}
+        )
+        const progressCallback: ProgressCallback = (message, percentage) =>
+            task.update(percentage as number | null, message)
+        const e2ee: SaveCopyE2EE = {
+            decryptObject: (encrypted, key) =>
+                E2EEEncryptor.decryptObject(encrypted as string, key),
+            encryptObject: (obj, key) =>
+                E2EEEncryptor.encryptObject(obj as object, key),
+            encrypt: (text, key) => E2EEEncryptor.encrypt(text, key),
+            encryptImage: (file, key) => E2EEEncryptor.encryptImage(file, key),
+            generateSalt: () => E2EEKeyManager.generateSalt(),
+            deriveKey: (password, salt, iterations) =>
+                E2EEKeyManager.deriveKey(password, salt, iterations)
+        }
+
+        const importDocument: ImportDocument = (
+            doc,
+            bibDB,
+            imageDB,
+            httpIncludes,
+            options
+        ) => {
+            const opts = options as ImportDocumentOptions
+            return new NativeImporter(
+                doc,
+                bibDB as unknown as Record<string, unknown>,
+                imageDB,
+                httpIncludes as unknown as Array<{
+                    filename: string
+                    content: Blob | ArrayBuffer | string
+                }>,
+                opts.user,
+                createNativeImporterBackend(opts.user, opts.e2eeOptions ?? null),
+                {
+                    importId: opts.importId,
+                    requestedPath: opts.requestedPath,
+                    e2eeOptions: opts.e2eeOptions ?? null
+                }
+            ).init()
+        }
+
+        super(doc as Record<string, unknown>, bibDB, imageDB, newUser, {
+            importId,
+            e2eeOptions,
+            e2ee,
+            importDocument,
+            progressCallback
+        })
+    }
+}

package/src/exporter/native/{file.js → file.ts}

@@ -1,23 +1,30 @@
+import type {BibDB, ExportDoc, ImageDB} from "@fiduswriter/document"
 import {ExportFidusFile as GenericExportFidusFile} from "@fiduswriter/document/exporter/native"
 import {addProgress, gettext, shortFileTitle} from "fwtoolkit"
 import {DocumentTemplateExporter} from "../../document_template/exporter.js"
 
 export class ExportFidusFile extends GenericExportFidusFile {
-    constructor(doc, bibDB, imageDB, includeTemplate = true, token = false) {
+    constructor(
+        doc: ExportDoc,
+        bibDB: BibDB,
+        imageDB: ImageDB,
+        includeTemplate = true,
+        token: string | boolean = false
+    ) {
         const title = shortFileTitle(doc.title, doc.path || "")
         const task = addProgress(
             "info",
             `${title}: ${gettext("Exporting Fidus file...")}`,
             {autoClose: 6000}
         )
-        const progressCallback = (message, percentage) =>
-            task.update(percentage, message)
-        const getTemplateFiles = (docId, token) => {
+        const progressCallback = (message: string, percentage?: number | null) =>
+            task.update(percentage ?? null, message)
+        const getTemplateFiles = (docId: number | string, token: string | boolean) => {
             const templateExporter = new DocumentTemplateExporter(
                 docId,
                 "/api/document/get_template_for_doc/",
                 false,
-                token
+                token as string | false
             )
             return templateExporter.init().then(() => ({
                 textFiles: templateExporter.textFiles,