Merge branch 'export-cmd' into wasm

README.md

@@ -7,20 +7,24 @@ and interacts with the main thread via [`SharedArrayBuffer`][shared-array-buffer
 
 ### [Try it with your browser][try it]
 
-- **NOTICES**
+- **USAGE**
+  - Drag&Drop file to browser tab opens it in Vim
+  - `:write` only writes file on memory.  Download current buffer by `:export` or
+    specific file by `:export {file}`.
+  - You can try vimtutor by `:e tutor`.
+
+- **NOTICE**
   - Please access from desktop Chrome, Firefox, Safari or Chromium based browsers
     since this project uses `SharedArrayBuffer` and `Atomics`.  On Firefox or Safari,
     feature flags (`javascript.options.shared_memory` for Firefox) must be enabled
     for now.
-  - Drag&Drop file to browser tab opens the file in Vim
   - vim.wasm takes key inputs from DOM `keydown` event. Please disable your browser
-    extensions which affect key inputs (incognito mode would be the best).
+    extensions which intercept key events (incognito mode would be the best).
   - This project is very early phase of experiment.  Only tiny features
     are supported for now (please see TODO section).  And you may notice soon on
     trying it... it's buggy :)
   - If inputting something does not change anything, please try to click somewhere
     in the page.  Vim may have lost the focus.
-  - You can try vimtutor by `:e tutor`.
   - Vim exits on `:quit`, but it does not close a browser tab. Please close it
     manually :)
 

src/ex_cmdidxs.h

@@ -10,27 +10,27 @@ static const unsigned short cmdidxs1[26] =
   /* c */ 42,
   /* d */ 103,
   /* e */ 125,
-  /* f */ 145,
-  /* g */ 161,
-  /* h */ 167,
-  /* i */ 176,
-  /* j */ 194,
-  /* k */ 196,
-  /* l */ 201,
-  /* m */ 259,
-  /* n */ 277,
-  /* o */ 297,
-  /* p */ 309,
-  /* q */ 348,
-  /* r */ 351,
-  /* s */ 370,
-  /* t */ 437,
-  /* u */ 477,
-  /* v */ 488,
-  /* w */ 506,
-  /* x */ 521,
-  /* y */ 530,
-  /* z */ 531
+  /* f */ 146,
+  /* g */ 162,
+  /* h */ 168,
+  /* i */ 177,
+  /* j */ 195,
+  /* k */ 197,
+  /* l */ 202,
+  /* m */ 260,
+  /* n */ 278,
+  /* o */ 298,
+  /* p */ 310,
+  /* q */ 349,
+  /* r */ 352,
+  /* s */ 371,
+  /* t */ 438,
+  /* u */ 478,
+  /* v */ 489,
+  /* w */ 507,
+  /* x */ 522,
+  /* y */ 531,
+  /* z */ 532
 };
 
 /*
@@ -69,4 +69,4 @@ static const unsigned char cmdidxs2[26][26] =
   /* z */ {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0 }
 };
 
-static const int command_count = 544;
+static const int command_count = 545;

src/ex_cmds.c

@@ -8563,3 +8563,53 @@ ex_oldfiles(exarg_T *eap UNUSED)
     }
 }
 #endif
+
+
+    void
+ex_export(exarg_T *eap)
+{
+#ifndef FEAT_GUI_WASM
+    EMSG(_("E9999: This command is available only for Wasm build"));
+#else
+    int		other;
+    char_u	*ffname = eap->arg;
+    int		free_ffname = FALSE;
+
+    // Note: This implementation referred implementation of do_write()
+    // Note: ffname means full-fname
+
+    if (curbufIsChanged() && do_write(eap) == FAIL)
+    {
+	// Could not write the buffer. Do not export file
+	return;
+    }
+
+    if (*ffname == NUL)
+    {
+	ffname = curbuf->b_ffname;
+    }
+    else
+    {
+	ffname = fix_fname(ffname);
+	if (ffname == NULL)
+	{
+	    EMSG(_("E9999: Could not export this file"));
+	    return;
+	}
+	free_ffname = TRUE;
+    }
+
+    if (ffname == NULL)
+	EMSG(_("E9999: Cannot export file due to OOM"));
+    else
+    {
+	if (!vimwasm_export_file(ffname))
+	{
+	    EMSG(_("E9999: Could not export file in JavaScript runtime"));
+	}
+    }
+
+    if (free_ffname)
+	vim_free(ffname);
+#endif // FEAT_GUI_WASM
+}

src/ex_cmds.h

@@ -535,6 +535,9 @@ EX(CMD_execute,		"execute",	ex_execute,
 EX(CMD_exit,		"exit",		ex_exit,
 			RANGE|WHOLEFOLD|BANG|FILE1|ARGOPT|DFLALL|TRLBAR|CMDWIN,
 			ADDR_LINES),
+EX(CMD_export,		"export",	ex_export,
+			FILE1|ARGOPT|TRLBAR,
+			ADDR_LINES),
 EX(CMD_exusage,		"exusage",	ex_exusage,
 			TRLBAR,
 			ADDR_LINES),

src/proto/ex_cmds.pro

@@ -67,4 +67,5 @@ void ex_smile(exarg_T *eap);
 void ex_drop(exarg_T *eap);
 char_u *skip_vimgrep_pat(char_u *p, char_u **s, int *flags);
 void ex_oldfiles(exarg_T *eap);
+void ex_export(exarg_T *eap);
 /* vim: set ft=c : */

src/wasm_runtime.h

@@ -43,6 +43,7 @@ int vimwasm_get_mouse_y(void);
 void vimwasm_resize(int, int);
 int vimwasm_call_shell(char *);
 int vimwasm_wait_for_event(int timeout);
+int vimwasm_export_file(char *fullpath);
 
 #endif /* FEAT_GUI_WASM */
 

wasm/common.d.ts

@@ -56,7 +56,13 @@ declare type MessageFromWorker =
           readonly status: number;
           timestamp?: number;
       }
