@heyputer/puter.js 2.1.6 → 2.1.8

package/src/modules/FileSystem/operations/upload.js

@@ -1,19 +1,22 @@
-import path from "../../../lib/path.js";
+import path from '../../../lib/path.js';
 import * as utils from '../../../lib/utils.js';
 import getAbsolutePathForApp from '../utils/getAbsolutePathForApp.js';
 
-const upload = async function(items, dirPath, options = {}){
+const upload = async function (items, dirPath, options = {}) {
     return new Promise(async (resolve, reject) => {
-        const DataTransferItem = globalThis.DataTransfer || (class DataTransferItem {});
-        const FileList = globalThis.FileList || (class FileList {});
-        const DataTransferItemList = globalThis.DataTransferItemList || (class DataTransferItemList {});
-
-        // If auth token is not provided and we are in the web environment, 
+        const DataTransferItem = globalThis.DataTransfer || (class DataTransferItem {
+        });
+        const FileList = globalThis.FileList || (class FileList {
+        });
+        const DataTransferItemList = globalThis.DataTransferItemList || (class DataTransferItemList {
+        });
+
+        // If auth token is not provided and we are in the web environment,
         // try to authenticate with Puter
-        if(!puter.authToken && puter.env === 'web'){
-            try{
+        if ( !puter.authToken && puter.env === 'web' ) {
+            try {
                 await puter.ui.authenticateWithPuter();
-            }catch(e){
+            } catch (e) {
                 // if authentication fails, throw an error
                 reject(e);
             }
@@ -21,8 +24,10 @@ const upload = async function(items, dirPath, options = {}){
 
         const error = (e) => {
             // if error callback is provided, call it
-            if(options.error && typeof options.error === 'function')
+            if ( options.error && typeof options.error === 'function' )
+            {
                 options.error(e);
+            }
             return reject(e);
         };
 
@@ -30,8 +35,10 @@ const upload = async function(items, dirPath, options = {}){
         let xhr = new XMLHttpRequest();
 
         // Can not write to root
-        if(dirPath === '/')
+        if ( dirPath === '/' )
+        {
             return error('Can not upload to root directory.');
+        }
 
         // If dirPath is not provided or it's not starting with a slash, it means it's a relative path
         // in that case, we need to prepend the app's root directory to it
@@ -44,7 +51,7 @@ const upload = async function(items, dirPath, options = {}){
 
         // Call 'init' callback if provided
         // init is basically a hook that allows the user to get the operation ID and the XMLHttpRequest object
-        if(options.init && typeof options.init === 'function'){
+        if ( options.init && typeof options.init === 'function' ) {
             options.init(operation_id, xhr);
         }
 
@@ -63,66 +70,74 @@ const upload = async function(items, dirPath, options = {}){
         let file_count = 0;
 
         let seemsToBeParsedDataTransferItems = false;
-        if(Array.isArray(items) && items.length > 0){
-            for(let i=0; i<items.length; i++){
-                if(items[i] instanceof DataTransferItem || items[i] instanceof DataTransferItemList){
+        if ( Array.isArray(items) && items.length > 0 ) {
+            for ( let i = 0; i < items.length; i++ ) {
+                if ( items[i] instanceof DataTransferItem || items[i] instanceof DataTransferItemList ) {
                     seemsToBeParsedDataTransferItems = true;
                 }
             }
         }
 
         // DataTransferItemList
-        if(items instanceof DataTransferItemList || items instanceof DataTransferItem  || items[0] instanceof DataTransferItem || options.parsedDataTransferItems){
+        if ( items instanceof DataTransferItemList || items instanceof DataTransferItem || items[0] instanceof DataTransferItem || options.parsedDataTransferItems ) {
             // if parsedDataTransferItems is true, it means the user has already parsed the DataTransferItems
-            if(options.parsedDataTransferItems)
+            if ( options.parsedDataTransferItems )
+            {
                 entries = items;
+            }
             else
+            {
                 entries = await puter.ui.getEntriesFromDataTransferItems(items);
+            }
 
             // Sort entries by size ascending
             entries.sort((entry_a, entry_b) => {
-                if ( entry_a.isDirectory && ! entry_b.isDirectory ) return -1;
-                if ( ! entry_a.isDirectory && entry_b.isDirectory ) return 1;
+                if ( entry_a.isDirectory && !entry_b.isDirectory ) return -1;
+                if ( !entry_a.isDirectory && entry_b.isDirectory ) return 1;
                 if ( entry_a.isDirectory && entry_b.isDirectory ) return 0;
-        
+
                 return entry_a.size - entry_b.size;
             });
         }
         // FileList/File
-        else if(items instanceof File || items[0] instanceof File || items instanceof FileList || items[0] instanceof FileList){
-            if(!Array.isArray(items))
+        else if ( items instanceof File || items[0] instanceof File || items instanceof FileList || items[0] instanceof FileList ) {
+            if ( ! Array.isArray(items) )
+            {
                 entries = items instanceof FileList ? Array.from(items) : [items];
+            }
             else
+            {
                 entries = items;
+            }
 
             // Sort entries by size ascending
             entries.sort((entry_a, entry_b) => {
                 return entry_a.size - entry_b.size;
-            })
+            });
             // add FullPath property to each entry
-            for(let i=0; i<entries.length; i++){
+            for ( let i = 0; i < entries.length; i++ ) {
                 entries[i].filepath = entries[i].name;
                 entries[i].fullPath = entries[i].name;
             }
         }
         // blob
-        else if(items instanceof Blob){
+        else if ( items instanceof Blob ) {
             // create a File object from the blob
-            let file = new File([items], options.name, { type: "application/octet-stream" });
+            let file = new File([items], options.name, { type: 'application/octet-stream' });
             entries = [file];
             // add FullPath property to each entry
-            for(let i=0; i<entries.length; i++){
+            for ( let i = 0; i < entries.length; i++ ) {
                 entries[i].filepath = entries[i].name;
                 entries[i].fullPath = entries[i].name;
             }
         }
         // String
-        else if(typeof items === 'string'){
+        else if ( typeof items === 'string' ) {
             // create a File object from the string
-            let file = new File([items], 'default.txt', { type: "text/plain" });
+            let file = new File([items], 'default.txt', { type: 'text/plain' });
             entries = [file];
             // add FullPath property to each entry
-            for(let i=0; i<entries.length; i++){
+            for ( let i = 0; i < entries.length; i++ ) {
                 entries[i].filepath = entries[i].name;
                 entries[i].fullPath = entries[i].name;
             }
@@ -134,50 +149,54 @@ const upload = async function(items, dirPath, options = {}){
 
         // Will hold directories and files to be uploaded
         let dirs = [];
-        let uniqueDirs = {}
+        let uniqueDirs = {};
         let files = [];
 
         // Separate files from directories
-        for(let i=0; i<entries.length; i++){
+        for ( let i = 0; i < entries.length; i++ ) {
             // skip empty entries
-            if(!entries[i])
+            if ( ! entries[i] )
+            {
                 continue;
+            }
             //collect dirs
-            if(entries[i].isDirectory)
-                dirs.push({path: path.join(dirPath, entries[i].finalPath ? entries[i].finalPath : entries[i].fullPath)});
+            if ( entries[i].isDirectory )
+            {
+                dirs.push({ path: path.join(dirPath, entries[i].finalPath ? entries[i].finalPath : entries[i].fullPath) });
+            }
             // also files
-            else{
+            else {
                 // Dragged and dropped files do not have a finalPath property and hence the fileItem will go undefined.
                 // In such cases, we need default to creating the files as uploaded by the user.
                 let fileItem = entries[i].finalPath ? entries[i].finalPath : entries[i].fullPath;
-                let [dirLevel, fileName] = [fileItem?.slice(0, fileItem?.lastIndexOf("/")), fileItem?.slice(fileItem?.lastIndexOf("/") + 1)]
-                
+                let [dirLevel, fileName] = [fileItem?.slice(0, fileItem?.lastIndexOf('/')), fileItem?.slice(fileItem?.lastIndexOf('/') + 1)];
+
                 // If file name is blank then we need to create only an empty directory.
                 // On the other hand if the file name is not blank(could be undefined), we need to create the file.
-                fileName != "" && files.push(entries[i])
-                if (options.createFileParent && fileItem.includes('/')) {
+                fileName != '' && files.push(entries[i]);
+                if ( options.createFileParent && fileItem.includes('/') ) {
                     let incrementalDir;
                     dirLevel.split('/').forEach((directory) => {
-                        incrementalDir = incrementalDir ? incrementalDir + '/' + directory : directory;
-                        let filePath = path.join(dirPath, incrementalDir)
+                        incrementalDir = incrementalDir ? `${incrementalDir }/${ directory}` : directory;
+                        let filePath = path.join(dirPath, incrementalDir);
                         // Prevent duplicate parent directory creation
-                        if(!uniqueDirs[filePath]){
+                        if ( ! uniqueDirs[filePath] ) {
                             uniqueDirs[filePath] = true;
-                            dirs.push({path: filePath});
+                            dirs.push({ path: filePath });
                         }
-                    })
+                    });
                 }
             }
             // stats about the upload to come
-            if(entries[i].size !== undefined){
+            if ( entries[i].size !== undefined ) {
                 total_size += (entries[i].size);
                 file_count++;
             }
         }
 
         // Continue only if there are actually any files/directories to upload
-        if(dirs.length === 0 && files.length === 0){
-            return error({code: 'EMPTY_UPLOAD', message: 'No files or directories to upload.'});
+        if ( dirs.length === 0 && files.length === 0 ) {
+            return error({ code: 'EMPTY_UPLOAD', message: 'No files or directories to upload.' });
         }
 
         // Check storage capacity.
@@ -188,56 +207,58 @@ const upload = async function(items, dirPath, options = {}){
         //
         // Space check in 'web' environment is currently not supported since it requires permissions.
         let storage;
-        if(puter.env !== 'web'){
-            try{
+        if ( puter.env !== 'web' ) {
+            try {
                 storage = await this.space();
-                if(storage.capacity - storage.used < total_size){
-                    return error({code: 'NOT_ENOUGH_SPACE', message: 'Not enough storage space available.'});
+                if ( storage.capacity - storage.used < total_size ) {
+                    return error({ code: 'NOT_ENOUGH_SPACE', message: 'Not enough storage space available.' });
                 }
-            }catch(e){
+            } catch (e) {
                 // Ignored
             }
         }
-    
+
         // total size of the upload is doubled because we will be uploading the files to the server
         // and then the server will upload them to the cloud
         total_size = total_size * 2;
 
         // holds the data to be sent to the server
         const fd = new FormData();
-    
+
         //-------------------------------------------------
-        // Generate the requests to create all the 
+        // Generate the requests to create all the
         // folders in this upload
         //-------------------------------------------------
         dirs.sort((a, b) => b.path.length - a.path.length);
         let mkdir_requests = [];
-    
-        for(let i=0; i < dirs.length; i++){
+
+        for ( let i = 0; i < dirs.length; i++ ) {
             // update all file paths under this folder if dirname was changed
-            for(let j=0; j<files.length; j++){
+            for ( let j = 0; j < files.length; j++ ) {
                 // if file is in this folder and has not been processed yet
-                if(!files[j].puter_path_param && path.join(dirPath, files[j].filepath).startsWith((dirs[i].path) + '/')){
-                    files[j].puter_path_param = `$dir_${i}/`+ path.basename(files[j].filepath);
+                if ( !files[j].puter_path_param && path.join(dirPath, files[j].filepath).startsWith(`${dirs[i].path }/`) ) {
+                    files[j].puter_path_param = `$dir_${i}/${ path.basename(files[j].filepath)}`;
                 }
             }
-    
+
             // update all subdirs under this dir
-            for(let k=0; k < dirs.length; k++){
-                if(!dirs[k].puter_path_param && dirs[k].path.startsWith(dirs[i].path + '/')){
-                    dirs[k].puter_path_param = `$dir_${i}/`+ path.basename(dirs[k].path);
+            for ( let k = 0; k < dirs.length; k++ ) {
+                if ( !dirs[k].puter_path_param && dirs[k].path.startsWith(`${dirs[i].path }/`) ) {
+                    dirs[k].puter_path_param = `$dir_${i}/${ path.basename(dirs[k].path)}`;
                 }
             }
         }
 
-        for(let i=0; i < dirs.length; i++){
+        for ( let i = 0; i < dirs.length; i++ ) {
             let parent_path = path.dirname(dirs[i].puter_path_param || dirs[i].path);
             let dir_path = dirs[i].puter_path_param || dirs[i].path;
-            
+
             // remove parent path from the beginning of path since path is relative to parent
-            if(parent_path !== '/')
+            if ( parent_path !== '/' )
+            {
                 dir_path = dir_path.replace(parent_path, '');
-    
+            }
+
             mkdir_requests.push({
                 op: 'mkdir',
                 parent: parent_path,
@@ -248,23 +269,23 @@ const upload = async function(items, dirPath, options = {}){
                 as: `dir_${i}`,
             });
         }
-    
+
         // inverse mkdir_requests so that the root folder is created first
         // and then go down the tree
         mkdir_requests.reverse();
-    
+
         fd.append('operation_id', operation_id);
         fd.append('socket_id', this.socket.id);
         fd.append('original_client_socket_id', this.socket.id);
 
         // Append mkdir operations to upload request
-        for(let i=0; i<mkdir_requests.length; i++){
-            fd.append('operation', JSON.stringify(mkdir_requests[i]));          
+        for ( let i = 0; i < mkdir_requests.length; i++ ) {
+            fd.append('operation', JSON.stringify(mkdir_requests[i]));
         }
-    
+
         // Append file metadata to upload request
-        if(!options.shortcutTo){
-            for(let i=0; i<files.length; i++){
+        if ( ! options.shortcutTo ) {
+            for ( let i = 0; i < files.length; i++ ) {
                 fd.append('fileinfo', JSON.stringify({
                     name: files[i].name,
                     type: files[i].type,
@@ -273,12 +294,12 @@ const upload = async function(items, dirPath, options = {}){
             }
         }
         // Append write operations for each file
-        for(let i=0; i<files.length; i++){
+        for ( let i = 0; i < files.length; i++ ) {
             fd.append('operation', JSON.stringify({
                 op: options.shortcutTo ? 'shortcut' : 'write',
                 dedupe_name: options.dedupeName ?? true,
                 overwrite: options.overwrite ?? false,
-                create_missing_ancestors: (options.createMissingAncestors ||  options.createMissingParents),
+                create_missing_ancestors: (options.createMissingAncestors || options.createMissingParents),
                 operation_id: operation_id,
                 path: (
                     files[i].puter_path_param &&
@@ -294,102 +315,108 @@ const upload = async function(items, dirPath, options = {}){
                 app_uid: options.appUID,
             }));
         }
-        
+
         // Append files to upload
-        if(!options.shortcutTo){
-            for(let i=0; i<files.length; i++){
+        if ( ! options.shortcutTo ) {
+            for ( let i = 0; i < files.length; i++ ) {
                 fd.append('file', files[i] ?? '');
             }
         }
-    
+
         const progress_handler = (msg) => {
-            if(msg.operation_id === operation_id){
-                bytes_uploaded_to_cloud += msg.loaded_diff
+            if ( msg.operation_id === operation_id ) {
+                bytes_uploaded_to_cloud += msg.loaded_diff;
             }
-        }
+        };
 
         // Handle upload progress events from server
         this.socket.on('upload.progress', progress_handler);
 
         // keeps track of the amount of data uploaded to the server
         let previous_chunk_uploaded = null;
-    
+
         // open request to server
-        xhr.open("post",(this.APIOrigin +'/batch'), true);
+        xhr.open('post', (`${this.APIOrigin }/batch`), true);
         // set auth header
-        xhr.setRequestHeader("Authorization", "Bearer " + this.authToken);
+        xhr.setRequestHeader('Authorization', `Bearer ${ this.authToken}`);
 
         // -----------------------------------------------
         // Upload progress: client -> server
         // -----------------------------------------------
-        xhr.upload.addEventListener('progress', function(e){
+        xhr.upload.addEventListener('progress', function (e) {
             // update operation tracker
             let chunk_uploaded;
-            if(previous_chunk_uploaded === null){
+            if ( previous_chunk_uploaded === null ) {
                 chunk_uploaded = e.loaded;
                 previous_chunk_uploaded = 0;
-            }else{
+            } else {
                 chunk_uploaded = e.loaded - previous_chunk_uploaded;
             }
             previous_chunk_uploaded += chunk_uploaded;
             bytes_uploaded_to_server += chunk_uploaded;
 
             // overall operation progress
-            let op_progress = ((bytes_uploaded_to_cloud + bytes_uploaded_to_server)/total_size * 100).toFixed(2);
+            let op_progress = ((bytes_uploaded_to_cloud + bytes_uploaded_to_server) / total_size * 100).toFixed(2);
             op_progress = op_progress > 100 ? 100 : op_progress;
 
             // progress callback function
-            if(options.progress && typeof options.progress === 'function')
+            if ( options.progress && typeof options.progress === 'function' )
+            {
                 options.progress(operation_id, op_progress);
-        })
-    
+            }
+        });
+
         // -----------------------------------------------
         // Upload progress: server -> cloud
         // the following code will check the progress of the upload every 100ms
         // -----------------------------------------------
-        let cloud_progress_check_interval = setInterval(function() {
+        let cloud_progress_check_interval = setInterval(function () {
             // operation progress
-            let op_progress = ((bytes_uploaded_to_cloud + bytes_uploaded_to_server)/total_size * 100).toFixed(2);
-    
+            let op_progress = ((bytes_uploaded_to_cloud + bytes_uploaded_to_server) / total_size * 100).toFixed(2);
+
             op_progress = op_progress > 100 ? 100 : op_progress;
-            if(options.progress && typeof options.progress === 'function')
+            if ( options.progress && typeof options.progress === 'function' )
+            {
                 options.progress(operation_id, op_progress);
+            }
         }, 100);
-    
+
         // -----------------------------------------------
         // onabort
         // -----------------------------------------------
-        xhr.onabort = ()=>{
+        xhr.onabort = () => {
             // stop the cloud upload progress tracker
             clearInterval(cloud_progress_check_interval);
             // remove progress handler
             this.socket.off('upload.progress', progress_handler);
             // if an 'abort' callback is provided, call it
-            if(options.abort && typeof options.abort === 'function')
+            if ( options.abort && typeof options.abort === 'function' )
+            {
                 options.abort(operation_id);
-        }
+            }
+        };
 
         // -----------------------------------------------
         // on success/error
         // -----------------------------------------------
-        xhr.onreadystatechange = async (e)=>{
-            if (xhr.readyState === 4) {
+        xhr.onreadystatechange = async (e) => {
+            if ( xhr.readyState === 4 ) {
                 const resp = await utils.parseResponse(xhr);
-                // Error 
-                if((xhr.status >= 400 && xhr.status < 600) || (options.strict && xhr.status === 218)) {
+                // Error
+                if ( (xhr.status >= 400 && xhr.status < 600) || (options.strict && xhr.status === 218) ) {
                     // stop the cloud upload progress tracker
                     clearInterval(cloud_progress_check_interval);
 
                     // remove progress handler
                     this.socket.off('upload.progress', progress_handler);
 
-                    // If this is a 'strict' upload (i.e. status code is 218), we need to find out which operation failed 
+                    // If this is a 'strict' upload (i.e. status code is 218), we need to find out which operation failed
                     // and call the error callback with that operation.
-                    if(options.strict && xhr.status === 218){
+                    if ( options.strict && xhr.status === 218 ) {
                         // find the operation that failed
                         let failed_operation;
-                        for(let i=0; i<resp.results?.length; i++){
-                            if(resp.results[i].status !== 200){
+                        for ( let i = 0; i < resp.results?.length; i++ ) {
+                            if ( resp.results[i].status !== 200 ) {
                                 failed_operation = resp.results[i];
                                 break;
                             }
@@ -400,18 +427,20 @@ const upload = async function(items, dirPath, options = {}){
                     return error(resp);
                 }
                 // Success
-                else{
-                    if(!resp || !resp.results || resp.results.length === 0){
+                else {
+                    if ( !resp || !resp.results || resp.results.length === 0 ) {
                         // no results
-                        if(puter.debugMode)
+                        if ( puter.debugMode )
+                        {
                             console.log('no results');
+                        }
                     }
-    
+
                     let items = resp.results;
                     items = items.length === 1 ? items[0] : items;
 
                     // if success callback is provided, call it
-                    if(options.success && typeof options.success === 'function'){
+                    if ( options.success && typeof options.success === 'function' ) {
                         options.success(items);
                     }
                     // stop the cloud upload progress tracker
@@ -422,16 +451,16 @@ const upload = async function(items, dirPath, options = {}){
                     return resolve(items);
                 }
             }
-        }
-    
+        };
+
         // Fire off the 'start' event
-        if(options.start && typeof options.start === 'function'){
+        if ( options.start && typeof options.start === 'function' ) {
             options.start();
         }
 
         // send request
         xhr.send(fd);
-    })
-}
+    });
+};
 
 export default upload;

package/src/modules/FileSystem/operations/write.js

@@ -1,13 +1,13 @@
-import path from "../../../lib/path.js";
+import path from '../../../lib/path.js';
 import getAbsolutePathForApp from '../utils/getAbsolutePathForApp.js';
 
 const write = async function (targetPath, data, options = {}) {
     // targetPath is required
-    if(!targetPath){
+    if ( ! targetPath ) {
         throw new Error({ code: 'NO_TARGET_PATH', message: 'No target path provided.' });
     }
     // if targetPath is a File
-    if(targetPath instanceof File && data === undefined){
+    if ( targetPath instanceof File && data === undefined ) {
         data = targetPath;
         targetPath = data.name;
     }
@@ -21,8 +21,10 @@ const write = async function (targetPath, data, options = {}) {
     options.overwrite = options.overwrite ?? true;
 
     // if overwrite is true and dedupeName is not provided, set dedupeName to false
-    if(options.overwrite && options.dedupeName === undefined)
+    if ( options.overwrite && options.dedupeName === undefined )
+    {
         options.dedupeName = false;
+    }
 
     // if targetPath is not provided or it's not starting with a slash, it means it's a relative path
     // in that case, we need to prepend the app's root directory to it
@@ -35,28 +37,30 @@ const write = async function (targetPath, data, options = {}) {
     const parent = path.dirname(targetPath);
 
     // if data is a string, convert it to a File object
-    if(typeof data === 'string'){
-        data = new File([data ?? ''], filename ?? 'Untitled.txt', { type: "text/plain" });
+    if ( typeof data === 'string' ) {
+        data = new File([data ?? ''], filename ?? 'Untitled.txt', { type: 'text/plain' });
     }
     // blob
-    else if(data instanceof Blob){
+    else if ( data instanceof Blob ) {
         data = new File([data ?? ''], filename ?? 'Untitled', { type: data.type });
     }
     // typed arrays (Uint8Array, Int8Array, etc.) and ArrayBuffer
-    else if(data instanceof ArrayBuffer || ArrayBuffer.isView(data)){
-        data = new File([data], filename ?? 'Untitled', { type: "application/octet-stream" });
+    else if ( data instanceof ArrayBuffer || ArrayBuffer.isView(data) ) {
+        data = new File([data], filename ?? 'Untitled', { type: 'application/octet-stream' });
     }
 
-    if(!data)
+    if ( ! data )
+    {
         data = new File([data ?? ''], filename);
+    }
 
     // data should be a File now. If it's not, it's an unsupported type
-    if (!(data instanceof File)) {
+    if ( ! (data instanceof File) ) {
         throw new Error({ code: 'field_invalid', message: 'write() data parameter is an invalid type' });
     }
 
     // perform upload
     return this.upload(data, parent, options);
-}
+};
 
 export default write;

package/src/modules/FileSystem/utils/getAbsolutePathForApp.js

@@ -1,21 +1,25 @@
-import path from "../../../lib/path.js"
+import path from '../../../lib/path.js';
 
-const getAbsolutePathForApp = (relativePath)=>{
+const getAbsolutePathForApp = (relativePath) => {
     // if we are in the gui environment, return the relative path as is
-    if(puter.env === 'gui')
+    if ( puter.env === 'gui' )
+    {
         return relativePath;
+    }
 
     // if no relative path is provided, use the current working directory
-    if(!relativePath)
+    if ( ! relativePath )
+    {
         relativePath = '.';
+    }
 
     // If relativePath is not provided, or it's not starting with a slash or tilde,
     // it means it's a relative path. In that case, prepend the app's root directory.
-    if (!relativePath || (!relativePath.startsWith('/') && !relativePath.startsWith('~') && puter.appID)) {
+    if ( !relativePath || (!relativePath.startsWith('/') && !relativePath.startsWith('~') && puter.appID) ) {
         relativePath = path.join('~/AppData', puter.appID, relativePath);
     }
 
     return relativePath;
-}
+};
 
 export default getAbsolutePathForApp;