obsidian-confluence 5.6.0

package/src/main.ts

@@ -0,0 +1,501 @@
+import { Plugin, Notice, MarkdownView, Workspace, loadMermaid } from "obsidian";
+import {
+	ConfluenceUploadSettings,
+	Publisher,
+	ConfluencePageConfig,
+	StaticSettingsLoader,
+	renderADFDoc,
+	MermaidRendererPlugin,
+	UploadAdfFileResult,
+} from "md-confluence-lib";
+import { ElectronMermaidRenderer } from "md-confluence-mermaid-electron-renderer";
+import { ConfluenceSettingTab } from "./ConfluenceSettingTab";
+import ObsidianAdaptor from "./adaptors/obsidian";
+import { CompletedModal } from "./CompletedModal";
+import { ObsidianConfluenceClient } from "./MyBaseClient";
+import {
+	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";
+}
+
+interface FailedFile {
+	fileName: string;
+	reason: string;
+}
+
+interface UploadResults {
+	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();
+	}
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions":{
+     "baseUrl":".",
+     "rootDir": "src",
+         "outDir": "dist",
+         "declarationDir": "dist",
+         "noEmit": true,
+         "skipLibCheck": true,
+  },
+  "include":[ "**/*.ts", "**/*.tsx"  ],
+    "exclude": ["node_modules", "packages/**/dist/*", "dist/*", "**/*.test.ts", "**/jest.config.ts"]
+}