Skip to main content

Data in Quasar Apps

Quasar is a VueJS framework for building iOS and Android apps with the Cordova platform.

SheetJS is a JavaScript library for reading and writing data from spreadsheets.

This demo uses Quasar and SheetJS to process data and generate spreadsheets. We'll explore how to load SheetJS in an Quasar app and use Quasar and Cordova features to extract data from, and write data to, spreadsheets on the device.

The "Demo" creates an app that looks like the screenshots below:

iOSAndroid

iOS screenshot

Android screenshot

Tested Deployments

This demo was tested in the following environments:

OSTypeDeviceQuasarDate
Android 34SimPixel 3a2.14.12023-12-04
iOS 17.0.1SimiPhone SE (3rd gen)2.14.12023-12-04

Integration Details

The SheetJS NodeJS Module can be imported from any component or script in the app.

This demo will use the Quasar ViteJS starter project with VueJS and Cordova. The starter places the backing Cordova project in the src-cordova folder.

The complete solution uses cordova-plugin-file for file operations. It can be installed from the Cordova folder:

cd src-cordova
cordova plugin add cordova-plugin-file
cd ..

Reading data

The QFile1 component presents an API reminiscent of File Input elements:

<q-file label="Load File" filled label-color="orange" @input="updateFile"/>

When binding to the input element, the callback receives an Event object. Using standard DOM operations, the file data can be pulled into an ArrayBuffer and parsed using the SheetJS read method2. read returns a workbook3 object that holds data and metadata for each worksheet.

This snippet reads a workbook, pulls the first worksheet, generates an array of objects using the SheetJS sheet_to_json4 method, and updates state:

import { read } from 'xlsx';

// assuming `todos` is a standard VueJS `ref`
async function updateFile(v) { try {
// `v.target.files[0]` is the desired file object
const files = (v.target as HTMLInputElement).files;
if(!files || files.length == 0) return;

// read first file
const wb = read(await files[0].arrayBuffer());

// get data of first worksheet as an array of objects
const data = utils.sheet_to_json(wb.Sheets[wb.SheetNames[0]]);

// update state
todos.value = data.map(row => ({id: row.Index, content: row.Name}));

} catch(e) { console.log(e); } }

Writing data

Starting from an array of objects, the SheetJS json_to_sheet method5 generates a SheetJS worksheet object. The book_append_sheet and book_new helper functions6 create a SheetJS workbook object that can be exported:

import { utils } from 'xlsx';

// assuming `todos` is a VueJS ref whose value is an array of objects
const ws = utils.json_to_sheet(todos.value);
const wb = utils.book_new();
utils.book_append_sheet(wb, ws, "SheetJSQuasar");

The SheetJS write function7 with the option type: "buffer" will generate Uint8Array objects that can be converted to blobs and exported:

import { write } from 'xlsx';

// on iOS and android, `XLSX.write` with type "buffer" returns a `Uint8Array`
const u8: Uint8Array = write(wb, {bookType: "xlsx", type: "buffer"});

The cordova-plugin-file API writes the data to the filesystem. The code uses the File and Directory Entries API8:

// Request filesystem access for persistent storage
window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
// Request a handle to "SheetJSQuasar.xlsx", making a new file if necessary
fs.root.getFile("SheetJSQuasar.xlsx", {create: true}, entry => {
// Request a FileWriter for writing data
entry.createWriter(writer => {
// The FileWriter API needs an actual Blob
const data = new Blob([u8], {type: "application/vnd.ms-excel"});
// This callback is called if the write is successful
writer.onwriteend = () => {
// TODO: show a dialog
};
// writer.onerror will be invoked if there is an error in writing

// write the data
writer.write(data);
});
});
});

Demo

The demo draws from the ViteJS example. Familiarity with VueJS and TypeScript is assumed.

0) Ensure all of the dependencies are installed. Install the CLI globally:

npm i -g @quasar/cli cordova

