@cocreate/file 1.19.5 → 1.20.0

package/CHANGELOG.md

@@ -1,3 +1,27 @@
+# [1.20.0](https://github.com/CoCreate-app/CoCreate-file/compare/v1.19.6...v1.20.0) (2025-10-11)
+
+
+### Bug Fixes
+
+* add error handling for translation service in file function ([262dc66](https://github.com/CoCreate-app/CoCreate-file/commit/262dc66d57c13a8948ef1afa863413c203f965bc))
+* update import statement and modify exit behavior in server function ([6e72fde](https://github.com/CoCreate-app/CoCreate-file/commit/6e72fdec3867c031e342b3faef598b661f43a620))
+
+
+### Features
+
+* add options parameter to file function for enhanced translation support ([7fac13d](https://github.com/CoCreate-app/CoCreate-file/commit/7fac13d10b8abd40584d5abc6b89d110f84db288))
+* enhance file handling by supporting base64 encoding for binary sources and improving file reading logic ([192337c](https://github.com/CoCreate-app/CoCreate-file/commit/192337c3a44d412f8a8d2c6bb1172451661eebf5))
+* enhance file processing with support for base64 and binary types, and add variable processing functionality ([eabfddf](https://github.com/CoCreate-app/CoCreate-file/commit/eabfddf2e1c36e7abd330369c1f28f90290cc1b8))
+
+## [1.19.6](https://github.com/CoCreate-app/CoCreate-file/compare/v1.19.5...v1.19.6) (2025-09-07)
+
+
+### Bug Fixes
+
+* correct exclusion logic to check each item in the exclude array ([1fae391](https://github.com/CoCreate-app/CoCreate-file/commit/1fae391f4333813aa30805e87ba7ea28fefda5d3))
+* ensure match is an array by wrapping non-array values ([5c67ec5](https://github.com/CoCreate-app/CoCreate-file/commit/5c67ec592f0217199b2ce965d14e377d6faa9a5b))
+* ensure match is an array of directory paths and await run function ([eb47cf0](https://github.com/CoCreate-app/CoCreate-file/commit/eb47cf00c672ac5110293b3dab38fd8186bb8d64))
+
 ## [1.19.5](https://github.com/CoCreate-app/CoCreate-file/compare/v1.19.4...v1.19.5) (2025-05-01)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocreate/file",
-  "version": "1.19.5",
+  "version": "1.20.0",
   "description": "A versatile, configurable headless file uploader supporting local and server operations. Accessible via a JavaScript API and HTML5 attributes, it provides seamless file reading, writing, and uploading with fallbacks to the standard HTML5 file input API. Ideal for developers needing robust file management in headless environments.",
   "keywords": [
     "file-uploader",

package/src/client.js

@@ -28,7 +28,7 @@ import Elements from "@cocreate/elements";
 import Actions from "@cocreate/actions";
 import { render } from "@cocreate/render";
 import { queryElements } from "@cocreate/utils";
-import "@cocreate/element-prototype";
+import { setValue } from "@cocreate/element-prototype";
 
 const inputs = new Map();
 const Files = new Map();

package/src/server.js

@@ -83,13 +83,21 @@ const mimeTypes = {
 	".7z": "application/x-7z-compressed"
 };
 
-module.exports = async function file(CoCreateConfig, configPath, match) {
+module.exports = async function file(
+	CoCreateConfig,
+	configPath,
+	match,
+	options
+) {
 	let directories = CoCreateConfig.directories;
 	let sources = CoCreateConfig.sources;
 	let configDirectoryPath = path.dirname(configPath);
 
-	if (match && !Array.isArray(match)) match = [match];
-	else if (!match) match = [];
+	if (match && !Array.isArray(match)) {
+		match = [match];
+	} else if (!match) {
+		match = [];
+	}
 
 	let config = await Config(
 		{
@@ -179,7 +187,7 @@ module.exports = async function file(CoCreateConfig, configPath, match) {
 		for (let file of files) {
 			let skip = false;
 			for (let i = 0; i < exclude.length; i++) {
-				if (file.includes(exclude)) {
+				if (file.includes(exclude[i])) {
 					skip = true;
 					break;
 				}
@@ -250,7 +258,7 @@ module.exports = async function file(CoCreateConfig, configPath, match) {
 
 			let values = {
 				"{{name}}": name || "",
-				"{{source}}": source || "",
+				"{{source}}": Buffer.isBuffer(source) ? `data:${mimeType};base64,${source.toString('base64')}` : source || "",
 				"{{directory}}": directoryName || "",
 				"{{path}}": Path || "",
 				"{{pathname}}": pathname,
@@ -277,6 +285,25 @@ module.exports = async function file(CoCreateConfig, configPath, match) {
 				object
 			};
 
+			if (
+				options.translate &&
+				mimeType === "text/html" &&
+				Array.isArray(directory.languages) &&
+				!object.translations
+			) {
+				try {
+					// Call your AI translation service
+					const translations = await options.translate(
+						Buffer.isBuffer(source) ? source.toString('utf-8') : source,
+						directory.languages
+					);
+					newObject.object.translations = translations;
+				} catch (err) {
+					console.error("Translation error:", err);
+					// Continue without translations
+				}
+			}
+
 			if (directory.storage) newObject.storage = directory.storage;
 			if (directory.database) newObject.database = directory.database;
 			if (directory.array) newObject.array = directory.array || "files";
@@ -288,9 +315,13 @@ module.exports = async function file(CoCreateConfig, configPath, match) {
 					);
 					if (variables) {
 						for (let variable of variables) {
+							let replacement = values[variable];
+							if (key === 'src' && variable === '{{source}}' && Buffer.isBuffer(source)) {
+								replacement = `data:${mimeType};base64,${source.toString('base64')}`;
+							}
 							newObject.object[key] = newObject.object[
 								key
-							].replace(variable, values[variable]);
+							].replace(variable, replacement);
 						}
 					}
 				}
@@ -325,144 +356,137 @@ module.exports = async function file(CoCreateConfig, configPath, match) {
 		//     console.log(...errorLog)
 	}
 
-	async function getSource(path, mimeType, isSymlink) {
-		let readType = "utf8";
-		if (mimeType === "image/svg+xml") {
-			readType = "utf8";
-		} else if (/^(image|audio|video)\/[-+.\w]+/.test(mimeType)) {
-			readType = "base64";
-		}
+	async function getSource(filePath, mimeType, isSymlink) {
+		// 1. UPDATED: Includes standard font types and uses simpler matching
+		const base64MimeTypes = /^(image|audio|video|font\/(woff2?|ttf|otf|eot)|application\/vnd\.ms-fontobject|application\/x-font-.*|application\/octet-stream)/;
 
-		if (isSymlink) path = await realpathAsync(path);
+		// We only care if it needs to be Base64-encoded for a Data URI.
+		const needsBase64 = base64MimeTypes.test(mimeType);
 
-		let binary = fs.readFileSync(path);
-		let content = new Buffer.from(binary).toString(readType);
+		let resolvedPath = filePath;
+		if (isSymlink) {
+			// Use promises for realpath
+			resolvedPath = await realpathAsync(filePath);
+		}
 
-		return content;
+		// 2. READ: Always read the file as a raw Buffer (omitting encoding)
+		// This gives us the raw bytes, which is the safest start for any file.
+		let fileBuffer;
+		try {
+			fileBuffer = await fs.promises.readFile(resolvedPath);
+		} catch (error) {
+			console.error(`Error reading file: ${resolvedPath}`, error);
+			return ""; // Return empty string or handle error as appropriate
+		}
+
+		if (needsBase64) {
+			// 3. RETURN BUFFER: Return the raw buffer for binary files.
+			return fileBuffer;
+		} else {
+			// 4. HANDLE TEXT/OTHER:
+			// For files not intended for Base64, convert the Buffer to a string using 'utf8'.
+			return fileBuffer.toString('utf8');
+		}
 	}
 
 	/**
 	 * Store files by config sources
 	 **/
 	async function runSources() {
-		let updatedSources = [];
+		let newConfig = require(configPath);
 
 		for (let i = 0; i < sources.length; i++) {
-			const { array, object } = sources[i];
-
-			let source = { ...sources[i] };
-			let keys = new Map();
-			let response = {};
-			let isMatch = false;
-
-			try {
-				if (array) {
-					if (!object) object = {};
-					else
-						for (const key of Object.keys(object)) {
-							if (typeof object[key] != "string") continue;
-
-							let variables = object[key].match(
-								/{{([A-Za-z0-9_.,\[\]\-\/ ]*)}}/g
-							);
-							if (variables) {
-								let originalValue = object[key];
-								keys.set(key, originalValue);
-								let value = "";
-								for (let variable of variables) {
-									let entry = /{{\s*([\w\W]+)\s*}}/g.exec(
-										variable
-									);
-									entry = entry[1].trim();
-									if (entry) {
-										if (!fs.existsSync(entry)) continue;
-
-										if (!isMatch) {
-											const filePath = path.resolve(
-												configDirectoryPath,
-												entry
-											);
-											for (
-												let i = 0;
-												i < match.length;
-												i++
-											) {
-												if (
-													filePath.startsWith(
-														match[i]
-													)
-												) {
-													console.log(
-														"Source saved",
-														sources[i]
-													);
-													isMatch = true;
-													break;
-												}
-											}
-										}
-
-										let read_type = "utf8";
-										const fileExtension =
-											path.extname(entry);
-										let mime_type =
-											mimeTypes[fileExtension] ||
-											"text/html";
-
-										if (
-											/^(image|audio|video)\/[-+.\w]+/.test(
-												mime_type
-											)
-										) {
-											read_type = "base64";
-										}
-
-										let binary = fs.readFileSync(entry);
-										let content = new Buffer.from(
-											binary
-										).toString(read_type);
-										if (content) value += content;
-										// object[key] = object[key].replace(variable, content);
-									}
-								}
-								object[key] = value;
-							}
+			let data = sources[i];
+
+			// Handle string values
+			if (typeof data === "string") {
+				let {value, filePath } = await processVariables(data);
+				let response = await runStore(value);
+				if (response && response.object && response.object[0]) {
+					updateFilePath(filePath, response); // Call the new function to update the file path
+				}
+			} else if (data.array && data.object) {
+				if (typeof data.object === "string") {
+					let {value, filePath } = await processVariables(data.object);
+					if (value) {
+						let response = await runStore(value);
+						if (response && response.object && response.object[0]) {
+							updateFilePath(filePath, response.object);
 						}
-
-					let data = { array, object };
-					if (!object._id && object.pathname)
-						data.$filter = {
-							query: {
-								$or: [{ pathname: object.pathname }]
-							}
-						};
-
-					if (match.length && isMatch)
-						response = await runStore(data);
+					}
+				} else if (typeof data.object === "object" && data.object !== null) {
+					for (const key in data) {
+						let {value } = await processVariables(data[key]);
+						if (data) {
+							data.object[key] = value;
+						}
+					}
+					let response = await runStore(data);
+					if (response && response.object && response.object[0] && response.object[0]._id) {
+						newConfig.sources[i].object._id = response.object[0]._id;
+					}
 				}
-			} catch (err) {
-				console.log(err);
-				process.exit();
 			}
 
-			if (
-				response.object &&
-				response.object[0] &&
-				response.object[0]._id
-			) {
-				source.object._id = response.object[0]._id;
-			}
+		}
 
-			for (const [key, value] of keys) {
-				source.object[key] = value;
-			}
+		return newConfig;
+	}
+
+	async function processVariables(value) {
+		let variableMatch = /{{\s*([\w\W]+)\s*}}/g.exec(value);
+		if (!variableMatch) return { value, filePath: null };
+
+		let entry = variableMatch[1].trim();
+		if (!fs.existsSync(entry)) return { value, filePath: null };
+
+		const filePath = path.resolve(configDirectoryPath, entry);
+
+		// Check if the file path matches any of the provided match patterns
+		let isMatched = match.some((pattern) => filePath.startsWith(pattern));
+		if (!isMatched) return { value, filePath: null };
 
-			updatedSources.push(source);
+		// Read the file as is
+		let content;
+		try {
+			const fileMimeType = mimeTypes[path.extname(entry)] || "text/plain";
+
+			if (fileMimeType === "application/json") {
+				// Parse JSON files
+				content = JSON.parse(fs.readFileSync(filePath, "utf8"));
+			} else if (fileMimeType === "application/javascript" || fileMimeType === "text/javascript") {
+				// For JavaScript files, require the file to execute exports
+				content = require(filePath);
+			} else {
+				// For plain strings, read as UTF-8 without conversion
+				content = fs.readFileSync(filePath, "utf8");
+			}
+		} catch (error) {
+			console.error(`Failed to process file: ${filePath}`, error);
+			return { value, filePath: null };
 		}
 
-		return updatedSources;
+		return { value: content, filePath };
 	}
 
+	/**
+	 * Updates the file at the given file path with the provided data.
+	 * The data is saved as a JSON string.
+	 * 
+	 * @param {string} filePath - The path of the file to update.
+	 * @param {object} data - The data to write to the file.
+	 */
+	function updateFilePath(filePath, data) {
+		try {
+			const jsonData = JSON.stringify(data, null, 4); // Format JSON with indentation
+			fs.writeFileSync(filePath, jsonData, "utf8");
+			console.log(`File updated successfully at: ${filePath}`);
+		} catch (error) {
+			console.error(`Failed to update file at: ${filePath}`, error);
+		}
+	}
+
+
 	async function runStore(data) {
 		try {
 			let response;
@@ -490,42 +514,22 @@ module.exports = async function file(CoCreateConfig, configPath, match) {
 	}
 
 	async function run() {
-		if (directories) await runDirectories();
+		if (directories) {
+			await runDirectories();
+		}
 
 		if (sources && sources.length) {
-			let sources = await runSources();
-			let newConfig = { ...CoCreateConfig };
-			if (directories && directories.length)
-				newConfig.directories = directories;
-
-			newConfig.sources = sources;
-
-			if (newConfig.repositories)
-				newConfig.repositories.forEach((obj) => {
-					for (const key in obj) {
-						if (!["path", "repo", "exclude"].includes(key)) {
-							delete obj[key];
-						}
-					}
-				});
-
-			delete newConfig.url;
-			delete newConfig.broadcast;
-
+			let newConfig = await runSources();
 			fs.writeFileSync(
 				configPath,
 				`module.exports = ${JSON.stringify(newConfig, null, 4)};`
 			);
 		}
-
-		if (!match.length) {
-			console.log("upload complete!");
-
-			setTimeout(function () {
-				process.exit();
-			}, 2000);
-		}
 	}
 
-	run();
+	await run();
+	// Only exit if not in watch mode
+	if (!process.argv.includes("--watch") && !process.argv.includes("-w")) {
+		process.exit();
+	}
 };