obsidian-confluence 5.6.13 → 5.6.15

package/src/main.ts

@@ -1,12 +1,12 @@
 import { Plugin, Notice, MarkdownView, Workspace, loadMermaid } from "obsidian";
 import {
-	ConfluenceUploadSettings,
-	Publisher,
-	ConfluencePageConfig,
-	StaticSettingsLoader,
-	renderADFDoc,
-	MermaidRendererPlugin,
-	UploadAdfFileResult,
+  ConfluenceUploadSettings,
+  Publisher,
+  ConfluencePageConfig,
+  StaticSettingsLoader,
+  renderADFDoc,
+  MermaidRendererPlugin,
+  UploadAdfFileResult,
 } from "md-confluence-lib";
 import { ElectronMermaidRenderer } from "md-confluence-mermaid-electron-renderer";
 import { ConfluenceSettingTab } from "./ConfluenceSettingTab";
@@ -14,488 +14,456 @@ import ObsidianAdaptor from "./adaptors/obsidian";
 import { CompletedModal } from "./CompletedModal";
 import { ObsidianConfluenceClient } from "./MyBaseClient";
 import {
-	ConfluencePerPageForm,
-	ConfluencePerPageUIValues,
-	mapFrontmatterToConfluencePerPageUIValues,
+  ConfluencePerPageForm,
+  ConfluencePerPageUIValues,
+  mapFrontmatterToConfluencePerPageUIValues,
 } from "./ConfluencePerPageForm";
 import { Mermaid } from "mermaid";
 
 export interface ObsidianPluginSettings