-    | FileBufferMessageFromWorker;
+    | FileBufferMessageFromWorker
+    | {
+          readonly kind: 'export';
+          readonly path: string;
+          readonly contents: ArrayBuffer;
+          timestamp?: number;
+      };
 declare type MessageKindFromWorker = MessageFromWorker['kind'];
 
 declare type EventStatusFromMain = 0 | 1 | 2 | 3 | 4;

wasm/main.ts

@@ -543,6 +543,7 @@ interface StartOptions {
 class VimWasm {
     public onVimInit?: () => void;
     public onVimExit?: (status: number) => void;
+    public onFileExport?: (fullpath: string, contents: ArrayBuffer) => void;
     private readonly worker: VimWorker;
     private readonly screen: ScreenCanvas;
     private readonly resizer: ResizeHandler;
@@ -652,6 +653,19 @@ class VimWasm {
                 this.screen.enqueue(msg.event);
                 debug('draw event', msg.event);
                 break;
+            case 'export':
+                debug(
+                    'Exporting file',
+                    msg.path,
+                    'with size',
+                    msg.contents.byteLength,
+                    'bytes with',
+                    this.onFileExport,
+                );
+                if (this.onFileExport !== undefined) {
+                    this.onFileExport(msg.path, msg.contents);
+                }
+                break;
             case 'started':
                 this.screen.onVimInit();
                 this.resizer.onVimInit();
@@ -679,7 +693,7 @@ class VimWasm {
                 debug('Vim exited with status', msg.status);
                 break;
             default:
-                throw new Error(`FATAL: Unexpected message from worker: ${msg}`);
+                throw new Error(`FATAL: Unexpected message from worker: ${JSON.stringify(msg)}`);
         }
     }
 
@@ -796,4 +810,18 @@ if (!perf) {
     };
 }
 
+vim.onFileExport = (fullpath: string, contents: ArrayBuffer) => {
+    const slashIdx = fullpath.lastIndexOf('/');
+    const filename = slashIdx !== -1 ? fullpath.slice(slashIdx + 1) : fullpath;
+    const blob = new Blob([contents], { type: 'application/octet-stream' });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.style.display = 'none';
+    a.href = url;
+    a.download = filename;
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+};
+
 vim.start({ debug: debugging, perf });

wasm/runtime.d.ts

@@ -24,6 +24,7 @@ declare const FS: {
         stderr: ((...args: any[]) => void) | null,
     ): void;
     writeFile(name: string, contents: Uint8Array): void;
+    readFile(path: string, opts?: { encoding?: string; flags?: string }): Uint8Array;
 };
 declare interface VimWasmRuntime {
     domWidth: number;
@@ -33,6 +34,7 @@ declare interface VimWasmRuntime {
     vimStarted(): void;
     vimExit(status: number): void;
     waitForEventFromMain(timeout: number | undefined): number;
+    exportFile(fullpath: string): number;
 }
 declare const VW: {
     runtime: VimWasmRuntime;

wasm/runtime.ts

@@ -160,6 +160,13 @@ const VimWasmLibrary = {
                     }
                 }
 
+                exportFile(fullpath: string) {
+                    const contents = FS.readFile(fullpath).buffer; // encoding = binary
+                    debug('Read', contents.byteLength, 'bytes contents from', fullpath);
+                    this.sendMessage({ kind: 'export', path: fullpath, contents }, [contents]);
+                    return 1;
+                }
+
                 private eventStatus() {
                     return Atomics.load(this.buffer, 0) as EventStatusFromMain;
                 }
@@ -264,13 +271,13 @@ const VimWasmLibrary = {
                     return [idx, s];
                 }
 
-                private sendMessage(msg: MessageFromWorker) {
+                private sendMessage(msg: MessageFromWorker, transfer?: ArrayBuffer[]) {
                     if (this.perf) {
                         // performance.now() is not available because time origin is different between
                         // Window and Worker
                         msg.timestamp = Date.now();
                     }
-                    postMessage(msg);
+                    postMessage(msg, transfer as any);
                 }
             }
 
@@ -441,6 +448,11 @@ const VimWasmLibrary = {
     vimwasm_wait_for_event(timeout: number): number {
         return VW.runtime.waitForEventFromMain(timeout > 0 ? timeout : undefined);
     },
+
+    // int vimwasm_export_file(char *);
+    vimwasm_export_file(fullpath: CharPtr) {
+        return VW.runtime.exportFile(UTF8ToString(fullpath));
+    },
 };
 
 autoAddDeps(VimWasmLibrary, '$VW');