@novasamatech/host-container 0.5.3-0 → 0.5.4-0

package/dist/constants.d.ts

@@ -0,0 +1 @@
+export declare const WEBVIEW_HOST_PORT_NAME = "__HOST_API_PORT__";

package/dist/constants.js

@@ -0,0 +1 @@
+export const WEBVIEW_HOST_PORT_NAME = '__HOST_API_PORT__';

package/dist/createContainer.js

@@ -1,4 +1,4 @@
-import { ChatContactRegistrationErr, ChatMessagePostingErr, CreateProofErr, CreateTransactionErr, GenericError, PermissionErr, RequestCredentialsErr, SigningErr, StatementProofErr, StorageErr, assertEnumVariant, createTransport, enumValue, isEnumVariant, resultErr, resultOk, } from '@novasamatech/host-api';
+import { ChatMessagePostingErr, ChatRoomRegistrationErr, CreateProofErr, CreateTransactionErr, GenericError, RequestCredentialsErr, SigningErr, StatementProofErr, StorageErr, assertEnumVariant, createTransport, enumValue, isEnumVariant, resultErr, resultOk, } from '@novasamatech/host-api';
 import { err, errAsync, ok, okAsync } from 'neverthrow';
 const UNSUPPORTED_MESSAGE_FORMAT_ERROR = 'Unsupported message format';
 function guardVersion(value, tag, error) {
@@ -18,6 +18,7 @@ export function createContainer(provider) {
     }
     return {
         handleFeature(handler) {
+            init();
             return transport.handleRequest('feature', async (message) => {
                 const version = 'v1';
                 const error = new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
@@ -28,19 +29,9 @@ export function createContainer(provider) {
                     .unwrapOr(enumValue(version, resultErr(error)));
             });
         },
-        handlePermissionRequest(handler) {
-            return transport.handleRequest('permission_request', async (message) => {
-                const version = 'v1';
-                const error = new PermissionErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
-                return guardVersion(message, version, error)
-                    .asyncMap(async (params) => handler(params, { ok: (okAsync), err: (errAsync) }))
-                    .andThen(r => r.map(r => enumValue(version, resultOk(r))))
-                    .orElse(r => ok(enumValue(version, resultErr(r))))
-                    .unwrapOr(enumValue(version, resultErr(error)));
-            });
-        },
-        handleStorageRead(handler) {
-            return transport.handleRequest('storage_read', async (message) => {
+        handleLocalStorageRead(handler) {
+            init();
+            return transport.handleRequest('local_storage_read', async (message) => {
                 const version = 'v1';
                 const error = new StorageErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
                 return guardVersion(message, version, error)
@@ -50,8 +41,9 @@ export function createContainer(provider) {
                     .unwrapOr(enumValue(version, resultErr(error)));
             });
         },
-        handleStorageWrite(handler) {
-            return transport.handleRequest('storage_write', async (message) => {
+        handleLocalStorageWrite(handler) {
+            init();
+            return transport.handleRequest('local_storage_write', async (message) => {
                 const version = 'v1';
                 const error = new StorageErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
                 return guardVersion(message, version, error)
@@ -61,8 +53,9 @@ export function createContainer(provider) {
                     .unwrapOr(enumValue(version, resultErr(error)));
             });
         },
-        handleStorageClear(handler) {
-            return transport.handleRequest('storage_clear', async (params) => {
+        handleLocalStorageClear(handler) {
+            init();
+            return transport.handleRequest('local_storage_clear', async (params) => {
                 const version = 'v1';
                 const error = new StorageErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
                 return guardVersion(params, version, error)
@@ -73,6 +66,7 @@ export function createContainer(provider) {
             });
         },
         handleAccountGet(handler) {
+            init();
             return transport.handleRequest('account_get', async (params) => {
                 const version = 'v1';
                 const error = new RequestCredentialsErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
@@ -84,6 +78,7 @@ export function createContainer(provider) {
             });
         },
         handleAccountGetAlias(handler) {
+            init();
             return transport.handleRequest('account_get_alias', async (params) => {
                 const version = 'v1';
                 const error = new RequestCredentialsErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
@@ -95,6 +90,7 @@ export function createContainer(provider) {
             });
         },
         handleAccountCreateProof(handler) {
+            init();
             return transport.handleRequest('account_create_proof', async (params) => {
                 const version = 'v1';
                 const error = new CreateProofErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
@@ -106,6 +102,7 @@ export function createContainer(provider) {
             });
         },
         handleGetNonProductAccounts(handler) {
+            init();
             return transport.handleRequest('get_non_product_accounts', async (params) => {
                 const version = 'v1';
                 const error = new RequestCredentialsErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
@@ -117,6 +114,7 @@ export function createContainer(provider) {
             });
         },
         handleCreateTransaction(handler) {
+            init();
             return transport.handleRequest('create_transaction', async (params) => {
                 const version = 'v1';
                 const error = new CreateTransactionErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
@@ -128,6 +126,7 @@ export function createContainer(provider) {
             });
         },
         handleCreateTransactionWithNonProductAccount(handler) {
+            init();
             return transport.handleRequest('create_transaction_with_non_product_account', async (params) => {
                 const version = 'v1';
                 const error = new CreateTransactionErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
@@ -139,6 +138,7 @@ export function createContainer(provider) {
             });
         },
         handleSignRaw(handler) {
+            init();
             return transport.handleRequest('sign_raw', async (params) => {
                 const version = 'v1';
                 const error = new SigningErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
@@ -150,6 +150,7 @@ export function createContainer(provider) {
             });
         },
         handleSignPayload(handler) {
+            init();
             return transport.handleRequest('sign_payload', async (params) => {
                 const version = 'v1';
                 const error = new SigningErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
@@ -160,10 +161,11 @@ export function createContainer(provider) {
                     .unwrapOr(enumValue(version, resultErr(error)));
             });
         },
-        handleChatCreateContact(handler) {
-            return transport.handleRequest('chat_create_contact', async (params) => {
+        handleChatCreateRoom(handler) {
+            init();
+            return transport.handleRequest('chat_create_room', async (params) => {
                 const version = 'v1';
-                const error = new ChatContactRegistrationErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
+                const error = new ChatRoomRegistrationErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
                 return guardVersion(params, version, error)
                     .asyncMap(async (params) => handler(params, { ok: (okAsync), err: (errAsync) }))
                     .andThen(r => r.map(r => enumValue(version, resultOk(r))))
@@ -171,7 +173,20 @@ export function createContainer(provider) {
                     .unwrapOr(enumValue(version, resultErr(error)));
             });
         },
+        handleChatListSubscribe(handler) {
+            init();
+            return transport.handleSubscription('chat_list_subscribe', (params, send, interrupt) => {
+                const version = 'v1';
+                return guardVersion(params, version, null)
+                    .map(params => handler(params, payload => send(enumValue(version, payload)), interrupt))
+                    .orTee(interrupt)
+                    .unwrapOr(() => {
+                    /* empty */
+                });
+            });
+        },
         handleChatPostMessage(handler) {
+            init();
             return transport.handleRequest('chat_post_message', async (params) => {
                 const version = 'v1';
                 const error = new ChatMessagePostingErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
@@ -183,6 +198,7 @@ export function createContainer(provider) {
             });
         },
         handleChatActionSubscribe(handler) {
+            init();
             return transport.handleSubscription('chat_action_subscribe', (params, send, interrupt) => {
                 const version = 'v1';
                 return guardVersion(params, version, null)
@@ -193,7 +209,32 @@ export function createContainer(provider) {
                 });
             });
         },
+        handleStatementStoreQuery(handler) {
+            init();
+            return transport.handleRequest('statement_store_query', async (params) => {
+                const version = 'v1';
+                const error = new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
+                return guardVersion(params, version, error)
+                    .asyncMap(async (params) => handler(params, { ok: (okAsync), err: (errAsync) }))
+                    .andThen(r => r.map(r => enumValue(version, resultOk(r))))
+                    .orElse(r => ok(enumValue(version, resultErr(r))))
+                    .unwrapOr(enumValue(version, resultErr(error)));
+            });
+        },
+        handleStatementStoreSubscribe(handler) {
+            init();
+            return transport.handleSubscription('statement_store_subscribe', (params, send, interrupt) => {
+                const version = 'v1';
+                return guardVersion(params, version, null)
+                    .map(params => handler(params, payload => send(enumValue(version, payload)), interrupt))
+                    .orTee(interrupt)
+                    .unwrapOr(() => {
+                    /* empty */
+                });
+            });
+        },
         handleStatementStoreCreateProof(handler) {
+            init();
             return transport.handleRequest('statement_store_create_proof', async (params) => {
                 const version = 'v1';
                 const error = new StatementProofErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
@@ -204,6 +245,18 @@ export function createContainer(provider) {
                     .unwrapOr(enumValue(version, resultErr(error)));
             });
         },
+        handleStatementStoreSubmit(handler) {
+            init();
+            return transport.handleRequest('statement_store_submit', async (params) => {
+                const version = 'v1';
+                const error = new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
+                return guardVersion(params, version, error)
+                    .asyncMap(async (params) => handler(params, { ok: (okAsync), err: (errAsync) }))
+                    .andThen(r => r.map(r => enumValue(version, resultOk(r))))
+                    .orElse(r => ok(enumValue(version, resultErr(r))))
+                    .unwrapOr(enumValue(version, resultErr(error)));
+            });
+        },
         handleJsonRpcMessageSubscribe(genesisHash, provider) {
             init();
             return transport.handleSubscription('jsonrpc_message_subscribe', (params, send) => {

package/dist/createWebviewProvider.d.ts

@@ -0,0 +1,8 @@
+import type { Logger, Provider } from '@novasamatech/host-api';
+import type { WebviewTag } from 'electron';
+type Params = {
+    webview: WebviewTag;
+    logger?: Logger;
+};
+export declare function createWebviewProvider({ webview, logger }: Params): Provider;
+export {};

package/dist/createWebviewProvider.js

@@ -0,0 +1,99 @@
+import { createDefaultLogger } from '@novasamatech/host-api';
+import { nanoid } from 'nanoid';
+import { WEBVIEW_HOST_PORT_NAME } from './constants.js';
+function hasWindow() {
+    try {
+        return typeof window !== 'undefined';
+    }
+    catch {
+        return false;
+    }
+}
+function isValidMessage(event, sourceEnv, currentEnv) {
+    return (event.source !== currentEnv &&
+        event.source === sourceEnv &&
+        event.data &&
+        event.data.constructor.name === 'Uint8Array');
+}
+export function createWebviewProvider({ webview, logger }) {
+    let disposed = false;
+    let subscribed = false;
+    let port = null;
+    const subscribers = new Set();
+    const webviewPromise = new Promise((resolve, reject) => {
+        webview.addEventListener('did-fail-load', e => {
+            reject(new Error(e.errorDescription));
+        });
+        webview.addEventListener('dom-ready', async () => {
+            const { port1, port2 } = new MessageChannel();
+            const portInitMessage = `PORT_INIT_${nanoid(12)}`;
+            port = port1;
+            await webview
+                .executeJavaScript(`
+            window.addEventListener('message', e => {
+              if (e.data === '${portInitMessage}') {
+                const port = e.ports[0];
+                if (port) {
+                  window['${WEBVIEW_HOST_PORT_NAME}'] = port;
+                }
+              }
+            });
+         `)
+                .catch(reject);
+            // @ts-expect-error contentWindow is undefined somehow
+            webview.contentWindow.postMessage(portInitMessage, '*', [port2]);
+            resolve(port);
+        });
+    });
+    function waitForWebview(callback) {
+        if (port) {
+            return callback(port);
+        }
+        webviewPromise.then(callback);
+    }
+    const messageHandler = (event) => {
+        if (disposed)
+            return;
+        waitForWebview(port => {
+            if (disposed)
+                return;
+            if (!isValidMessage(event, port, window))
+                return;
+            for (const subscriber of subscribers) {
+                subscriber(event.data);
+            }
+        });
+    };
+    return {
+        logger: logger ?? createDefaultLogger(),
+        isCorrectEnvironment() {
+            return hasWindow();
+        },
+        postMessage(message) {
+            if (disposed)
+                return;
+            waitForWebview(port => {
+                if (disposed)
+                    return;
+                port.postMessage(message, [message.buffer]);
+            });
+        },
+        subscribe(callback) {
+            if (!subscribed && port) {
+                subscribed = true;
+                port.addEventListener('message', messageHandler);
+            }
+            subscribers.add(callback);
+            return () => {
+                subscribers.delete(callback);
+            };
+        },
+        dispose() {
+            disposed = true;
+            subscribers.clear();
+            if (port) {
+                port.removeEventListener('message', messageHandler);
+            }
+        },
+    };
+}

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export { createWebviewProvider } from './createWebviewProvider.js';
 export { createIframeProvider } from './createIframeProvider.js';
 export { createContainer } from './createContainer.js';
 export type { Container } from './types.js';

package/dist/index.js

@@ -1,2 +1,3 @@
+export { createWebviewProvider } from './createWebviewProvider.js';
 export { createIframeProvider } from './createIframeProvider.js';
 export { createContainer } from './createContainer.js';

package/dist/types.d.ts

@@ -51,10 +51,9 @@ type InferSubscribeHandler<V extends string, T extends VersionedProtocolSubscrip
 type InferHandler<V extends string, T extends VersionedProtocolRequest | VersionedProtocolSubscription> = T extends VersionedProtocolRequest ? InferRequestHandler<V, T> : T extends VersionedProtocolSubscription ? InferSubscribeHandler<V, T> : never;
 export type Container = {
     handleFeature: InferHandler<'v1', HostApiProtocol['feature']>;
-    handlePermissionRequest: InferHandler<'v1', HostApiProtocol['permission_request']>;
-    handleStorageRead: InferHandler<'v1', HostApiProtocol['storage_read']>;
-    handleStorageWrite: InferHandler<'v1', HostApiProtocol['storage_write']>;
-    handleStorageClear: InferHandler<'v1', HostApiProtocol['storage_clear']>;
+    handleLocalStorageRead: InferHandler<'v1', HostApiProtocol['local_storage_read']>;
+    handleLocalStorageWrite: InferHandler<'v1', HostApiProtocol['local_storage_write']>;
+    handleLocalStorageClear: InferHandler<'v1', HostApiProtocol['local_storage_clear']>;
     handleAccountGet: InferHandler<'v1', HostApiProtocol['account_get']>;
     handleAccountGetAlias: InferHandler<'v1', HostApiProtocol['account_get_alias']>;
     handleAccountCreateProof: InferHandler<'v1', HostApiProtocol['account_create_proof']>;
@@ -63,10 +62,14 @@ export type Container = {
     handleCreateTransactionWithNonProductAccount: InferHandler<'v1', HostApiProtocol['create_transaction_with_non_product_account']>;
     handleSignRaw: InferHandler<'v1', HostApiProtocol['sign_raw']>;
     handleSignPayload: InferHandler<'v1', HostApiProtocol['sign_payload']>;
-    handleChatCreateContact: InferHandler<'v1', HostApiProtocol['chat_create_contact']>;
+    handleChatCreateRoom: InferHandler<'v1', HostApiProtocol['chat_create_room']>;
+    handleChatListSubscribe: InferHandler<'v1', HostApiProtocol['chat_list_subscribe']>;
     handleChatPostMessage: InferHandler<'v1', HostApiProtocol['chat_post_message']>;
     handleChatActionSubscribe: InferHandler<'v1', HostApiProtocol['chat_action_subscribe']>;
+    handleStatementStoreQuery: InferHandler<'v1', HostApiProtocol['statement_store_query']>;
+    handleStatementStoreSubscribe: InferHandler<'v1', HostApiProtocol['statement_store_subscribe']>;
     handleStatementStoreCreateProof: InferHandler<'v1', HostApiProtocol['statement_store_create_proof']>;
+    handleStatementStoreSubmit: InferHandler<'v1', HostApiProtocol['statement_store_submit']>;
     handleJsonRpcMessageSubscribe: (params: WithVersion<'v1', Value<HostApiProtocol['jsonrpc_message_subscribe']['start']>>, provider: JsonRpcProvider) => VoidFunction;
     isReady(): Promise<boolean>;
     dispose(): void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-container",
   "type": "module",
-  "version": "0.5.3-0",
+  "version": "0.5.4-0",
   "description": "Host container for hosting and managing products within the Polkadot ecosystem.",
   "license": "Apache-2.0",
   "repository": {
@@ -28,7 +28,11 @@
   "dependencies": {
     "@polkadot-api/utils": "^0.2.0",
     "@polkadot-api/json-rpc-provider": "^0.0.4",
-    "@novasamatech/host-api": "0.5.3-0"
+    "@novasamatech/host-api": "0.5.4-0",
+    "nanoid": "5.1.6"
+  },
+  "devDependencies": {
+    "electron": "^40.1.0"
   },
   "publishConfig": {
     "access": "public"