# TypeScript Apps

TypeScript mode gives improved development tooling and performance for apps.

## Overview

Highlights for apps in TypeScript mode include:

* Support for modern JavaScript and TypeScript syntax
* Build-time type checking, reducing errors and improving auto-complete
* `async`/`await` support, allowing control over concurrency
* App module support for sharing code across views
* App package support for managing sub-projects within the app codebase
* NPM dependency support for sharing code across apps, or including external libraries

### Asynchronous functions

In standard JourneyApps apps, many functions appear synchronous, even though asynchronous execution occurs behind the scenes.

In TypeScript mode, these functions are all explicitly asynchronous, and return a Promise. It is recommended to use the `await` keyword with these functions.

The database APIs function the same as in CloudCode. See the [async & await documentation](https://docs.journeyapps.com/reference/build/syntax/async-and-await) for details.

Other notable async functions include `fetch`, `journey.dialog`, `actionSheet`, `optionList`.

{% hint style="info" %}
**Tip**

Async functions and Promises are highlighted using *italics* in OXIDE. Use this as a hint for when to use the `await` keyword.
{% endhint %}

### SharedJS / App modules

In standard JourneyApps apps, SharedJS (`app.js` in OXIDE) is available to define global functions, usable from any view. In TypeScript mode, this is replaced with app modules. These are files that can be imported from views.

Functions defined in app modules must be explicitly exported and imported to be used from views. For details, see the [TypeScript handbook](https://www.typescriptlang.org/docs/handbook/modules.html).

By default, app modules are created in a `lib` folder. These can be imported into your views by including `import * as mymodule from "~/lib/mymodule"` at the top of your view TS. See an example below.

#### Example

Send a push notification from a view using a global function from an app module: 

{% code title="lib/index.ts" %}

```typescript
export async function createPushNotification(user, message) {
    var pushNotification = DB.push_notification.create();
    pushNotification.message = message;
    pushNotification.created_at = new Date();
    pushNotification.user(user);
    await pushNotification.save();
}
```

{% endcode %}

{% code title="main.ts" %}

```typescript
import * as shared from "~/lib/index"

// This function is called when the app navigates to this view (using a link)
async function init() {
    // initialize any data here that should be available when the view is shown
    await shared.createPushNotification(user, "A new job was assigned to you");
}
```

{% endcode %}

{% hint style="info" %}
**Tip**

Add the **App Modules** panel (available from the command palette) to your views workspace to make it easier to manage your modules.
{% endhint %}

### App packages

App packages are available as a way to manage custom sub-projects within your application's codebase. Please see [the documentation](https://docs.journeyapps.com/reference/build/extending-your-app-with-custom-code/app-packages/app-packages-overview) for further information.

### Node.js packages

Node.js package dependencies can be added and imported from views.

Some restrictions:

* Types for the package are used during the build and deploy process, but not available during editing in OXIDE yet.
* The package must be compatible with Webpack without using additional loaders or configuration.
* The code runs in the context of a [Web Worker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API). Many standard browser APIs are not available, and some Web Worker APIs are also disabled.
* DOM APIs are not available. It is not possible to add any form of visual components via NPM dependencies yet.
* XMLHttpRequest is not available. The package must use `fetch` instead.

#### Example - Add a Node.js package to your app and import it from a view

See this section about adding/managing external dependencies:

{% content-ref url="../../oxide/editing-and-managing-files/managing-external-dependencies" %}
[managing-external-dependencies](https://docs.journeyapps.com/reference/oxide/editing-and-managing-files/managing-external-dependencies)
{% endcontent-ref %}

After adding the Node.js package to your app it can be imported in any of your app's views. In this example we are formatting a date using [luxon](https://www.npmjs.com/package/luxon):

{% code title="main.ts" %}

```typescript
import {DateTime} from 'luxon'

// This function is called when the app navigates to this view (using a link)
async function init() {
    // initialize any data here that should be available when the view is shown
    var currentDate = DateTime.now().toFormat('MM-dd-yyyy');
}
```

{% endcode %}

## Default TypeScript settings

The default TypeScript version for apps is >= `4.1.3` but is exactly specified within an app's `yarn.lock` file. The default TSConfig settings for apps include the following:

{% code title="tsconfig.json" %}

```json
...
target: 'ES2017',
module: 'ES2015',
esModuleInterop: true,
moduleResolution: 'node',
lib: ['es2018', 'webworker'],
outDir: 'lib',
skipLibCheck: true,
noEmitOnError: true,
baseUrl: '.’
...
```

{% endcode %}

## Migrating an app to TypeScript

1. Commit any changes to the app.
2. Run the **Migrate app to TypeScript** action in OXIDE (via the command palette). Note that this action is only available in advanced IDE mode.

The action does the following automatically:

1. Add package.json and yarn.lock files to the project.
2. Rename view scripts from `.js` -> `.ts`.
3. Move SharedJS to `lib/index.ts`.

No code changes are performed automatically. Once the above migration has completed, code will have to be fixed in each view. At this point, attempting to deploy may result in a large number of build errors.

Generally, OXIDE should pick up a large portion of code changes that must be performed. Some of these have quick-fixes available. Most notably, since many APIs are now async, the code must be updated to include `await` in the relevant places.

Once OXIDE doesn't display any errors in view code anymore, deploy and test the application.