(you may need to run sudo npm i -g if there are permission issues)

1) Create a new app:

npm init quasar

When prompted:

  • "What would you like to build?": App with Quasar CLI
  • "Project folder": SheetJSQuasar
  • "Pick Quasar version": Quasar v2 (Vue 3 | latest and greatest)
  • "Pick script type": Typescript
  • "Pick Quasar App CLI variant": Quasar App CLI with Vite
  • "Package name": (just press enter, it will use the default sheetjsquasar
  • "Project product name": SheetJSQuasar
  • "Project description": SheetJS + Quasar
  • "Author": (just press enter, it will use your git config settings)
  • "Pick a Vue component style": Composition API
  • "Pick your CSS preprocessor": None
  • "Check the features needed for your project": Deselect everything
  • "Install project dependencies": No

2) Install dependencies:

cd SheetJSQuasar
npm i
npm i --save https://cdn.sheetjs.com/xlsx-0.20.1/xlsx-0.20.1.tgz

3) Set up Cordova:

quasar mode add cordova

When prompted, enter the app id org.sheetjs.quasar.

It will create a new src-cordova folder. Continue in that folder:

cd src-cordova
cordova platform add ios
cordova plugin add cordova-plugin-wkwebview-engine
cordova plugin add cordova-plugin-file

If there is an error Could not load API for iOS project, it needs to be reset:

cordova platform rm ios
cordova platform add ios
cordova plugin add cordova-plugin-file

Return to the project directory:

cd ..

11) Enable file sharing and make the documents folder visible in the iOS app. The following lines must be added to src-cordova/platforms/ios/SheetJSQuasar/SheetJSQuasar-Info.plist:

src-cordova/platforms/ios/SheetJSQuasar/SheetJSQuasar-Info.plist (add to file)
<plist version="1.0">
<dict>
<key>UIFileSharingEnabled</key>
<true/>
<key>LSSupportsOpeningDocumentsInPlace</key>
<true/>
<key>CFBundleDevelopmentRegion</key>

(The root element of the document is plist and it contains one dict child)

5) Start the development server:

quasar dev -m ios

If the app is blank or not refreshing, delete the app and close the simulator, then restart the development process.

6) Add the Dialog plugin to quasar.config.js:

quasar.config.js
    framework: {
config: {},
// ...
// Quasar plugins
plugins: ['Dialog']
},

7) In the template section of src/pages/IndexPage.vue, replace the example with a Table, Save button and Load file picker component:

src/pages/IndexPage.vue
<template>
<q-page class="row items-center justify-evenly">
<q-table :rows="todos" />
<q-btn-group>
<q-file label="Load File" filled label-color="orange" @input="updateFile"/>
<q-btn label="Save File" @click="saveFile" />
</q-btn-group>
</q-page>
</template>

This uses two functions that should be added to the component script:

src/pages/IndexPage.vue
    const meta = ref<Meta>({
totalCount: 1200
});
function saveFile() {
}
async function updateFile(v: Event) {
}
return { todos, meta, saveFile, updateFile };
}
});

The app should now show two buttons at the bottom:

Quasar Step 6

If the app is blank or not refreshing, delete the app and close the simulator, then restart the development process.

8) Wire up the updateFile function:

src/pages/IndexPage.vue
import { defineComponent, ref } from 'vue';
import { read, write, utils } from 'xlsx';
import { useQuasar } from 'quasar';

