notes-to-strapi-export-article-ai 1.0.119 → 3.0.0

package/src/utils/image-processor.ts

@@ -1,442 +1,166 @@
-import { App, MarkdownView, Notice, TFile, TFolder } from 'obsidian'
-import { OpenAI } from 'openai'
-import { StrapiExporterSettings } from '../types/settings'
+import { App, TFile } from 'obsidian'
 import {
-	uploadGalleryImagesToStrapi,
-	uploadImagesToStrapi,
-} from './strapi-uploader'
-import { generateArticleContent, getImageDescription } from './openai-generator'
-import { ImageBlob } from '../types/image'
+	ImageDescription,
+	ImageProcessingResult,
+	StrapiExporterSettings,
+} from '../types'
+import { uploadImageToStrapi } from './strapi-uploader'
 
 /**
- * Process the markdown content
- * @param app
- * @param settings
- * @param useAdditionalCallAPI
+ * Process images in markdown content and handle uploads to Strapi
  */
-export async function processMarkdownContent(
+export async function processImages(
 	app: App,
 	settings: StrapiExporterSettings,
-	useAdditionalCallAPI = false
-) {
-	const activeView = app.workspace.getActiveViewOfType(MarkdownView)
-	if (!activeView) {
-		new Notice('No active Markdown view')
-		return
-	}
+	content: string
+): Promise<ImageProcessingResult> {
+	try {
+		const imageRefs = extractImageReferences(content)
 
-	/** ****************************************************************************
-	 * Check if all the settings are configured
-	 * *****************************************************************************
-	 */
-	if (!settings.strapiUrl || !settings.strapiApiToken) {
-		new Notice(
-			'Please configure Strapi URL and API token in the plugin settings'
+		const processedImages = await processImageReferences(
+			app,
+			settings,
+			imageRefs
 		)
-		return
-	}
-
-	if (!settings.openaiApiKey) {
-		new Notice('Please configure OpenAI API key in the plugin settings')
-		return
-	}
-
-	if (useAdditionalCallAPI) {
-		if (!settings.additionalJsonTemplate) {
-			new Notice(
-				'Please configure the additional call api JSON template in the plugin settings'
-			)
-			return
-		}
-
-		if (!settings.additionalJsonTemplateDescription) {
-			new Notice(
-				'Please configure the additional call api JSON template description in the plugin settings'
-			)
-			return
+		const updatedContent = updateImageReferences(content, processedImages)
+		return {
+			content: updatedContent,
+			processedImages,
 		}
+	} catch (error) {
+		throw new Error(`Image processing failed: ${error.message}`)
+	}
+}
 
-		if (!settings.additionalUrl) {
-			new Notice(
-				'Please configure the additional call api URL in the plugin settings'
-			)
-			return
-		}
+interface ImageReference {
+	fullMatch: string
+	path: string
+	altText: string
+	type: 'wikilink' | 'markdown'
+}
 
-		if (!settings.additionalContentAttributeName) {
-			new Notice(
-				'Please configure the additional call api content attribute name in the plugin settings'
-			)
-			return
-		}
-	} else {
-		if (!settings.jsonTemplate) {
-			new Notice('Please configure JSON template in the plugin settings')
-			return
-		}
+/**
+ * Extract image references from content
+ */
+function extractImageReferences(content: string): ImageReference[] {
+	const references: ImageReference[] = []
 
-		if (!settings.jsonTemplateDescription) {
-			new Notice(
-				'Please configure JSON template description in the plugin settings'
-			)
-			return
+	try {
+		// Wiki-style image links (![[image.png]])
+		const wikiLinkRegex = /!\[\[([^\]]+\.(png|jpe?g|gif|svg|bmp|webp))\]\]/gi
+		let match
+
+		while ((match = wikiLinkRegex.exec(content)) !== null) {
+			references.push({
+				fullMatch: match[0],
+				path: match[1],
+				altText: '',
+				type: 'wikilink',
+			})
 		}
 
-		if (!settings.strapiArticleCreateUrl) {
-			new Notice(
-				'Please configure Strapi article create URL in the plugin settings'
-			)
-			return
+		// Markdown-style image links (![alt](path.png))
+		const markdownLinkRegex =
+			/!\[([^\]]*)\]\(([^)]+\.(png|jpe?g|gif|svg|bmp|webp))\)/gi
+		while ((match = markdownLinkRegex.exec(content)) !== null) {
+			references.push({
+				fullMatch: match[0],
+				path: match[2],
+				altText: match[1],
+				type: 'markdown',
+			})
 		}
 
-		if (!settings.strapiContentAttributeName) {
-			new Notice(
-				'Please configure Strapi content attribute name in the plugin settings'
-			)
-			return
-		}
-	}
-
-	new Notice('All settings are ok, processing Markdown content...')
-
-	// Initialize OpenAI API
-	const openai = new OpenAI({
-		apiKey: settings.openaiApiKey,
-		dangerouslyAllowBrowser: true,
-	})
-
-	/** ****************************************************************************
-	 * Process the markdown content
-	 * *****************************************************************************
-	 */
-	const file = activeView.file
-	let content = ''
-	if (!file) {
-		new Notice('No file found in active view...')
-		return
+		return references
+	} catch (error) {
+		throw new Error(`Failed to extract image references: ${error.message}`)
 	}
+}
 
-	/** ****************************************************************************
-	 * Check if the content has any images to process
-	 * *****************************************************************************
-	 */
-	let imageBlob: ImageBlob | null = null
-	let galleryUploadedImageIds: number[] = []
-	const articleFolderPath = file.parent?.path
-	const imageFolderPath = `${articleFolderPath}/image`
-	const galleryFolderPath = `${articleFolderPath}/gallery`
-	const imageMetadataFile = `${articleFolderPath}/image/metadata.json`
-	const galleryMetadataFile = `${articleFolderPath}/gallery/metadata.json`
-
-	// Check if metadata files exist
-	if (await app.vault.adapter.exists(imageMetadataFile)) {
-		const imageMetadata = JSON.parse(
-			await app.vault.adapter.read(imageMetadataFile)
-		)
-		if (Object.keys(imageMetadata).length > 0) {
-			imageBlob = {
-				path: imageMetadata[Object.keys(imageMetadata)[0]].data.url,
-				blob: new Blob(),
-				name: Object.keys(imageMetadata)[0],
-				id: imageMetadata[Object.keys(imageMetadata)[0]].id,
+/**
+ * Process image references and upload to Strapi
+ */
+async function processImageReferences(
+	app: App,
+	settings: StrapiExporterSettings,
+	references: ImageReference[]
+): Promise<ImageDescription[]> {
+	const processedImages: ImageDescription[] = []
+
+	for (const ref of references) {
+		try {
+			if (isExternalUrl(ref.path)) {
+				processedImages.push({
+					url: ref.path,
+					name: ref.path,
+					path: ref.path,
+					description: {
+						name: ref.path,
+						alternativeText: ref.altText,
+						caption: ref.altText,
+					},
+				})
+				continue
 			}
-		}
-	}
 
-	if (await app.vault.adapter.exists(galleryMetadataFile)) {
-		const galleryMetadata = JSON.parse(
-			await app.vault.adapter.read(galleryMetadataFile)
-		)
-		if (Object.keys(galleryMetadata).length > 0) {
-			galleryUploadedImageIds = Object.values(galleryMetadata).map(
-				(item: any) => item.data.id
-			)
-		}
-	}
+			const file = app.vault.getAbstractFileByPath(ref.path)
+			if (!(file instanceof TFile)) {
+				continue
+			}
 
-	// If metadata doesn't exist, get image blobs and upload to Strapi
-	if (!imageBlob) {
-		imageBlob = await getImageBlob(app, imageFolderPath)
-		if (imageBlob) {
-			const imageDescription = await getImageDescription(imageBlob.blob, openai)
-			const uploadedImage: any = await uploadImagesToStrapi(
-				[{ ...imageBlob, description: imageDescription }],
+			const uploadResult = await uploadImageToStrapi(
+				file,
+				file.name,
 				settings,
 				app,
-				imageFolderPath
-			)
-			imageBlob.path = uploadedImage[imageBlob.name].url
-			imageBlob.id = uploadedImage[imageBlob.name].id
-		}
-	}
-
-	if (galleryUploadedImageIds.length === 0) {
-		const galleryImageBlobs = await getGalleryImageBlobs(app, galleryFolderPath)
-		galleryUploadedImageIds = await uploadGalleryImagesToStrapi(
-			galleryImageBlobs,
-			settings,
-			app,
-			galleryFolderPath
-		)
-	}
-
-	content = await app.vault.read(file)
-
-	const flag = hasUnexportedImages(content)
-
-	/** ****************************************************************************
-	 * Process the images
-	 * *****************************************************************************
-	 */
-	if (flag) {
-		const imagePaths = extractImagePaths(content)
-		const imageBlobs = await getImageBlobs(app, imagePaths)
-
-		new Notice('Getting image descriptions...')
-		const imageDescriptions = await Promise.all(
-			imageBlobs.map(async imageBlob => {
-				const description = await getImageDescription(imageBlob.blob, openai)
-				return {
-					blob: imageBlob.blob,
-					name: imageBlob.name,
-					path: imageBlob.path,
-					description,
+				{
+					alternativeText: ref.altText || file.basename,
+					caption: ref.altText || file.basename,
 				}
-			})
-		)
-
-		new Notice('Uploading images to Strapi...')
-		const uploadedImages = await uploadImagesToStrapi(
-			imageDescriptions,
-			settings
-		)
-
-		new Notice('Replacing image paths...')
-		content = replaceImagePaths(content, uploadedImages)
-		await app.vault.modify(file, content)
-		new Notice('Images uploaded and links updated successfully!')
-	} else {
-		new Notice(
-			'No local images found in the content... Skip the image processing...'
-		)
-	}
-
-	/** ****************************************************************************
-	 * Generate article content
-	 * *****************************************************************************
-	 */
-	new Notice('Generating article content...')
-	const articleContent = await generateArticleContent(
-		content,
-		openai,
-		settings,
-		useAdditionalCallAPI
-	)
-
-	/** ****************************************************************************
-	 * Add the content, image, and gallery to the article content based on the settings
-	 * *****************************************************************************
-	 */
-	const imageFullPathProperty = useAdditionalCallAPI
-		? settings.additionalImageFullPathProperty
-		: settings.mainImageFullPathProperty
-	const galleryFullPathProperty = useAdditionalCallAPI
-		? settings.additionalGalleryFullPathProperty
-		: settings.mainGalleryFullPathProperty
-
-	articleContent.data = {
-		...articleContent.data,
-		...(imageBlob &&
-			imageFullPathProperty && { [imageFullPathProperty]: imageBlob.id }),
-		...(galleryUploadedImageIds.length > 0 &&
-			galleryFullPathProperty && {
-				[galleryFullPathProperty]: galleryUploadedImageIds,
-			}),
-	}
+			)
 
-	new Notice('Article content generated successfully!')
-	try {
-		const response = await fetch(
-			useAdditionalCallAPI
-				? settings.additionalUrl
-				: settings.strapiArticleCreateUrl,
-			{
-				method: 'POST',
-				headers: {
-					'Content-Type': 'application/json',
-					Authorization: `Bearer ${settings.strapiApiToken}`,
-				},
-				body: JSON.stringify(articleContent),
+			if (uploadResult) {
+				processedImages.push(uploadResult)
 			}
-		)
-
-		if (response.ok) {
-			new Notice(
-				'Check your API content now, the article is created & uploaded! 🎉'
-			)
-		} else {
-			const errorData = await response.json()
-			new Notice(
-				`Failed to create article in Strapi. Error: ${errorData.error.message}`
-			)
+		} catch (error) {
+			throw new Error(`Failed to process image ${ref.path}: ${error.message}`)
 		}
-	} catch (error) {
-		new Notice(`Error creating article in Strapi. Error: ${error.message}`)
 	}
-}
-
-/**
- * Extract image paths from the markdown content
- * @param content
- */
-export function extractImagePaths(content: string): string[] {
-	const imageRegex = /!\[\[([^\[\]]*\.(png|jpe?g|gif|bmp|webp))\]\]/gi
-	const imagePaths: string[] = []
-	let match
-
-	while ((match = imageRegex.exec(content)) !== null) {
-		imagePaths.push(match[1])
-	}
-
-	return imagePaths
-}
-
-/**
- * Check if the markdown content has unexported images
- * @param content
- */
-export function hasUnexportedImages(content: string): boolean {
-	const imageRegex = /!\[\[([^\[\]]*\.(png|jpe?g|gif|bmp|webp))\]\]/gi
-	return imageRegex.test(content)
-}
 
-/**
- * Get the image blobs from the image paths
- * @param app
- * @param imagePaths
- */
-export async function getImageBlobs(
-	app: App,
-	imagePaths: string[]
-): Promise<{ path: string; blob: Blob; name: string }[]> {
-	const files = app.vault.getAllLoadedFiles()
-	const fileNames = files.map(file => file.name)
-	const imageFiles = imagePaths.filter(path => fileNames.includes(path))
-	return await Promise.all(
-		imageFiles.map(async path => {
-			const file = files.find(file => file.name === path)
-			if (file instanceof TFile) {
-				const blob = await app.vault.readBinary(file)
-				return {
-					name: path,
-					blob: new Blob([blob], { type: 'image/png' }),
-					path: file.path,
-				}
-			}
-			return {
-				name: '',
-				blob: new Blob(),
-				path: '',
-			}
-		})
-	)
+	return processedImages
 }
 
 /**
- * Get the image blob from the image path
- * @param app
- * @param imageFolderPath
+ * Update image references in content with uploaded URLs
  */
-export async function getImageBlob(
-	app: App,
-	imageFolderPath: string
-): Promise<{ path: string; blob: Blob; name: string } | null> {
-	const folder = app.vault.getAbstractFileByPath(imageFolderPath)
-	if (folder instanceof TFolder) {
-		const files = folder.children.filter(
-			file =>
-				file instanceof TFile &&
-				file.extension.match(/^(jpg|jpeg|png|gif|bmp|webp)$/i)
-		)
-		if (files.length > 0) {
-			// check the TFILE type, and not cast it to TFILE
-			if (!(files[0] instanceof TFile)) {
-				return null
-			}
-			const file = files[0]
-
-			const blob = await app.vault.readBinary(file)
-			return {
-				name: file.name,
-				blob: new Blob([blob], { type: 'image/png' }),
-				path: file.path,
+function updateImageReferences(
+	content: string,
+	processedImages: ImageDescription[]
+): string {
+	try {
+		let updatedContent = content
+		for (const image of processedImages) {
+			if (image.url) {
+				const imageRegex = new RegExp(
+					`!\\[([^\\]]*)\\]\\(${image.path}\\)|!\\[\\[${image.path}\\]\\]`,
+					'g'
+				)
+				updatedContent = updatedContent.replace(
+					imageRegex,
+					`![${image.description?.alternativeText || ''}](${image.url})`
+				)
 			}
 		}
-	} else {
-		new Notice(
-			'Image folder not found. Please create an "image" folder next to your article file.'
-		)
-	}
-	return null
-}
 
-/**
- * Get the gallery image blobs from the folder path
- * @param app
- * @param galleryFolderPath
- */
-export async function getGalleryImageBlobs(
-	app: App,
-	galleryFolderPath: string
-): Promise<{ path: string; blob: Blob; name: string }[]> {
-	const folder = app.vault.getAbstractFileByPath(galleryFolderPath)
-	if (folder instanceof TFolder) {
-		const files = folder.children.filter(
-			file =>
-				file instanceof TFile &&
-				file.extension.match(/^(jpg|jpeg|png|gif|bmp|webp)$/i)
-		)
-		return Promise.all(
-			files.map(async file => {
-				// check the TFILE type, and not cast it to TFILE
-				if (!(file instanceof TFile)) {
-					return {
-						name: '',
-						blob: new Blob(),
-						path: '',
-					}
-				}
-				const blob = await app.vault.readBinary(file)
-				return {
-					name: file.name,
-					blob: new Blob([blob], { type: 'image/png' }),
-					path: file.path,
-				}
-			})
-		)
-	} else {
-		new Notice(
-			'Gallery folder not found. Please create a "gallery" folder next to your article file.'
-		)
+		return updatedContent
+	} catch (error) {
+		throw new Error(`Failed to update image references: ${error.message}`)
 	}
-	return []
 }
 
 /**
- * Replace the image paths in the content with the uploaded images
- * @param content
- * @param uploadedImages
+ * Check if a path is an external URL
  */
-export function replaceImagePaths(
-	content: string,
-	uploadedImages: { [key: string]: { url: string; data: any } }
-): string {
-	for (const [localPath, imageData] of Object.entries(uploadedImages)) {
-		const markdownImageRegex = new RegExp(`!\\[\\[${localPath}\\]\\]`, 'g')
-		content = content.replace(
-			markdownImageRegex,
-			`![${imageData.data.alternativeText}](${imageData.url})`
-		)
-	}
-	return content
+function isExternalUrl(path: string): boolean {
+	return path.startsWith('http://') || path.startsWith('https://')
 }