forked from sheetjs/docs.sheetjs.com
703 lines
19 KiB
Markdown
703 lines
19 KiB
Markdown
---
|
|
title: Data Wrangling in Tauri Apps
|
|
sidebar_label: Tauri
|
|
description: Build data-intensive desktop apps using Tauri. Seamlessly integrate spreadsheets into your app using SheetJS. Modernize Excel-powered business processes with confidence.
|
|
pagination_prev: demos/mobile/index
|
|
pagination_next: demos/cli/index
|
|
sidebar_position: 4
|
|
sidebar_custom_props:
|
|
summary: Webview + Rust Backend
|
|
---
|
|
|
|
import current from '/version.js';
|
|
import Tabs from '@theme/Tabs';
|
|
import TabItem from '@theme/TabItem';
|
|
import CodeBlock from '@theme/CodeBlock';
|
|
|
|
export const y = {style: {color:"gold"}};
|
|
export const g = {style: {color:"green"}};
|
|
export const B = {style: {fontWeight:"bold"}};
|
|
|
|
[Tauri](https://tauri.app/) is a modern toolkit for building desktop apps. Tauri
|
|
apps leverage platform-native browser engines to build lightweight programs.
|
|
|
|
[SheetJS](https://sheetjs.com) is a JavaScript library for reading and writing
|
|
data from spreadsheets.
|
|
|
|
This demo uses Tauri and SheetJS to pull data from a spreadsheet and display the
|
|
data in the app. We'll explore how to load SheetJS in a Tauri app and exchange
|
|
file data between the JavaScript frontend and Rust backend.
|
|
|
|
The ["Complete Example"](#complete-example) section covers a complete desktop
|
|
app to read and write workbooks. The app will look like the screenshots below:
|
|
|
|
<table><thead><tr>
|
|
<th><a href="#complete-example">Windows</a></th>
|
|
<th><a href="#complete-example">macOS</a></th>
|
|
<th><a href="#complete-example">Linux</a></th>
|
|
</tr></thead><tbody><tr><td>
|
|
|
|

|
|
|
|
</td><td>
|
|
|
|

|
|
|
|
</td><td>
|
|
|
|

|
|
|
|
</td></tr></tbody></table>
|
|
|
|
## Integration Details
|
|
|
|
The [SheetJS NodeJS Module](/docs/getting-started/installation/nodejs) can be
|
|
installed and imported from JavaScript code.
|
|
|
|
:::note pass
|
|
|
|
Tauri currently does not provide the equivalent of NodeJS `fs` module. The raw
|
|
`@tauri-apps/api` methods used in the examples are not expected to change.
|
|
|
|
:::
|
|
|
|
For security reasons, Tauri apps must explicitly enable system features.[^1]
|
|
They are enabled in `src-tauri/tauri.conf.json` in the `allowlist` subsection of
|
|
the `tauri` section of the config.
|
|
|
|
- The `fs` entitlement[^2] enables reading and writing file data.
|
|
|
|
```js title="src-tauri/tauri.conf.json"
|
|
"tauri": {
|
|
"allowlist": {
|
|
//highlight-start
|
|
"fs": {
|
|
"all": true
|
|
}
|
|
// highlight-end
|
|
```
|
|
|
|
- The `dialog` entitlement[^3] enables the open and save dialog methods.
|
|
|
|
```js title="src-tauri/tauri.conf.json"
|
|
"tauri": {
|
|
"allowlist": {
|
|
//highlight-start
|
|
"dialog": {
|
|
"all": true
|
|
}
|
|
// highlight-end
|
|
```
|
|
|
|
- The `http` entitlement[^4] enables downloading files. Note that `http` is not
|
|
needed for reading or writing files in the local filesystem.
|
|
|
|
```json title="src-tauri/tauri.conf.json"
|
|
"tauri": {
|
|
"allowlist": {
|
|
//highlight-start
|
|
"http": {
|
|
"all": true,
|
|
"request": true,
|
|
"scope": ["https://**"]
|
|
}
|
|
// highlight-end
|
|
```
|
|
|
|
### Reading Files
|
|
|
|
There are three steps to reading files:
|
|
|
|
1) Show an open file dialog to allow users to select a path. The `open` method
|
|
in `@tauri-apps/api/dialog`[^5] simplifies this process.
|
|
|
|
2) Read raw data from the selected file using the `readBinaryFile` method in
|
|
`@tauri-apps/api/fs`[^6]. This method resolves to a standard `Uint8Array`
|
|
|
|
3) Parse the data with the SheetJS `read` method[^7]. This method returns a
|
|
SheetJS workbook object.
|
|
|
|
The following code example defines a single function `openFile` that performs
|
|
all three steps and returns a SheetJS workbook object:
|
|
|
|
```js
|
|
import { read } from 'xlsx';
|
|
import { open } from '@tauri-apps/api/dialog';
|
|
import { readBinaryFile } from '@tauri-apps/api/fs';
|
|
|
|
const filters = [
|
|
{name: "Excel Binary Workbook", extensions: ["xlsb"]},
|
|
{name: "Excel Workbook", extensions: ["xlsx"]},
|
|
{name: "Excel 97-2004 Workbook", extensions: ["xls"]},
|
|
// ... other desired formats ...
|
|
];
|
|
|
|
async function openFile() {
|
|
/* show open file dialog */
|
|
const selected = await open({
|
|
title: "Open Spreadsheet",
|
|
multiple: false,
|
|
directory: false,
|
|
filters
|
|
});
|
|
|
|
/* read data into a Uint8Array */
|
|
const d = await readBinaryFile(selected);
|
|
|
|
/* parse with SheetJS */
|
|
const wb = read(d);
|
|
return wb;
|
|
}
|
|
```
|
|
|
|
At this point, standard SheetJS utility functions[^8] can extract data from the
|
|
workbook object. The demo includes a button that calls `sheet_to_json`[^9] to
|
|
generate an array of arrays of data.
|
|
|
|
<Tabs groupId="framework">
|
|
<TabItem value="vuejs" label="VueJS">
|
|
|
|
The following snippet uses the VueJS framework:
|
|
|
|
```js title="VueJS sample"
|
|
import { utils } from 'xlsx';
|
|
import { shallowRef } from 'vue';
|
|
const data = shallowRef([[]]); // update data by setting `data.value`
|
|
|
|
const open_button_callback = async() => {
|
|
const wb = await openFile();
|
|
|
|
/* get the first worksheet */
|
|
// highlight-start
|
|
const ws = wb.Sheets[wb.SheetNames[0]];
|
|
// highlight-end
|
|
|
|
/* get data from the first worksheet */
|
|
// highlight-start
|
|
const array = utils.sheet_to_json(ws, { header: 1 });
|
|
// highlight-end
|
|
data.value = array;
|
|
};
|
|
```
|
|
|
|
</TabItem>
|
|
<TabItem value="kaioken" label="Kaioken" default>
|
|
|
|
The following snippet shows a simple Kaioponent:
|
|
|
|
```tsx title="Kaioponent for importing data"
|
|
import { utils } from 'xlsx';
|
|
import { useState } from 'kaioken';
|
|
|
|
function SheetJSImportKaioponent() {
|
|
const [data, setData] = useState<any[][]>([]);
|
|
|
|
const open_callback = async() => {
|
|
const wb = await openFile();
|
|
|
|
/* get the first worksheet */
|
|
// highlight-start
|
|
const ws = wb.Sheets[wb.SheetNames[0]];
|
|
// highlight-end
|
|
|
|
/* get data from the first worksheet */
|
|
// highlight-start
|
|
const array = utils.sheet_to_json(ws, { header: 1 });
|
|
// highlight-end
|
|
setData(array);
|
|
};
|
|
|
|
return ( <>
|
|
<button type="button" onclick={open_callback}>Load Data</button>
|
|
<table><tbody>{data.map((row) =>
|
|
<tr>{row.map((cell) => <td>{cell}</td>)}</tr>
|
|
)}</tbody></table>
|
|
</> );
|
|
}
|
|
```
|
|
|
|
</TabItem>
|
|
</Tabs>
|
|
|
|
### Writing Files
|
|
|
|
There are three steps to writing files:
|
|
|
|
1) Show a save file dialog to allow users to select a path. The `save` method
|
|
in `@tauri-apps/api/dialog`[^10] simplifies this process.
|
|
|
|
2) Write the data with the SheetJS `write` method[^11]. The output book type can
|
|
be inferred from the selected file path. Using the `buffer` output type[^12],
|
|
the method will return a `Uint8Array` object that plays nice with Tauri.
|
|
|
|
3) Write the data using `writeBinaryFile` in `@tauri-apps/api/fs`[^13].
|
|
|
|
The following code example defines a single function `saveFile` that performs
|
|
all three steps starting from a SheetJS workbook object:
|
|
|
|
```js
|
|
import { write } from 'xlsx';
|
|
import { save } from '@tauri-apps/api/dialog';
|
|
import { writeBinaryFile } from '@tauri-apps/api/fs';
|
|
|
|
const filters = [
|
|
{name: "Excel Binary Workbook", extensions: ["xlsb"]},
|
|
{name: "Excel Workbook", extensions: ["xlsx"]},
|
|
{name: "Excel 97-2004 Workbook", extensions: ["xls"]},
|
|
// ... other desired formats ...
|
|
];
|
|
|
|
async function saveFile(wb) {
|
|
/* show save file dialog */
|
|
const selected = await save({
|
|
title: "Save to Spreadsheet",
|
|
filters
|
|
});
|
|
if(!selected) return;
|
|
|
|
/* Generate workbook */
|
|
const bookType = selected.slice(selected.lastIndexOf(".") + 1);
|
|
const d = write(wb, {type: "buffer", bookType});
|
|
|
|
/* save data to file */
|
|
await writeBinaryFile(selected, d);
|
|
}
|
|
```
|
|
|
|
The demo includes a button that calls `aoa_to_sheet`[^14] to generate a sheet
|
|
from array of arrays of data. A workbook is constructed using `book_new` and
|
|
`book_append_sheet`[^15].
|
|
|
|
<Tabs groupId="framework">
|
|
<TabItem value="vuejs" label="VueJS">
|
|
|
|
The following snippet uses the VueJS framework:
|
|
|
|
```js title="VueJS sample"
|
|
import { utils } from 'xlsx';
|
|
import { shallowRef } from 'vue';
|
|
const data = shallowRef([[]]); // `data.value` is an array of arrays
|
|
|
|
const save_button_callback = async() => {
|
|
/* generate worksheet from the data */
|
|
// highlight-start
|
|
const ws = utils.aoa_to_sheet(data.value);
|
|
// highlight-end
|
|
|
|
/* create a new workbook object */
|
|
// highlight-start
|
|
const wb = utils.book_new();
|
|
// highlight-end
|
|
|
|
/* append the worksheet to the workbook using the sheet name "SheetJSTauri" */
|
|
// highlight-start
|
|
utils.book_append_sheet(wb, ws, "SheetJSTauri");
|
|
// highlight-end
|
|
|
|
await saveFile(wb);
|
|
}
|
|
```
|
|
|
|
</TabItem>
|
|
<TabItem value="kaioken" label="Kaioken" default>
|
|
|
|
The following snippet shows a simple Kaioponent:
|
|
|
|
```js title="Kaioponent for exporting data"
|
|
import { utils } from 'xlsx';
|
|
import { useState } from 'kaioken';
|
|
|
|
function SheetJSExportKaioponent() {
|
|
const [data, setData] = useState<any[][]>(["SheetJS".split(""), "Kaioken".split("")]);
|
|
|
|
const save_callback = async() => {
|
|
/* generate worksheet from the data */
|
|
// highlight-start
|
|
const ws = utils.aoa_to_sheet(data);
|
|
// highlight-end
|
|
|
|
/* create a new workbook object */
|
|
// highlight-start
|
|
const wb = utils.book_new();
|
|
// highlight-end
|
|
|
|
/* append the worksheet to the workbook using the sheet name "SheetJSTauri" */
|
|
// highlight-start
|
|
utils.book_append_sheet(wb, ws, "SheetJSTauri");
|
|
// highlight-end
|
|
|
|
await saveFile(wb);
|
|
}
|
|
|
|
return ( <button type="button" onclick={save_callback}>Save Data</button> );
|
|
}
|
|
```
|
|
|
|
</TabItem>
|
|
</Tabs>
|
|
|
|
## Complete Example
|
|
|
|
:::note Tested Deployments
|
|
|
|
This demo was tested in the following environments:
|
|
|
|
| OS and Version | Architecture | Tauri | Date |
|
|
|:---------------|:-------------|:----------|:-----------|
|
|
| macOS 14.4 | `darwin-x64` | `v1.5.11` | 2024-04-20 |
|
|
| macOS 14.0 | `darwin-arm` | `v1.5.2` | 2023-10-18 |
|
|
| Windows 10 | `win10-x64` | `v1.5.11` | 2024-03-24 |
|
|
| Windows 11 | `win11-arm` | `v1.5.7` | 2023-12-01 |
|
|
| Linux (HoloOS) | `linux-x64` | `v1.5.11` | 2024-03-21 |
|
|
| Linux (Debian) | `linux-arm` | `v1.5.7` | 2023-12-01 |
|
|
|
|
:::
|
|
|
|
0) Read Tauri "Getting Started" guide and install prerequisites.[^16]
|
|
|
|
<details>
|
|
<summary><b>Installation Notes</b> (click to show)</summary>
|
|
|
|
At a high level, the following software is required for building Tauri apps:
|
|
|
|
- a native platform-specific C/C++ compiler (for example, macOS requires Xcode)
|
|
- a browser engine integration (for example, linux requires `webkit2gtk`)
|
|
- [Rust](https://www.rust-lang.org/tools/install)
|
|
|
|
The platform configuration can be verified by running:
|
|
|
|
```bash
|
|
npx @tauri-apps/cli info
|
|
```
|
|
|
|
If required dependencies are installed, the output will show a checkmark next to
|
|
"Environment". The output from the most recent macOS test is shown below:
|
|
|
|
<pre>
|
|
<span {...g}>[✔]</span> <span style={{...y.style,...B.style}}>Environment</span>
|
|
{` `}<span {...g}>-</span> <span {...B}>OS</span>: Mac OS 14.4.1 X64
|
|
{` `}<span {...g}>✔</span> <span {...B}>Xcode Command Line Tools</span>: installed
|
|
{` `}<span {...g}>✔</span> <span {...B}>rustc</span>: 1.77.2 (25ef9e3d8 2024-04-09)
|
|
{` `}<span {...g}>✔</span> <span {...B}>cargo</span>: 1.77.2 (e52e36006 2024-03-26)
|
|
{` `}<span {...g}>✔</span> <span {...B}>rustup</span>: 1.27.0 (bbb9276d2 2024-03-08)
|
|
{` `}<span {...g}>✔</span> <span {...B}>Rust toolchain</span>: stable-x86_64-apple-darwin (default)
|
|
{` `}<span {...g}>-</span> <span {...B}>node</span>: 20.12.1
|
|
{` `}<span {...g}>-</span> <span {...B}>npm</span>: 10.5.0
|
|
{` `}<span {...g}>-</span> <span {...B}>bun</span>: 1.1.4
|
|
</pre>
|
|
|
|
:::caution pass
|
|
|
|
When the demo was last tested on ARM64 macOS, the output mentioned `X64`. The
|
|
build step will correctly detect the platform architecture.
|
|
|
|
:::
|
|
|
|
</details>
|
|
|
|
1) Create a new Tauri app:
|
|
|
|
<Tabs groupId="framework">
|
|
<TabItem value="vuejs" label="VueJS">
|
|
|
|
```bash
|
|
npm create tauri-app@latest -- -m npm -t vue-ts SheetJSTauri -y
|
|
```
|
|
|
|
</TabItem>
|
|
<TabItem value="kaioken" label="Kaioken" default>
|
|
|
|
:::note pass
|
|
|
|
There is no official Tauri Kaioken template. This demo starts from the vanilla
|
|
TypeScript template and manually wires Kaioken
|
|
|
|
:::
|
|
|
|
```bash
|
|
npm create tauri-app@latest -- -m npm -t vanilla-ts SheetJSTauri -y
|
|
```
|
|
|
|
</TabItem>
|
|
</Tabs>
|
|
|
|
2) Enter the directory and install dependencies:
|
|
|
|
<CodeBlock language="bash">{`\
|
|
cd SheetJSTauri
|
|
npm i --save https://cdn.sheetjs.com/xlsx-${current}/xlsx-${current}.tgz
|
|
npm i --save @tauri-apps/api
|
|
npm i --save-dev @tauri-apps/cli`}
|
|
</CodeBlock>
|
|
|
|
<Tabs groupId="framework">
|
|
<TabItem value="vuejs" label="VueJS">
|
|
|
|
</TabItem>
|
|
<TabItem value="kaioken" label="Kaioken" default>
|
|
|
|
Install the Kaioken dependencies:
|
|
|
|
```bash
|
|
npm add kaioken --save
|
|
npm add vite-plugin-kaioken -D --save
|
|
```
|
|
|
|
</TabItem>
|
|
</Tabs>
|
|
|
|
3) Add the highlighted lines to `src-tauri/tauri.conf.json` in the
|
|
`tauri.allowlist` section:
|
|
|
|
```json title="src-tauri/tauri.conf.json (add highlighted lines)"
|
|
"tauri": {
|
|
"allowlist": {
|
|
// highlight-start
|
|
"http": {
|
|
"all": true,
|
|
"request": true,
|
|
"scope": ["https://**"]
|
|
},
|
|
"dialog": {
|
|
"all": true
|
|
},
|
|
"fs": {
|
|
"all": true
|
|
},
|
|
// highlight-end
|
|
```
|
|
|
|
In the same file, look for `"identifier"` and change the value to `com.sheetjs.tauri`:
|
|
|
|
```json title="src-tauri/tauri.conf.json (edit highlighted line)"
|
|
"targets": "all",
|
|
// highlight-next-line
|
|
"identifier": "com.sheetjs.tauri",
|
|
"icon": [
|
|
```
|
|
|
|
<Tabs groupId="framework">
|
|
<TabItem value="vuejs" label="VueJS">
|
|
|
|
4) Download [`App.vue`](pathname:///tauri/App.vue) and replace `src/App.vue`
|
|
with the downloaded script.
|
|
|
|
```bash
|
|
curl -o src/App.vue https://docs.sheetjs.com/tauri/App.vue
|
|
```
|
|
|
|
</TabItem>
|
|
<TabItem value="kaioken" label="Kaioken" default>
|
|
|
|
4) Wire up Kaioken to the Tauri app:
|
|
|
|
- Add the highlighted lines to `vite.config.ts`:
|
|
|
|
```ts title="vite.config.ts (add highlighted lines)"
|
|
import { defineConfig } from "vite";
|
|
// highlight-next-line
|
|
import kaioken from "vite-plugin-kaioken";
|
|
|
|
// https://vitejs.dev/config/
|
|
export default defineConfig(async () => ({
|
|
// highlight-start
|
|
plugins: [kaioken()],
|
|
// highlight-end
|
|
```
|
|
|
|
- Add the highlighted line to `tsconfig.json`:
|
|
|
|
```js title="tsconfig.json (add highlighted line)"
|
|
{
|
|
"compilerOptions": {
|
|
// highlight-next-line
|
|
"jsx": "preserve",
|
|
"target": "ES2020",
|
|
```
|
|
|
|
- Replace `index.html` with the following codeblock:
|
|
|
|
```html title="index.html"
|
|
<!doctype html>
|
|
<html lang="en">
|
|
<head>
|
|
<meta charset="UTF-8" />
|
|
<link rel="stylesheet" href="/src/styles.css" />
|
|
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
|
|
<title>SheetJS x Tauri</title>
|
|
<script type="module" src="/src/main.ts" defer></script>
|
|
</head>
|
|
|
|
<body>
|
|
<div id="container" class="container"></div>
|
|
</body>
|
|
</html>
|
|
```
|
|
|
|
- Add the following lines to `src/styles.css`:
|
|
|
|
```css title="src/styles.css (add to end)"
|
|
.logo {
|
|
padding: 0px;
|
|
height: 64px; width: 64px;
|
|
vertical-align: middle;
|
|
}
|
|
.logo:hover {
|
|
filter: drop-shadow(0 0 2em #646cffaa);
|
|
}
|
|
.centre { text-align: center; }
|
|
table.center {
|
|
margin-left: auto;
|
|
margin-right: auto;
|
|
}
|
|
```
|
|
|
|
- Replace `src/main.ts` with the following codeblock:
|
|
|
|
```ts title="src/main.ts"
|
|
import { mount } from "kaioken";
|
|
import App from "./App";
|
|
|
|
const root = document.getElementById("container");
|
|
mount(App, root!);
|
|
```
|
|
|
|
- Download [`App.tsx`](pathname:///tauri/App.tsx) and save to `src/App.tsx`:
|
|
|
|
```bash
|
|
curl -o src/App.tsx https://docs.sheetjs.com/tauri/App.tsx
|
|
```
|
|
|
|
</TabItem>
|
|
</Tabs>
|
|
|
|
5) Build the app with
|
|
|
|
```bash
|
|
npm run tauri build
|
|
```
|
|
|
|
At the end, it will print the path to the generated installer.
|
|
|
|
:::info pass
|
|
|
|
If the build fails, see ["Troubleshooting"](#troubleshooting) for more details.
|
|
|
|
:::
|
|
|
|
6) Run the program.
|
|
|
|
<Tabs groupId="os">
|
|
<TabItem value="unix" label="Linux/MacOS">
|
|
|
|
Depending on the version of Tauri, the command may be
|
|
|
|
```bash
|
|
./src-tauri/target/release/SheetJSTauri
|
|
```
|
|
|
|
or
|
|
|
|
```bash
|
|
./src-tauri/target/release/sheet-js-tauri
|
|
```
|
|
|
|
or
|
|
|
|
```bash
|
|
./src-tauri/target/release/sheetjstauri
|
|
```
|
|
|
|
</TabItem>
|
|
<TabItem value="win" label="Windows">
|
|
|
|
```powershell
|
|
.\src-tauri\target\release\SheetJSTauri.exe
|
|
```
|
|
|
|
</TabItem>
|
|
</Tabs>
|
|
|
|
The following features should be manually verified:
|
|
|
|
- When it is loaded, the app will download https://docs.sheetjs.com/pres.numbers
|
|
and display the data in a table.
|
|
- Clicking "Save Data" will show a save dialog. After selecting a path and name,
|
|
the app will write a file. That file can be opened in a spreadsheet editor.
|
|
- Edit the file in a spreadsheet editor, then click "Load Data" and select the
|
|
edited file. The table will refresh with new contents.
|
|
|
|
#### Troubleshooting
|
|
|
|
:::note pass
|
|
|
|
During the last Linux ARM64 test, the build failed to create an AppImage:
|
|
|
|
```
|
|
Error [tauri-cli-node] failed to bundle project: error running appimage.sh
|
|
```
|
|
|
|
This is a known Tauri AppImage packaging bug. Since the actual application and
|
|
the `.deb` distributable are created, the error can be ignored.
|
|
|
|
:::
|
|
|
|
:::note pass
|
|
|
|
During the last Linux x64 test, the build failed with the error message:
|
|
|
|
```
|
|
'openssl/opensslv.h' file not found
|
|
```
|
|
|
|
OpenSSL must be installed. On Arch Linux and HoloOS (Steam Deck):
|
|
|
|
```bash
|
|
sudo pacman -S openssl
|
|
```
|
|
|
|
:::
|
|
|
|
:::note pass
|
|
|
|
In some macOS tests, the build failed with the following error message:
|
|
|
|
```
|
|
Error failed to bundle project: error running bundle_dmg.sh
|
|
```
|
|
|
|
The root cause of the error can be discovered by running
|
|
|
|
```bash
|
|
npm run tauri build -- --verbose
|
|
```
|
|
|
|
The most recent test failed with a message:
|
|
|
|
```
|
|
execution error: Not authorized to send Apple events to Finder
|
|
```
|
|
|
|
This error was resolved by allowing Terminal to control Finder.
|
|
|
|
In the "System Settings" app, select "Privacy & Security" in the left column and
|
|
select "Automation" in the body. Look for "Terminal", expand the section, and enable "Finder".
|
|
|
|
:::
|
|
|
|
[^1]: See ["Security"](https://tauri.app/v1/references/architecture/security#allowing-api) in the Tauri documentation
|
|
[^2]: See [`FsAllowlistConfig`](https://tauri.app/v1/api/config/#fsallowlistconfig) in the Tauri documentation
|
|
[^3]: See [`DialogAllowlistConfig`](https://tauri.app/v1/api/config/#dialogallowlistconfig) in the Tauri documentation
|
|
[^4]: See [`HttpAllowlistConfig`](https://tauri.app/v1/api/config/#httpallowlistconfig) in the Tauri documentation
|
|
[^5]: See [`dialog`](https://tauri.app/v1/api/js/dialog/#open) in the Tauri documentation
|
|
[^6]: See [`fs`](https://tauri.app/v1/api/js/fs#readbinaryfile) in the Tauri documentation
|
|
[^7]: See [`read` in "Reading Files"](/docs/api/parse-options)
|
|
[^8]: See ["Utility Functions"](/docs/api/utilities/)
|
|
[^9]: See ["Array Output" in "Utility Functions"](/docs/api/utilities/array#array-output)
|
|
[^10]: See [`dialog`](https://tauri.app/v1/api/js/dialog/#save) in the Tauri documentation
|
|
[^11]: See [`write` in "Writing Files"](/docs/api/write-options)
|
|
[^12]: See ["Supported Output Formats"](/docs/api/write-options#supported-output-formats)
|
|
[^13]: See [`fs`](https://tauri.app/v1/api/js/fs#writebinaryfile) in the Tauri documentation
|
|
[^14]: See ["Array of Arrays Input" in "Utility Functions"](/docs/api/utilities/array#array-of-arrays-input)
|
|
[^15]: See ["Workbook Helpers" in "Utility Functions"](/docs/api/utilities/wb)
|
|
[^16]: See ["Prerequisites"](https://tauri.app/v1/guides/getting-started/prerequisites) in the Tauri documentation |