arcane-os 0.1.0-dev.5

package/runtime/arcane/entities/File.js

@@ -0,0 +1,143 @@
+import Is from '../../node_modules/strong-type/index.js';
+import '../modules/DBOPFS.js';
+import MD from '../modules/MD.js';
+
+const is = new Is(false);
+
+class FileEntity {
+
+    #tableName = '';
+
+    #fileName = '';
+
+    persist = true;
+
+    constructor(fileName = '', tableName = '') {
+        if (!is.string(tableName) || !tableName) {
+            tableName = this.#tableName;
+        }
+        if (!is.string(fileName) || !fileName) {
+            fileName = this.#fileName;
+        }
+
+        this.#tableName = tableName;
+        this.#fileName = fileName;
+
+        return this;
+    }
+
+    get tableName() {
+        return this.#tableName;
+    }
+
+    set tableName(value) {
+        return this.#tableName=value;
+    }
+
+    get fileName() {
+        return this.#fileName;
+    }
+
+    set fileName(fileName = '') {
+        if (!is.string(fileName) || !fileName) {
+            return this.#fileName;
+        }
+
+        this.#fileName = fileName;
+        return this.#fileName;
+    }
+
+    async open() {
+        const file = await dbopfs.readFile(
+            this.#tableName,
+            this.#fileName
+        );
+
+        const mimeTypes ={
+            "json": "application/json",
+            "jsonl": "application/x-ndjson",
+            "ndjson": "application/x-ndjson",
+
+            "txt": "text/plain;charset=utf-8",
+            "log": "text/plain;charset=utf-8",
+            "md": "text/markdown;charset=utf-8",
+
+            "html": "text/html;charset=utf-8",
+            "css": "text/css;charset=utf-8",
+            "js": "text/javascript;charset=utf-8",
+            "mjs": "text/javascript;charset=utf-8",
+
+            "png": "image/png",
+            "jpg": "image/jpeg",
+            "jpeg": "image/jpeg",
+            "webp": "image/webp",
+            "svg": "image/svg+xml",
+
+            "pdf": "application/pdf"
+        };
+
+        file.ext=this.fileName.slice(
+            (this.fileName.lastIndexOf('.')+1)
+        ).toLowerCase();
+
+        const mime=mimeTypes[file.ext]||
+            file.type||
+            'application/octet-stream';
+
+        file.mime=mime;
+        file.parsed=null;
+
+        switch(file.ext){
+            case 'json':
+                file.parsed=await file.text();
+
+                try{
+                    file.parsed=JSON.parse(file.parsed.trim());
+                }catch(e){}
+                break;
+            case 'jsonl':
+            case 'ndjson':
+                const rows=(await file.text()).split('\n');
+                const parsedRows=[];
+
+                for(let i=0;i<rows.length;i++){
+                    try{
+                        parsedRows.push(
+                            JSON.parse(rows[i].trim())
+                        );
+                    }catch(e){}
+                }
+
+                file.parsed=parsedRows;
+                break;
+            case 'md':
+                file.parsed=new MD(await file.text()).rendered;
+                break;
+            case 'txt':
+            case 'log':
+            case 'html':
+            case 'css':
+            case 'js':
+            case 'mjs':
+                file.parsed=await file.text();
+                break;
+        }
+
+        return file;
+    }
+
+    async save(fileData) {
+        // fileData can be a File, Blob, ArrayBuffer, TypedArray like Uint8Array,
+        // DataView, or string. Other values such as numbers, booleans, arrays,
+        // or plain objects should be converted first with String(), JSON.stringify(),
+        // or wrapped in a Blob before writing.
+        return dbopfs.writeFile(
+            this.#tableName,
+            this.#fileName,
+            fileData
+        );
+    }
+
+}
+
+export default FileEntity;

package/runtime/arcane/entities/Image.js

@@ -0,0 +1,135 @@
+import FileEntity from './File.js';
+
+/**
+ * ImageEntity
+ *
+ * Image-focused file entity built on top of DocumentEntity.
+ *
+ * Storage table:
+ * - OPFS `images`
+ *
+ * Adds:
+ * - image type validation helpers
+ * - base64 data URL conversion
+ * - blob URL creation/revocation helpers
+ */
+class ImageEntity extends FileEntity {
+
+	/**
+	 * Create an ImageEntity targeting OPFS `images` table.
+	 *
+	 * @param {string} fileName Optional existing OPFS file key.
+	 */
+	constructor(fileName = '', tableName='images') {
+		super(fileName, tableName);
+		return this;
+	}
+
+	/**
+	 * Check whether a file is an accepted image type.
+	 *
+	 * Accepts MIME `image/*` or extension: png, jpg/jpeg, svg.
+	 *
+	 * @param {File|Object} file
+	 * @returns {boolean}
+	 */
+	static isImageFile(file) {
+		if (!file || typeof file.name !== 'string') {
+			return false;
+		}
+
+		const hasImageMime = typeof file.type === 'string' && file.type.startsWith('image/');
+		const hasImageExt = /\.(png|jpe?g|svg)$/i.test(file.name);
+
+		return hasImageMime || hasImageExt;
+	}
+
+	/**
+	 * Strict PNG validator for PNG-only workflows.
+	 *
+	 * @param {File|Object} file
+	 * @returns {boolean}
+	 */
+	static isPNGFile(file) {
+		if (!file || typeof file.name !== 'string') {
+			return false;
+		}
+
+		const lowerName = file.name.toLowerCase();
+		const hasPngMime = typeof file.type === 'string' && file.type.toLowerCase() === 'image/png';
+		const hasPngExt = lowerName.endsWith('.png');
+
+		return hasPngMime || hasPngExt;
+	}
+
+	/**
+	 * Upload and persist an image file.
+	 *
+	 * @param {File} file
+	 * @returns {Promise<ImageEntity>}
+	 */
+	async uploadFile(file) {
+		if (!ImageEntity.isImageFile(file)) {
+			throw new Error('ImageEntity.uploadFile expects an image file');
+		}
+
+		return super.uploadFile(file);
+	}
+
+	/**
+	 * Save raw bytes to OPFS for current `storedAs` key.
+	 *
+	 * @param {ArrayBuffer} buffer
+	 * @returns {Promise<void>}
+	 */
+	async save(buffer) {
+		return super.save(buffer);
+	}
+
+	/**
+	 * Convert stored image into a base64 data URL string.
+	 *
+	 * @returns {Promise<string>}
+	 */
+	async getBase64DataURL() {
+		const file = await this.getFile();
+
+		return await new Promise(
+			(resolve, reject) => {
+				const reader = new FileReader();
+
+				reader.onload = () => resolve(reader.result);
+				reader.onerror = () => reject(reader.error || new Error('Failed to encode image as data URL'));
+
+				reader.readAsDataURL(file);
+			}
+		);
+	}
+
+	/**
+	 * Create an object URL for the stored image.
+	 *
+	 * Caller should revoke the URL when done.
+	 *
+	 * @returns {Promise<string>}
+	 */
+	async getBlobURL() {
+		const file = await this.getFile();
+		return URL.createObjectURL(file);
+	}
+
+	/**
+	 * Revoke a blob URL created for image preview.
+	 *
+	 * @param {string} url
+	 * @returns {void}
+	 */
+	static revokeBlobURL(url = '') {
+		if (typeof url === 'string' && url.startsWith('blob:')) {
+			URL.revokeObjectURL(url);
+		}
+	}
+
+}
+
+export default ImageEntity;