tabris 3.9.0 → 3.10.0-dev.20250206

package/README.md

@@ -36,12 +36,12 @@ The code of the application is loaded dynamically - nothing is precompiled. Java
 
 ## Getting started
 
-To start developing Tabris.js applications, visit [tabrisjs.com](http://tabrisjs.com) and check out the "[Getting Started](https://tabrisjs.com/documentation/latest/getting-started)" guide in the documentation. Be sure to also consult the code [snippets](https://github.com/eclipsesource/tabris-js/tree/master/snippets) in the Tabris.js Developer App (download from the app store for [Android](https://play.google.com/store/apps/details?id=com.eclipsesource.tabrisjs2) and [iOS](https://itunes.apple.com/us/app/tabris.js-2/id1166468326?mt=8)).
+To start developing Tabris.js applications, visit [tabrisjs.com](http://tabrisjs.com) and check out the "[Getting Started](https://tabrisjs.com/documentation/latest/getting-started)" guide in the documentation. Be sure to also consult the code [snippets](https://github.com/eclipsesource/tabris-js/tree/master/snippets) in the Tabris.js Developer App (download from the app store for [Android](https://play.google.com/store/apps/details?id=com.eclipsesource.tabrisjs) and [iOS](https://apps.apple.com/us/app/tabris-js/id939600018)).
 
 ## Extensible
 
 Tabris.js can be extended with [Cordova plugins](https://cordova.apache.org/plugins/) to add support for additional native features. A cordova plugin is also able to directly interface with the native widgets (as can be seen e.g. in the [tabris-plugin-maps](https://github.com/eclipsesource/tabris-plugin-maps)).
- 
+
  Additionally [npm modules](https://www.npmjs.com/) can be used to further enrich the available JS APIs.
 
 Tabris.js also adds support for many key web technologies including:
@@ -50,12 +50,6 @@ Tabris.js also adds support for many key web technologies including:
 - _WebSockets_
 - _localStorage_
 
-
-## Online build
-
-To package your source into a installable app, Tabris.js features an online [build service](https://tabrisjs.com/documentation/latest/build). There is no need to download a huge SDK or use specific hardware for development (e.g. a Mac machine to build for iOS). A [local build](https://tabrisjs.com/documentation/latest/local-build) is also available as an option if more customization is needed.
-
-
 ## Build tabris npm module
 
 Follow these steps if you want to build the tabris module yourself.

package/boot.js

@@ -1,5 +1,5 @@
 /*!
- * Tabris.js 3.9.0
+ * Tabris.js 3.10.0-dev.20250206+1026
  * 
  * Copyright (c) 2014, 2020 EclipseSource Inc.
  * All rights reserved.

package/globals.d.ts

@@ -605,7 +605,7 @@ declare class CryptoKey {
   /**
    * @constant
    */
-  readonly algorithm: {name: 'ECDH', namedCurve: 'P-256'};
+  readonly algorithm: {name: 'ECDH' | 'ECDSA', namedCurve: 'P-256'};
 
 
   extractable: boolean;
@@ -1002,8 +1002,9 @@ declare class SubtleCrypto {
    * @param algorithm
    * @param baseKey
    * @param length
+   * @param options
    */
-  deriveBits(algorithm: {name: 'ECDH', namedCurve: 'P-256', public: CryptoKey}, baseKey: CryptoKey, length: number): Promise<ArrayBuffer>;
+  deriveBits(algorithm: {name: 'ECDH', namedCurve: 'P-256', public: CryptoKey}, baseKey: CryptoKey, length: number, options?: {authPromptTitle?: string, authPromptMessage?: string}): Promise<ArrayBuffer>;
 
   /**
    * Takes a base key and derives an array of bits from it using the HKDF algorithm.
@@ -1021,8 +1022,9 @@ declare class SubtleCrypto {
    * @param derivedKeyAlgorithm
    * @param extractable
    * @param keyUsages
+   * @param options
    */
-  deriveKey(algorithm: {name: 'ECDH', namedCurve: 'P-256', public: CryptoKey}, baseKey: CryptoKey, derivedKeyAlgorithm: {name: 'AES-GCM', length: number}, extractable: boolean, keyUsages: string[]): Promise<CryptoKey>;
+  deriveKey(algorithm: {name: 'ECDH', namedCurve: 'P-256', public: CryptoKey}, baseKey: CryptoKey, derivedKeyAlgorithm: {name: 'AES-GCM', length: number}, extractable: boolean, keyUsages: string[], options?: {authPromptTitle?: string, authPromptMessage?: string}): Promise<CryptoKey>;
 
   /**
    * Takes a base key and derives a secret key from it using the HKDF algorithm.
@@ -1051,21 +1053,27 @@ declare class SubtleCrypto {
   encrypt(algorithm: {name: 'AES-GCM', iv: ArrayBuffer | TypedArray, tagLength?: number}, key: CryptoKey, data: ArrayBuffer | TypedArray): Promise<ArrayBuffer>;
 
   /**
-   * Converts a CryptoKey instances into a portable format. To export a key, the key must have extractable
-   * set to true. Supports the spki format or raw bytes.
+   * Converts `CryptoKey` instances into a portable format. If the key's `extractable` is set to `true`,
+   * returns the raw key material in SPKI format or as raw bytes. If the key's `extractable` is set to
+   * `false`, for ECDSA and ECDH keys returns an opaque handle to the key in the device's trusted
+   * execution environment, and throws for other key formats.
    * @param format
    * @param key
    */
   exportKey(format: 'raw' | 'spki', key: CryptoKey): Promise<ArrayBuffer>;
 
   /**
-   * Generates new keys. Currently only supports the Elliptic Curve Diffie-Hellman (ECDH) algorithm to
-   * generate key pairs.
+   * Generates new keys. Currently only supports the Elliptic Curve Diffie-Hellman (ECDH) and Elliptic
+   * Curve Digital Signature Algorithm (ECDSA) algorithms to generate key pairs. When `extractable` is set
+   * to `true`, the raw key material can be exported using `exportKey`. When `extractable` is set to
+   * `false`, for ECDSA and ECDH keys `exportKey` returns an opaque handle to the key in the device's
+   * trusted execution environment, and throws for other key formats.
    * @param algorithm
    * @param extractable
    * @param keyUsages
+   * @param options
    */
-  generateKey(algorithm: {name: 'ECDH', namedCurve: 'P-256'}, extractable: boolean, keyUsages: string[]): Promise<{privateKey: CryptoKey, publicKey: CryptoKey}>;
+  generateKey(algorithm: {name: 'ECDH' | 'ECDSA', namedCurve: 'P-256'}, extractable: boolean, keyUsages: string[], options?: {usageRequiresAuth?: boolean}): Promise<{privateKey: CryptoKey, publicKey: CryptoKey}>;
 
   /**
    * Takes an external key in a portable format and returns a CryptoKey object that can be used with the
@@ -1076,7 +1084,26 @@ declare class SubtleCrypto {
    * @param extractable
    * @param keyUsages
    */
-  importKey(format: 'spki' | 'pkcs8' | 'raw', keyData: ArrayBuffer | TypedArray, algorithm: {name: 'ECDH', namedCurve: 'P-256'} | {name: 'AES-GCM'} | 'HKDF' | 'AES-GCM', extractable: boolean, keyUsages: string[]): Promise<CryptoKey>;
+  importKey(format: 'spki' | 'pkcs8' | 'raw', keyData: ArrayBuffer | TypedArray, algorithm: {name: 'ECDH' | 'ECDSA', namedCurve: 'P-256'} | {name: 'AES-GCM'} | 'HKDF' | 'AES-GCM', extractable: boolean, keyUsages: string[]): Promise<CryptoKey>;
+
+  /**
+   * Signs the given data. Currently only supports creating ECDSA signatures in DER format.
+   * @param algorithm
+   * @param key
+   * @param data
+   * @param options
+   */
+  sign(algorithm: {name: 'ECDSAinDERFormat', hash: 'SHA-256'}, key: CryptoKey, data: ArrayBuffer | TypedArray, options?: {authPromptTitle?: string, authPromptMessage?: string}): Promise<ArrayBuffer>;
+
+  /**
+   * Verifies the given signature against the data. Currently only supports verifying ECDSA signatures in
+   * DER format.
+   * @param algorithm
+   * @param key
+   * @param signature
+   * @param data
+   */
+  verify(algorithm: {name: 'ECDSAinDERFormat', hash: 'SHA-256'}, key: CryptoKey, signature: ArrayBuffer | TypedArray, data: ArrayBuffer | TypedArray): Promise<boolean>;
 }
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tabris",
-  "version": "3.9.0",
+  "version": "3.10.0-dev.20250206+1026",
   "description": "Mobile apps with native UIs in JavaScript",
   "keywords": [
     "native",

package/tabris.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Tabris.js 3.9.0
+// Type definitions for Tabris.js 3.10.0-dev.20250206+1026
 /// <reference path="globals.d.ts" />
 
 // General helper types

package/tabris.js

@@ -1,5 +1,5 @@
 /*!
- * Tabris.js 3.9.0
+ * Tabris.js 3.10.0-dev.20250206+1026
  * 
  * Copyright (c) 2014, 2020 EclipseSource Inc.
  * All rights reserved.
@@ -5034,7 +5034,7 @@ class Tabris extends NativeObject {
         this.$publishProxies();
     }
     get version() {
-        return '3.9.0';
+        return '3.10.0-dev.20250206+1026';
     }
     get started() {
         return !!this._started;
@@ -10447,7 +10447,7 @@ class _CryptoKey extends NativeObject {
             }));
         });
     }
-    derive(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages) {
+    derive(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages, authPromptTitle, authPromptMessage) {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise$1((onSuccess, onError) => {
                 if (typeof algorithm === 'string') {
@@ -10460,6 +10460,8 @@ class _CryptoKey extends NativeObject {
                         derivedKeyAlgorithm,
                         extractable,
                         keyUsages,
+                        authPromptTitle,
+                        authPromptMessage,
                         onSuccess,
                         onError: wrapErrorCb(onError)
                     });
@@ -10471,6 +10473,8 @@ class _CryptoKey extends NativeObject {
                         derivedKeyAlgorithm,
                         extractable,
                         keyUsages,
+                        authPromptTitle,
+                        authPromptMessage,
                         onSuccess,
                         onError: wrapErrorCb(onError)
                     });
@@ -10481,12 +10485,13 @@ class _CryptoKey extends NativeObject {
             });
         });
     }
-    generate(algorithm, extractable, keyUsages) {
+    generate(algorithm, extractable, keyUsages, usageRequiresAuth) {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise$1((onSuccess, onError) => this._nativeCall('generate', {
                 algorithm,
                 extractable,
                 keyUsages,
+                usageRequiresAuth,
                 onSuccess,
                 onError: wrapErrorCb(onError)
             }));
@@ -10549,12 +10554,12 @@ class SubtleCrypto {
             allowOnlyValues(format, ['spki', 'pkcs8', 'raw'], 'format');
             checkType(getBuffer(keyData), ArrayBuffer, { name: 'keyData' });
             if (typeof algorithm === 'string') {
-                allowOnlyValues(algorithm, ['ECDH', 'AES-GCM', 'HKDF'], 'algorithm');
+                allowOnlyValues(algorithm, ['AES-GCM', 'HKDF'], 'algorithm');
             }
             else {
                 checkType(algorithm, Object, { name: 'algorithm' });
-                allowOnlyValues(algorithm.name, ['ECDH', 'AES-GCM'], 'algorithm.name');
-                if (algorithm.name === 'ECDH') {
+                allowOnlyValues(algorithm.name, ['ECDH', 'ECDSA', 'AES-GCM'], 'algorithm.name');
+                if (algorithm.name === 'ECDH' || algorithm.name === 'ECDSA') {
                     allowOnlyKeys(algorithm, ['name', 'namedCurve']);
                     allowOnlyValues(algorithm.namedCurve, ['P-256'], 'algorithm.namedCurve');
                 }
@@ -10576,17 +10581,18 @@ class SubtleCrypto {
             });
         });
     }
-    deriveBits(algorithm, baseKey, length) {
+    deriveBits(algorithm, baseKey, length, options = {}) {
         return __awaiter(this, arguments, void 0, function* () {
-            if (arguments.length !== 3) {
-                throw new TypeError(`Expected 3 arguments, got ${arguments.length}`);
+            if (arguments.length < 3) {
+                throw new TypeError(`Expected at least 3 arguments, got ${arguments.length}`);
             }
             checkDeriveAlgorithm(algorithm);
             checkType(baseKey, CryptoKey, { name: 'baseKey' });
             checkType(length, Number, { name: 'length' });
+            checkAuthPromptOptions(options);
             const nativeObject = new _CryptoKey();
             try {
-                yield nativeObject.derive(algorithm, baseKey, { length, name: 'AES-GCM' }, true, []);
+                yield nativeObject.derive(algorithm, baseKey, { length, name: 'AES-GCM' }, true, [], options.authPromptTitle, options.authPromptMessage);
                 return new Promise$1((onSuccess, onReject) => this._nativeObject.subtleExportKey('raw', nativeObject, onSuccess, onReject));
             }
             finally {
@@ -10594,10 +10600,10 @@ class SubtleCrypto {
             }
         });
     }
-    deriveKey(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages) {
+    deriveKey(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages, options = {}) {
         return __awaiter(this, arguments, void 0, function* () {
-            if (arguments.length !== 5) {
-                throw new TypeError(`Expected 5 arguments, got ${arguments.length}`);
+            if (arguments.length < 5) {
+                throw new TypeError(`Expected at least 5 arguments, got ${arguments.length}`);
             }
             checkDeriveAlgorithm(algorithm);
             allowOnlyKeys(derivedKeyAlgorithm, ['name', 'length']);
@@ -10606,8 +10612,9 @@ class SubtleCrypto {
             checkType(baseKey, CryptoKey, { name: 'baseKey' });
             checkType(extractable, Boolean, { name: 'extractable' });
             checkType(keyUsages, Array, { name: 'keyUsages' });
+            checkAuthPromptOptions(options);
             const nativeObject = new _CryptoKey();
-            yield nativeObject.derive(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages);
+            yield nativeObject.derive(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages, options.authPromptTitle, options.authPromptMessage);
             return new CryptoKey(nativeObject, {
                 algorithm,
                 extractable,
@@ -10654,18 +10661,28 @@ class SubtleCrypto {
             return new Promise$1((onSuccess, onReject) => this._nativeObject.subtleExportKey(format, key, onSuccess, onReject));
         });
     }
-    generateKey(algorithm, extractable, keyUsages) {
+    generateKey(algorithm, extractable, keyUsages, options) {
         return __awaiter(this, arguments, void 0, function* () {
-            if (arguments.length !== 3) {
-                throw new TypeError(`Expected 3 arguments, got ${arguments.length}`);
+            if (arguments.length < 3) {
+                throw new TypeError(`Expected at least 3 arguments, got ${arguments.length}`);
             }
             allowOnlyKeys(algorithm, ['name', 'namedCurve']);
-            allowOnlyValues(algorithm.name, ['ECDH'], 'algorithm.name');
+            allowOnlyValues(algorithm.name, ['ECDH', 'ECDSA'], 'algorithm.name');
             allowOnlyValues(algorithm.namedCurve, ['P-256'], 'algorithm.namedCurve');
             checkType(extractable, Boolean, { name: 'extractable' });
             checkType(keyUsages, Array, { name: 'keyUsages' });
+            if (options != null) {
+                allowOnlyKeys(options, ['usageRequiresAuth']);
+                if ('usageRequiresAuth' in options) {
+                    checkType(options.usageRequiresAuth, Boolean, { name: 'options.usageRequiresAuth' });
+                }
+                if (options.usageRequiresAuth && (extractable || !algorithm.name.startsWith('EC'))) {
+                    throw new TypeError('options.usageRequiresAuth is only supported for non-extractable EC keys');
+                }
+            }
+            const usageRequiresAuth = options === null || options === void 0 ? void 0 : options.usageRequiresAuth;
             const nativeObject = new _CryptoKey();
-            yield nativeObject.generate(algorithm, extractable, keyUsages);
+            yield nativeObject.generate(algorithm, extractable, keyUsages, usageRequiresAuth);
             const nativePrivate = new _CryptoKey(nativeObject, 'private');
             const nativePublic = new _CryptoKey(nativeObject, 'public');
             return {
@@ -10674,6 +10691,36 @@ class SubtleCrypto {
             };
         });
     }
+    sign(algorithm, key, data, options = {}) {
+        return __awaiter(this, arguments, void 0, function* () {
+            if (arguments.length < 3) {
+                throw new TypeError(`Expected at least 3 arguments, got ${arguments.length}`);
+            }
+            allowOnlyKeys(algorithm, ['name', 'hash']);
+            allowOnlyValues(algorithm.name, ['ECDSAinDERFormat'], 'algorithm.name');
+            allowOnlyValues(algorithm.hash, ['SHA-256'], 'algorithm.hash');
+            checkType(key, CryptoKey, { name: 'key' });
+            checkType(algorithm.name, String, { name: 'algorithm.name' });
+            checkType(algorithm.hash, String, { name: 'algorithm.hash' });
+            checkType(getBuffer(data), ArrayBuffer, { name: 'data' });
+            checkAuthPromptOptions(options);
+            return new Promise$1((onSuccess, onError) => this._nativeObject.subtleSign(algorithm, key, data, options.authPromptTitle, options.authPromptMessage, onSuccess, onError));
+        });
+    }
+    verify(algorithm, key, signature, data) {
+        return __awaiter(this, arguments, void 0, function* () {
+            if (arguments.length !== 4) {
+                throw new TypeError(`Expected 4 arguments, got ${arguments.length}`);
+            }
+            allowOnlyKeys(algorithm, ['name', 'hash']);
+            allowOnlyValues(algorithm.name, ['ECDSAinDERFormat'], 'algorithm.name');
+            allowOnlyValues(algorithm.hash, ['SHA-256'], 'algorithm.hash');
+            checkType(key, CryptoKey, { name: 'key' });
+            checkType(getBuffer(signature), ArrayBuffer, { name: 'signature' });
+            checkType(getBuffer(data), ArrayBuffer, { name: 'data' });
+            return new Promise$1((onSuccess, onReject) => this._nativeObject.subtleVerify(algorithm, key, signature, data, onSuccess, onReject));
+        });
+    }
 }
 class NativeCrypto extends NativeObject {
     static getInstance() {
@@ -10743,6 +10790,35 @@ class NativeCrypto extends NativeObject {
             onError: (reason) => onError(new Error(String(reason)))
         });
     }
+    subtleSign(algorithm, key, data, authPromptTitle, authPromptMessage, onSuccess, onError) {
+        this._nativeCall('subtleSign', {
+            algorithm,
+            key: getCid(key),
+            data: getBuffer(data),
+            authPromptTitle,
+            authPromptMessage,
+            onSuccess,
+            onError: (reason) => onError(new Error(String(reason)))
+        });
+    }
+    subtleVerify(algorithm, key, signature, data, onSuccess, onError) {
+        this._nativeCall('subtleVerify', {
+            algorithm,
+            key: getCid(key),
+            signature: getBuffer(signature),
+            data: getBuffer(data),
+            onSuccess,
+            onError: (reason) => onError(new Error(String(reason)))
+        });
+    }
+}
+function checkAuthPromptOptions(options) {
+    if ('authPromptTitle' in options) {
+        checkType(options.authPromptTitle, String, { name: 'options.authPromptTitle' });
+    }
+    if ('authPromptMessage' in options) {
+        checkType(options.authPromptMessage, String, { name: 'options.authPromptMessage' });
+    }
 }
 function checkDeriveAlgorithm(algorithm) {
     if (algorithm === 'HKDF') {