export default defineComponent({
// ...
const $q = useQuasar();
function dialogerr(e: Error) { $q.dialog({title: "Error!", message: e.message || String(e)}); }
function saveFile() {
}
async function updateFile(v: Event) {
try {
const files = (v.target as HTMLInputElement).files;
if(!files || files.length == 0) return;

const wb = read(await files[0].arrayBuffer());

const data = utils.sheet_to_json<any>(wb.Sheets[wb.SheetNames[0]]);
todos.value = data.map(row => ({id: row.Index, content: row.Name}));
} catch(e) { dialogerr(e); }
}

To test that reading works:

  • Download https://sheetjs.com/pres.numbers
  • In the simulator, click the Home icon to return to the home screen
  • Click on the "Files" icon
  • Click and drag pres.numbers from a Finder window into the simulator.

Quasar Step 7 save file

  • Make sure "On My iPhone" is highlighted and select "Save"
  • Click the Home icon again then select the SheetJSQuasar app
  • Click the "Load" button, then select "Choose File" and select pres:

Quasar Step 7 load file

Once selected, the screen should refresh with new contents.

9) Wire up the saveFile function:

src/pages/IndexPage.vue
    function saveFile() {
/* generate workbook from state */
const ws = utils.json_to_sheet(todos.value);
const wb = utils.book_new();
utils.book_append_sheet(wb, ws, "SheetJSQuasar");
const u8: Uint8Array = write(wb, {bookType: "xlsx", type: "buffer"});
const dir: string = $q.cordova.file.documentsDirectory || $q.cordova.file.externalApplicationStorageDirectory;

/* save to file */
window.requestFileSystem(window.PERSISTENT, 0, function(fs) {
try {
fs.root.getFile("SheetJSQuasar.xlsx", {create: true}, entry => {
const msg = `File stored at ${dir} ${entry.fullPath}`;
entry.createWriter(writer => {
try {
const data = new Blob([u8], {type: "application/vnd.ms-excel"});
writer.onwriteend = () => {
try {
$q.dialog({title: "Success!", message: msg});
} catch(e) { dialogerr(e); }
};
writer.onerror = dialogerr;
writer.write(data);
} catch(e) { dialogerr(e); }
}, dialogerr);
}, dialogerr);
} catch(e) { dialogerr(e) }
}, dialogerr);
}

The page should revert to the old contents.

To test that writing works:

  • Click "Save File". You will see a popup with a location:

Quasar Step 8

  • Find the file and verify the contents are correct. Run in a new terminal:
find ~/Library/Developer/CoreSimulator -name SheetJSQuasar.xlsx |
while read x; do echo "$x"; npx xlsx-cli "$x"; done

Since the contents reverted, you should see

SheetJSQuasar
id,content
1,ct1
2,ct2
3,ct3
4,ct4
5,ct5
  • Use "Load File" to select pres.numbers again. Wait for the app to refresh.

  • Click "Save File", then re-run the command:

find ~/Library/Developer/CoreSimulator -name SheetJSQuasar.xlsx |
while read x; do echo "$x"; npx xlsx-cli "$x"; done

The contents from pres.numbers should show up now, with a new header row:

SheetJSQuasar
id,content
42,Bill Clinton
43,GeorgeW Bush
44,Barack Obama
45,Donald Trump
46,Joseph Biden

Android

10) Create the Android project:

cd src-cordova
cordova platform add android
cd ..

11) Start the simulator:

quasar dev -m android

To test that reading works:

  • Click and drag pres.numbers from a Finder window into the simulator.
  • Tap "Load", tap the icon, tap "Downloads" and select pres.numbers.

To test that writing works:

  • Tap "Save File". You will see a popup with a location.

  • Pull the file from the simulator and verify the contents:

adb exec-out run-as org.sheetjs.quasar cat files/files/SheetJSQuasar.xlsx > /tmp/SheetJSQuasar.xlsx
npx xlsx-cli /tmp/SheetJSQuasar.xlsx

  1. See "File Picker" in the Quasar documentation.
  2. See read in "Reading Files"
  3. See "SheetJS Data Model" for more details on workbooks, worksheets, and other concepts.
  4. See sheet_to_json in "Utilities"
  5. See json_to_sheet in "Utilities"
  6. See "Workbook Helpers" in "Utilities" for details on book_new and book_append_sheet.
  7. See write in "Writing Files"
  8. See requestFileSystem in the MDN Web Docs for more details.