-	extends ConfluenceUploadSettings.ConfluenceSettings {
-	mermaidTheme:
-		| "match-obsidian"
-		| "light-obsidian"
-		| "dark-obsidian"
-		| "default"
-		| "neutral"
-		| "dark"
-		| "forest";
+  extends ConfluenceUploadSettings.ConfluenceSettings {
+  mermaidTheme:
+    | "match-obsidian"
+    | "light-obsidian"
+    | "dark-obsidian"
+    | "default"
+    | "neutral"
+    | "dark"
+    | "forest";
 }
 
 interface FailedFile {
-	fileName: string;
-	reason: string;
+  fileName: string;
+  reason: string;
 }
 
 interface UploadResults {
-	errorMessage: string | null;
-	failedFiles: FailedFile[];
-	filesUploadResult: UploadAdfFileResult[];
+  errorMessage: string | null;
+  failedFiles: FailedFile[];
+  filesUploadResult: UploadAdfFileResult[];
 }
 
 export default class ConfluencePlugin extends Plugin {
-	settings!: ObsidianPluginSettings;
-	private isSyncing = false;
-	workspace!: Workspace;
-	publisher!: Publisher;
-	adaptor!: ObsidianAdaptor;
-
-	activeLeafPath(workspace: Workspace) {
-		return workspace.getActiveViewOfType(MarkdownView)?.file.path;
-	}
-
-	async init() {
-		await this.loadSettings();
-		const { vault, metadataCache, workspace } = this.app;
-		this.workspace = workspace;
-		this.adaptor = new ObsidianAdaptor(
-			vault,
-			metadataCache,
-			this.settings,
-			this.app,
-		);
-
-		const mermaidItems = await this.getMermaidItems();
-		const mermaidRenderer = new ElectronMermaidRenderer(
-			mermaidItems.extraStyleSheets,
-			mermaidItems.extraStyles,
-			mermaidItems.mermaidConfig,
-			mermaidItems.bodyStyles,
-		);
-		const confluenceClient = new ObsidianConfluenceClient({
-			host: this.settings.confluenceBaseUrl,
-			authentication: {
-				basic: {
-					email: this.settings.atlassianUserName,
-					apiToken: this.settings.atlassianApiToken,
-				},
-			},
-			middlewares: {
-				onError(e) {
-					if ("response" in e && "data" in e.response) {
-						e.message =
-							typeof e.response.data === "string"
-								? e.response.data
-								: JSON.stringify(e.response.data);
-					}
-				},
-			},
-		});
-
-		const settingsLoader = new StaticSettingsLoader(this.settings);
-		this.publisher = new Publisher(
-			this.adaptor,
-			settingsLoader,
-			confluenceClient,
-			[new MermaidRendererPlugin(mermaidRenderer)],
-		);
-	}
-
-	async getMermaidItems() {
-		const extraStyles: string[] = [];
-		const extraStyleSheets: string[] = [];
-		let bodyStyles = "";
-		const body = document.querySelector("body") as HTMLBodyElement;
-
-		switch (this.settings.mermaidTheme) {
-			case "default":
-			case "neutral":
-			case "dark":
-			case "forest":
-				return {
-					extraStyleSheets,
-					extraStyles,
-					mermaidConfig: { theme: this.settings.mermaidTheme },
-					bodyStyles,
-				};
-			case "match-obsidian":
-				bodyStyles = body.className;
-				break;
-			case "dark-obsidian":
-				bodyStyles = "theme-dark";
-				break;
-			case "light-obsidian":
-				bodyStyles = "theme-dark";
-				break;
-			default:
-				throw new Error("Missing theme");
-		}
-
-		extraStyleSheets.push("app://obsidian.md/app.css");
-
-		// @ts-expect-error
-		const cssTheme = this.app.vault?.getConfig("cssTheme") as string;
-		if (cssTheme) {
-			const fileExists = await this.app.vault.adapter.exists(
-				`.obsidian/themes/${cssTheme}/theme.css`,
-			);
-			if (fileExists) {
-				const themeCss = await this.app.vault.adapter.read(
-					`.obsidian/themes/${cssTheme}/theme.css`,
-				);
-				extraStyles.push(themeCss);
-			}
-		}
-
-		const cssSnippets =
-			// @ts-expect-error
-			(this.app.vault?.getConfig("enabledCssSnippets") as string[]) ?? [];
-		for (const snippet of cssSnippets) {
-			const fileExists = await this.app.vault.adapter.exists(
-				`.obsidian/snippets/${snippet}.css`,
-			);
-			if (fileExists) {
-				const themeCss = await this.app.vault.adapter.read(
-					`.obsidian/snippets/${snippet}.css`,
-				);
-				extraStyles.push(themeCss);
-			}
-		}
-
-		return {
-			extraStyleSheets,
-			extraStyles,
-			mermaidConfig: (
-				(await loadMermaid()) as Mermaid
-			).mermaidAPI.getConfig(),
-			bodyStyles,
-		};
-	}
-
-	async doPublish(publishFilter?: string): Promise<UploadResults> {
-		const adrFiles = await this.publisher.publish(publishFilter);
-
-		const returnVal: UploadResults = {
-			errorMessage: null,
-			failedFiles: [],
-			filesUploadResult: [],
-		};
-
-		adrFiles.forEach((element) => {
-			if (element.successfulUploadResult) {
-				returnVal.filesUploadResult.push(
-					element.successfulUploadResult,
-				);
-				return;
-			}
-
-			returnVal.failedFiles.push({
-				fileName: element.node.file.absoluteFilePath,
-				reason: element.reason ?? "No Reason Provided",
-			});
-		});
-
-		return returnVal;
-	}
-
-	override async onload() {
-		await this.init();
-
-		this.addRibbonIcon("cloud", "Publish to Confluence", async () => {
-			if (this.isSyncing) {
-				new Notice("Syncing already on going");
-				return;
-			}
-			this.isSyncing = true;
-			try {
-				const stats = await this.doPublish();
-				new CompletedModal(this.app, {
-					uploadResults: stats,
-				}).open();
-			} catch (error) {
-				if (error instanceof Error) {
-					new CompletedModal(this.app, {
-						uploadResults: {
-							errorMessage: error.message,
-							failedFiles: [],
-							filesUploadResult: [],
-						},
-					}).open();
-				} else {
-					new CompletedModal(this.app, {
-						uploadResults: {
-							errorMessage: JSON.stringify(error),
-							failedFiles: [],
-							filesUploadResult: [],
-						},
-					}).open();
-				}
-			} finally {
-				this.isSyncing = false;
-			}
-		});
-
-		this.addCommand({
-			id: "adf-to-markdown",
-			name: "ADF To Markdown",
-			callback: async () => {
-				console.log("HMMMM");
-				const json = JSON.parse(
-					'{"type":"doc","content":[{"type":"paragraph","content":[{"text":"Testing","type":"text"}]}],"version":1}',
-				);
-				console.log({ json });
-
-				const confluenceClient = new ObsidianConfluenceClient({
-					host: this.settings.confluenceBaseUrl,
-					authentication: {
-						basic: {
-							email: this.settings.atlassianUserName,
-							apiToken: this.settings.atlassianApiToken,
-						},
-					},
-				});
-				const testingPage =
-					await confluenceClient.content.getContentById({
-						id: "9732097",
-						expand: ["body.atlas_doc_format", "space"],
-					});
-				const adf = JSON.parse(
-					testingPage.body?.atlas_doc_format?.value ||
-						'{type: "doc", content:[]}',
-				);
-				renderADFDoc(adf);
-			},
-		});
-
-		this.addCommand({
-			id: "publish-current",
-			name: "Publish Current File to Confluence",
-			checkCallback: (checking: boolean) => {
-				if (!this.isSyncing) {
-					if (!checking) {
-						this.isSyncing = true;
-						this.doPublish(this.activeLeafPath(this.workspace))
-							.then((stats) => {
-								new CompletedModal(this.app, {
-									uploadResults: stats,
-								}).open();
-							})
-							.catch((error) => {
-								if (error instanceof Error) {
-									new CompletedModal(this.app, {
-										uploadResults: {
-											errorMessage: error.message,
-											failedFiles: [],
-											filesUploadResult: [],
-										},
-									}).open();
-								} else {
-									new CompletedModal(this.app, {
-										uploadResults: {
-											errorMessage: JSON.stringify(error),
-											failedFiles: [],
-											filesUploadResult: [],
-										},
-									}).open();
-								}
-							})
-							.finally(() => {
-								this.isSyncing = false;
-							});
-					}
-					return true;
-				}
-				return true;
-			},
-		});
-
-		this.addCommand({
-			id: "publish-all",
-			name: "Publish All to Confluence",
-			checkCallback: (checking: boolean) => {
-				if (!this.isSyncing) {
-					if (!checking) {
-						this.isSyncing = true;
-						this.doPublish()
-							.then((stats) => {
-								new CompletedModal(this.app, {
-									uploadResults: stats,
-								}).open();
-							})
-							.catch((error) => {
-								if (error instanceof Error) {
-									new CompletedModal(this.app, {
-										uploadResults: {
-											errorMessage: error.message,
-											failedFiles: [],
-											filesUploadResult: [],
-										},
-									}).open();
-								} else {
-									new CompletedModal(this.app, {
-										uploadResults: {
-											errorMessage: JSON.stringify(error),
-											failedFiles: [],
-											filesUploadResult: [],
-										},
-									}).open();
-								}
-							})
-							.finally(() => {
-								this.isSyncing = false;
-							});
-					}
-				}
-				return true;
-			},
-		});
-
-		this.addCommand({
-			id: "enable-publishing",
-			name: "Enable publishing to Confluence",
-			editorCheckCallback: (checking, _editor, view) => {
-				if (!view.file) {
-					return false;
-				}
-
-				if (checking) {
-					const frontMatter = this.app.metadataCache.getCache(
-						view.file.path,
-					)?.frontmatter;
-					const file = view.file;
-					const enabledForPublishing =
-						(file.path.startsWith(this.settings.folderToPublish) &&
-							(!frontMatter ||
-								frontMatter["connie-publish"] !== false)) ||
-						(frontMatter && frontMatter["connie-publish"] === true);
-					return !enabledForPublishing;
-				}
-
-				this.app.fileManager.processFrontMatter(
-					view.file,
-					(frontmatter) => {
-						if (
-							view.file &&
-							view.file.path.startsWith(
-								this.settings.folderToPublish,
-							)
-						) {
-							delete frontmatter["connie-publish"];
-						} else {
-							frontmatter["connie-publish"] = true;
-						}
-					},
-				);
-				return true;
-			},
-		});
-
-		this.addCommand({
-			id: "disable-publishing",
-			name: "Disable publishing to Confluence",
-			editorCheckCallback: (checking, _editor, view) => {
-				if (!view.file) {
-					return false;
-				}
-
-				if (checking) {
-					const frontMatter = this.app.metadataCache.getCache(
-						view.file.path,
-					)?.frontmatter;
-					const file = view.file;
-					const enabledForPublishing =
-						(file.path.startsWith(this.settings.folderToPublish) &&
-							(!frontMatter ||
-								frontMatter["connie-publish"] !== false)) ||
-						(frontMatter && frontMatter["connie-publish"] === true);
-					return enabledForPublishing;
-				}
-
-				this.app.fileManager.processFrontMatter(
-					view.file,
-					(frontmatter) => {
-						if (
-							view.file &&
-							view.file.path.startsWith(
-								this.settings.folderToPublish,
-							)
-						) {
-							frontmatter["connie-publish"] = false;
-						} else {
-							delete frontmatter["connie-publish"];
-						}
-					},
-				);
-				return true;
-			},
-		});
-
-		this.addCommand({
-			id: "page-settings",
-			name: "Update Confluence Page Settings",
-			editorCallback: (_editor, view) => {
-				if (!view.file) {
-					return false;
-				}
-
-				const frontMatter = this.app.metadataCache.getCache(
-					view.file.path,
-				)?.frontmatter;
-
-				const file = view.file;
-
-				new ConfluencePerPageForm(this.app, {
-					config: ConfluencePageConfig.conniePerPageConfig,
-					initialValues:
-						mapFrontmatterToConfluencePerPageUIValues(frontMatter),
-					onSubmit: (values, close) => {
-						const valuesToSet: Partial<ConfluencePageConfig.ConfluencePerPageAllValues> =
-							{};
-						for (const propertyKey in values) {
-							if (
-								Object.prototype.hasOwnProperty.call(
-									values,
-									propertyKey,
-								)
-							) {
-								const element =
-									values[
-										propertyKey as keyof ConfluencePerPageUIValues
-									];
-								if (element.isSet) {
-									valuesToSet[
-										propertyKey as keyof ConfluencePerPageUIValues
-									] = element.value as never;
-								}
-							}
-						}
-						this.adaptor.updateMarkdownValues(
-							file.path,
-							valuesToSet,
-						);
-						close();
-					},
-				}).open();
-				return true;
-			},
-		});
-
-		this.addSettingTab(new ConfluenceSettingTab(this.app, this));
-	}
-
-	override async onunload() {}
-
-	async loadSettings() {
-		this.settings = Object.assign(
-			{},
-			ConfluenceUploadSettings.DEFAULT_SETTINGS,
-			{ mermaidTheme: "match-obsidian" },
-			await this.loadData(),
-		);
-	}
-
-	async saveSettings() {
-		await this.saveData(this.settings);
-		await this.init();
-	}
+  settings!: ObsidianPluginSettings;
+  private isSyncing = false;
+  workspace!: Workspace;
+  publisher!: Publisher;
+  adaptor!: ObsidianAdaptor;
+
+  activeLeafPath(workspace: Workspace) {
+    return workspace.getActiveViewOfType(MarkdownView)?.file.path;
+  }
+
+  async init() {
+    await this.loadSettings();
+    const { vault, metadataCache, workspace } = this.app;
+    this.workspace = workspace;
+    this.adaptor = new ObsidianAdaptor(
+      vault,
+      metadataCache,
+      this.settings,
+      this.app,
+    );
+
+    const mermaidItems = await this.getMermaidItems();
+    const mermaidRenderer = new ElectronMermaidRenderer(
+      mermaidItems.extraStyleSheets,
+      mermaidItems.extraStyles,
+      mermaidItems.mermaidConfig,
+      mermaidItems.bodyStyles,
+    );
+    const confluenceClient = new ObsidianConfluenceClient({
+      host: this.settings.confluenceBaseUrl,
+      authentication: {
+        basic: {
+          email: this.settings.atlassianUserName,
+          apiToken: this.settings.atlassianApiToken,
+        },
+      },
+      middlewares: {
+        onError(e) {
+          if ("response" in e && "data" in e.response) {
+            e.message =
+              typeof e.response.data === "string"
+                ? e.response.data
+                : JSON.stringify(e.response.data);
+          }
+        },
+      },
+    });
+
+    const settingsLoader = new StaticSettingsLoader(this.settings);
+    this.publisher = new Publisher(
+      this.adaptor,
+      settingsLoader,
+      confluenceClient,
+      [new MermaidRendererPlugin(mermaidRenderer)],
+    );
+  }
+
+  async getMermaidItems() {
+    const extraStyles: string[] = [];
+    const extraStyleSheets: string[] = [];
+    let bodyStyles = "";
+    const body = document.querySelector("body") as HTMLBodyElement;
+
+    switch (this.settings.mermaidTheme) {
+      case "default":
+      case "neutral":
+      case "dark":
+      case "forest":
+        return {
+          extraStyleSheets,
+          extraStyles,
+          mermaidConfig: { theme: this.settings.mermaidTheme },
+          bodyStyles,
+        };
+      case "match-obsidian":
+        bodyStyles = body.className;
+        break;
+      case "dark-obsidian":
+        bodyStyles = "theme-dark";
+        break;
+      case "light-obsidian":
+        bodyStyles = "theme-dark";
+        break;
+      default:
+        throw new Error("Missing theme");
+    }
+
+    extraStyleSheets.push("app://obsidian.md/app.css");
+
+    // @ts-expect-error
+    const cssTheme = this.app.vault?.getConfig("cssTheme") as string;
+    if (cssTheme) {
+      const fileExists = await this.app.vault.adapter.exists(
+        `.obsidian/themes/${cssTheme}/theme.css`,
+      );
+      if (fileExists) {
+        const themeCss = await this.app.vault.adapter.read(
+          `.obsidian/themes/${cssTheme}/theme.css`,
+        );
+        extraStyles.push(themeCss);
+      }
+    }
+
+    const cssSnippets =
+      // @ts-expect-error
+      (this.app.vault?.getConfig("enabledCssSnippets") as string[]) ?? [];
+    for (const snippet of cssSnippets) {
+      const fileExists = await this.app.vault.adapter.exists(
+        `.obsidian/snippets/${snippet}.css`,
+      );
+      if (fileExists) {
+        const themeCss = await this.app.vault.adapter.read(
+          `.obsidian/snippets/${snippet}.css`,
+        );
+        extraStyles.push(themeCss);
+      }
+    }
+
+    return {
+      extraStyleSheets,
+      extraStyles,
+      mermaidConfig: ((await loadMermaid()) as Mermaid).mermaidAPI.getConfig(),
+      bodyStyles,
+    };
+  }
+
+  async doPublish(publishFilter?: string): Promise<UploadResults> {
+    const adrFiles = await this.publisher.publish(publishFilter);
+
+    const returnVal: UploadResults = {
+      errorMessage: null,
+      failedFiles: [],
+      filesUploadResult: [],
+    };
+
+    adrFiles.forEach((element) => {
+      if (element.successfulUploadResult) {
+        returnVal.filesUploadResult.push(element.successfulUploadResult);
+        return;
+      }
+
+      returnVal.failedFiles.push({
+        fileName: element.node.file.absoluteFilePath,
+        reason: element.reason ?? "No Reason Provided",
+      });
+    });
+
+    return returnVal;
+  }
+
+  override async onload() {
+    await this.init();
+
+    this.addRibbonIcon("cloud", "Publish to Confluence", async () => {
+      if (this.isSyncing) {
+        new Notice("Syncing already on going");
+        return;
+      }
+      this.isSyncing = true;
+      try {
+        const stats = await this.doPublish();
+        new CompletedModal(this.app, {
+          uploadResults: stats,
+        }).open();
+      } catch (error) {
+        if (error instanceof Error) {
+          new CompletedModal(this.app, {
+            uploadResults: {
+              errorMessage: error.message,
+              failedFiles: [],
+              filesUploadResult: [],
+            },
+          }).open();
+        } else {
+          new CompletedModal(this.app, {
+            uploadResults: {
+              errorMessage: JSON.stringify(error),
+              failedFiles: [],
+              filesUploadResult: [],
+            },
+          }).open();
+        }
+      } finally {
+        this.isSyncing = false;
+      }
+    });
+
+    this.addCommand({
+      id: "adf-to-markdown",
+      name: "ADF To Markdown",
+      callback: async () => {
+        console.log("HMMMM");
+        const json = JSON.parse(
+          '{"type":"doc","content":[{"type":"paragraph","content":[{"text":"Testing","type":"text"}]}],"version":1}',
+        );
+        console.log({ json });
+
+        const confluenceClient = new ObsidianConfluenceClient({
+          host: this.settings.confluenceBaseUrl,
+          authentication: {
+            basic: {
+              email: this.settings.atlassianUserName,
+              apiToken: this.settings.atlassianApiToken,
+            },
+          },
+        });
+        const testingPage = await confluenceClient.content.getContentById({
+          id: "9732097",
+          expand: ["body.atlas_doc_format", "space"],
+        });
+        const adf = JSON.parse(
+          testingPage.body?.atlas_doc_format?.value ||
+            '{type: "doc", content:[]}',
+        );
+        renderADFDoc(adf);
+      },
+    });
+
+    this.addCommand({
+      id: "publish-current",
+      name: "Publish Current File to Confluence",
+      checkCallback: (checking: boolean) => {
+        if (!this.isSyncing) {
+          if (!checking) {
+            this.isSyncing = true;
+            this.doPublish(this.activeLeafPath(this.workspace))
+              .then((stats) => {
+                new CompletedModal(this.app, {
+                  uploadResults: stats,
+                }).open();
+              })
+              .catch((error) => {
+                if (error instanceof Error) {
+                  new CompletedModal(this.app, {
+                    uploadResults: {
+                      errorMessage: error.message,
+                      failedFiles: [],
+                      filesUploadResult: [],
+                    },
+                  }).open();
+                } else {
+                  new CompletedModal(this.app, {
+                    uploadResults: {
+                      errorMessage: JSON.stringify(error),
+                      failedFiles: [],
+                      filesUploadResult: [],
+                    },
+                  }).open();
+                }
+              })
+              .finally(() => {
+                this.isSyncing = false;
+              });
+          }
+          return true;
+        }
+        return true;
+      },
+    });
+
+    this.addCommand({
+      id: "publish-all",
+      name: "Publish All to Confluence",
+      checkCallback: (checking: boolean) => {
+        if (!this.isSyncing) {
+          if (!checking) {
+            this.isSyncing = true;
+            this.doPublish()
+              .then((stats) => {
+                new CompletedModal(this.app, {
+                  uploadResults: stats,
+                }).open();
+              })
+              .catch((error) => {
+                if (error instanceof Error) {
+                  new CompletedModal(this.app, {
+                    uploadResults: {
+                      errorMessage: error.message,
+                      failedFiles: [],
+                      filesUploadResult: [],
+                    },
+                  }).open();
+                } else {
+                  new CompletedModal(this.app, {
+                    uploadResults: {
+                      errorMessage: JSON.stringify(error),
+                      failedFiles: [],
+                      filesUploadResult: [],
+                    },
+                  }).open();
+                }
+              })
+              .finally(() => {
+                this.isSyncing = false;
+              });
+          }
+        }
+        return true;
+      },
+    });
+
+    this.addCommand({
+      id: "enable-publishing",
+      name: "Enable publishing to Confluence",
+      editorCheckCallback: (checking, _editor, view) => {
+        if (!view.file) {
+          return false;
+        }
+
+        if (checking) {
+          const frontMatter = this.app.metadataCache.getCache(view.file.path)
+            ?.frontmatter;
+          const file = view.file;
+          const enabledForPublishing =
+            (file.path.startsWith(this.settings.folderToPublish) &&
+              (!frontMatter || frontMatter["connie-publish"] !== false)) ||
+            (frontMatter && frontMatter["connie-publish"] === true);
+          return !enabledForPublishing;
+        }
+
+        this.app.fileManager.processFrontMatter(view.file, (frontmatter) => {
+          if (
+            view.file &&
+            view.file.path.startsWith(this.settings.folderToPublish)
+          ) {
+            delete frontmatter["connie-publish"];
+          } else {
+            frontmatter["connie-publish"] = true;
+          }
+        });
+        return true;
+      },
+    });
+
+    this.addCommand({
+      id: "disable-publishing",
+      name: "Disable publishing to Confluence",
+      editorCheckCallback: (checking, _editor, view) => {
+        if (!view.file) {
+          return false;
+        }
+
+        if (checking) {
+          const frontMatter = this.app.metadataCache.getCache(view.file.path)
+            ?.frontmatter;
+          const file = view.file;
+          const enabledForPublishing =
+            (file.path.startsWith(this.settings.folderToPublish) &&
+              (!frontMatter || frontMatter["connie-publish"] !== false)) ||
+            (frontMatter && frontMatter["connie-publish"] === true);
+          return enabledForPublishing;
+        }
+
+        this.app.fileManager.processFrontMatter(view.file, (frontmatter) => {
+          if (
+            view.file &&
+            view.file.path.startsWith(this.settings.folderToPublish)
+          ) {
+            frontmatter["connie-publish"] = false;
+          } else {
+            delete frontmatter["connie-publish"];
+          }
+        });
+        return true;
+      },
+    });
+
+    this.addCommand({
+      id: "page-settings",
+      name: "Update Confluence Page Settings",
+      editorCallback: (_editor, view) => {
+        if (!view.file) {
+          return false;
+        }
+
+        const frontMatter = this.app.metadataCache.getCache(view.file.path)
+          ?.frontmatter;
+
+        const file = view.file;
+
+        new ConfluencePerPageForm(this.app, {
+          config: ConfluencePageConfig.conniePerPageConfig,
+          initialValues: mapFrontmatterToConfluencePerPageUIValues(frontMatter),
+          onSubmit: (values, close) => {
+            const valuesToSet: Partial<ConfluencePageConfig.ConfluencePerPageAllValues> =
+              {};
+            for (const propertyKey in values) {
+              if (Object.prototype.hasOwnProperty.call(values, propertyKey)) {
+                const element =
+                  values[propertyKey as keyof ConfluencePerPageUIValues];
+                if (element.isSet) {
+                  valuesToSet[propertyKey as keyof ConfluencePerPageUIValues] =
+                    element.value as never;
+                }
+              }
+            }
+            this.adaptor.updateMarkdownValues(file.path, valuesToSet);
+            close();
+          },
+        }).open();
+        return true;
+      },
+    });
+
+    this.addSettingTab(new ConfluenceSettingTab(this.app, this));
+  }
+
+  override async onunload() {}
+
+  async loadSettings() {
+    this.settings = Object.assign(
+      {},
+      ConfluenceUploadSettings.DEFAULT_SETTINGS,
+      { mermaidTheme: "match-obsidian" },
+      await this.loadData(),
+    );
+  }
+
+  async saveSettings() {
+    await this.saveData(this.settings);
+    await this.init();
+  }
 }