How To List Files in a FileSystemDirectoryHandle

[cstack89]

Summary

I'm super new to Rust and WebAssembly so I apologize if this a basic question. I am attempting to write a simple program that reads and writes to the OPFS. All of the work is happening inside a Worker Thread. I get a Window from the WorkerGlobalScope, get the navigator, then I open a new file eventually getting a FileSystemSyncAccessHandle. From there I write out a bunch of bytes to the file and close it. Before I close it I check the size and it says it has content. I then try to use the FileSystemDirectoryHandle entries method to iterate over the list of files in the base folder. The compiler complains until I do this: Object::entries(&dir2);. That returns no results, so I suspect it's wrong. Could someone point me in the direction of listing the contents of a directory from the OPFS?

Additional Details

`
//Not sure why Ic an't get this to format.
let window = js_sys::global().dyn_into::().unwrap();

log::debug!("got window");
let navigator = window.navigator();
log::debug!("got navigator");
let promise = js_sys::Promise::resolve(&navigator.storage().get_directory());
let result = wasm_bindgen_futures::JsFuture::from(promise).await.expect("awaiting array promise");
let dir = FileSystemDirectoryHandle::from(result);
log::debug!("directory received");
let mut name = web_sys::FileSystemGetFileOptions::new();
name.create(true);
log::debug!("file options created");
let promise2 = js_sys::Promise::resolve( &dir.get_file_handle_with_options(&in_file.name(),&name));
let result2 = wasm_bindgen_futures::JsFuture::from(promise2).await.expect("awaiting array promise");
log::debug!("file received");
let out_file = web_sys::FileSystemFileHandle::from(result2);
let promise3 = js_sys::Promise::resolve( &out_file.create_sync_access_handle( ));
let result3 = wasm_bindgen_futures::JsFuture::from(promise3).await.expect("awaiting array promise");
log::debug!("file sync received");
let out_sync_file = web_sys::FileSystemSyncAccessHandle::from(result3);


const BUF_SIZE: usize = 1024 * 1024;

let mut wf = WebSysFile::new(in_file);

let mut buffer = vec![0; BUF_SIZE];
let mut _count: u64 = 0;
while let Ok(n) = wf.read(&mut buffer[..]) {
    if n == 0 {
        // Probably end of file
        break;
    }

    let rest = &buffer[0..n];
    let _res = out_sync_file.write_with_u8_array(&rest);
    _count += n as u64;
}

let flush_val = out_sync_file.flush();
let size = out_sync_file.get_size().ok().unwrap();
out_sync_file.close();
let promise5 = js_sys::Promise::resolve(&navigator.storage().get_directory());
let result5 = wasm_bindgen_futures::JsFuture::from(promise5).await.expect("awaiting array promise");
let dir2 = FileSystemDirectoryHandle::from(result5);

// let mut stream = JsStream::from(Object::entries(&dir)); 
let f_names = Object::entries(&dir2);

let mut count = 0;
// let keys;
for a in f_names.iter() {
    count +=1;
}  
// while let Ok(n) = async_it.next() {
//     let promise4 = js_sys::Promise::resolve( &n);
//     let result4 = wasm_bindgen_futures::JsFuture::from(promise4).await.expect("awaiting array promise");
// //     keys = js_sys::Reflect::own_keys(&result4);
//     count +=1;
// }

format!("is ok {} and size {}, now has {} files and last file", flush_val.is_ok(),size ,count )

`

[daxpedda]

I believe what you are looking for is FileSystemDirectoryHandle.entries(), which is not the same as Object.entries().

Unfortunately this method is currently not available in web-sys, but it was added in #3962, so you have to wait for the new release, depend on the master branch or add bindings yourself:

extern "C" {
    #[wasm_bindgen(extends = FileSystemDirectoryHandle)] 
    type FileSystemDirectoryHandleExt;
    #[wasm_bindgen(method)]
    fn entries(this: &FileSystemDirectoryHandleExt) -> js_sys::AsyncIterator;
}

let dir: FileSystemDirectoryHandle = dir;
let dir: FileSystemDirectoryHandleExt = dir.unchecked_into();
let entries = dir.entires();

while Ok(entry) = entries.next() {
    let entry = JsFuture::from(entry).await;
    // do your thing
}