@novasamatech/host-api 0.6.5 → 0.6.6-1

package/dist/index.d.ts

@@ -23,5 +23,5 @@ export { RemotePermissionRequest } from './protocol/v1/remotePermission.js';
 export { PushNotification } from './protocol/v1/notification.js';
 export { NavigateToErr } from './protocol/v1/navigation.js';
 export { PreimageKey, PreimageSubmitErr, PreimageValue } from './protocol/v1/preimage.js';
-export { CustomRendererNode } from './protocol/v1/customRenderer.js';
+export { Arrangement, BorderStyle, ButtonVariant, ColorToken, ContentAlignment, CustomRendererNode, Dimensions, HorizontalAlignment, Modifier, Shape, Size, TypographyStyle, VerticalAlignment, } from './protocol/v1/customRenderer.js';
 export { ChainHeadEvent, ChainHeadFollowV1_start, OperationStartedResult, RuntimeType, StorageQueryItem, StorageQueryType, StorageResultItem, TransactionBroadcastV1_request, TransactionBroadcastV1_response, TransactionStopV1_request, TransactionStopV1_response, } from './protocol/v1/chainInteraction.js';

package/dist/index.js

@@ -18,5 +18,5 @@ export { RemotePermissionRequest } from './protocol/v1/remotePermission.js';
 export { PushNotification } from './protocol/v1/notification.js';
 export { NavigateToErr } from './protocol/v1/navigation.js';
 export { PreimageKey, PreimageSubmitErr, PreimageValue } from './protocol/v1/preimage.js';
-export { CustomRendererNode } from './protocol/v1/customRenderer.js';
+export { Arrangement, BorderStyle, ButtonVariant, ColorToken, ContentAlignment, CustomRendererNode, Dimensions, HorizontalAlignment, Modifier, Shape, Size, TypographyStyle, VerticalAlignment, } from './protocol/v1/customRenderer.js';
 export { ChainHeadEvent, ChainHeadFollowV1_start, OperationStartedResult, RuntimeType, StorageQueryItem, StorageQueryType, StorageResultItem, TransactionBroadcastV1_request, TransactionBroadcastV1_response, TransactionStopV1_request, TransactionStopV1_response, } from './protocol/v1/chainInteraction.js';

package/dist/protocol/v1/permission.d.ts

@@ -1,49 +1,17 @@
-export declare const PermissionErr: [import("scale-ts").Encoder<(Error & {
-    name: "PermissionErr::Rejected";
-    className: string;
-    payload: undefined;
-}) | (Error & {
-    name: "PermissionErr::Unknown";
-    className: string;
-    payload: {
+export declare const PermissionErr: [import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<undefined, "PermissionErr::Rejected"> | import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "PermissionErr::Unknown">>, import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<undefined, "PermissionErr::Rejected"> | import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "PermissionErr::Unknown">>] & {
+    enc: import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<undefined, "PermissionErr::Rejected"> | import("@novasamatech/scale").CodecError<{
         reason: string;
-    };
-})>, import("scale-ts").Decoder<(Error & {
-    name: "PermissionErr::Rejected";
-    className: string;
-    payload: undefined;
-}) | (Error & {
-    name: "PermissionErr::Unknown";
-    className: string;
-    payload: {
+    }, "PermissionErr::Unknown">>;
+    dec: import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<undefined, "PermissionErr::Rejected"> | import("@novasamatech/scale").CodecError<{
         reason: string;
-    };
-})>] & {
-    enc: import("scale-ts").Encoder<(Error & {
-        name: "PermissionErr::Rejected";
-        className: string;
-        payload: undefined;
-    }) | (Error & {
-        name: "PermissionErr::Unknown";
-        className: string;
-        payload: {
-            reason: string;
-        };
-    })>;
-    dec: import("scale-ts").Decoder<(Error & {
-        name: "PermissionErr::Rejected";
-        className: string;
-        payload: undefined;
-    }) | (Error & {
-        name: "PermissionErr::Unknown";
-        className: string;
-        payload: {
-            reason: string;
-        };
-    })>;
+    }, "PermissionErr::Unknown">>;
 } & {
-    readonly Rejected: import("../commonCodecs.js").ErrCodec<undefined, "PermissionErr::Rejected">;
-    readonly Unknown: import("../commonCodecs.js").ErrCodec<{
+    readonly Rejected: import("@novasamatech/scale").ErrCodec<undefined, "PermissionErr::Rejected">;
+    readonly Unknown: import("@novasamatech/scale").ErrCodec<{
         reason: string;
     }, "PermissionErr::Unknown">;
 };
@@ -77,14 +45,6 @@ export declare const PermissionRequestV1_request: import("scale-ts").Codec<{
     tag: "NetworkRequest";
     value: string[];
 }>;
-export declare const PermissionRequestV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, (Error & {
-    name: "PermissionErr::Rejected";
-    className: string;
-    payload: undefined;
-}) | (Error & {
-    name: "PermissionErr::Unknown";
-    className: string;
-    payload: {
-        reason: string;
-    };
-})>>;
+export declare const PermissionRequestV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<undefined, "PermissionErr::Rejected"> | import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "PermissionErr::Unknown">>>;

package/dist/protocol/v1/permission.js

@@ -1,5 +1,6 @@
+import { Enum, ErrEnum } from '@novasamatech/scale';
 import { Result, Struct, Vector, _void, str } from 'scale-ts';
-import { Enum, ErrEnum, GenericErr, GenesisHash } from '../commonCodecs.js';
+import { GenericErr, GenesisHash } from '../commonCodecs.js';
 export const PermissionErr = ErrEnum('PermissionErr', {
     Rejected: [_void, 'Permission: rejected'],
     Unknown: [GenericErr, 'Permission: unknown error'],

package/dist/protocol/v1/sign.js

@@ -6,7 +6,7 @@ export const SigningErr = ErrEnum('SigningErr', {
     FailedToDecode: [_void, 'Failed to decode'],
     Rejected: [_void, 'Rejected'],
     PermissionDenied: [_void, 'Permission denied'],
-    Unknown: [GenericErr, 'Unknown error'],
+    Unknown: [GenericErr, ({ reason }) => reason || 'Unknown error'],
 });
 export const SigningResult = Struct({
     signature: Hex(),

package/dist/transport.js

@@ -1,10 +1,15 @@
-import { enumValue, isEnumVariant, resultErr, resultOk } from '@novasamatech/scale';
+import { enumValue, isEnumVariant, resultErr, resultOk, toHex } from '@novasamatech/scale';
 import { createNanoEvents } from 'nanoevents';
 import { HANDSHAKE_INTERVAL, HANDSHAKE_TIMEOUT, JAM_CODEC_PROTOCOL_ID } from './constants.js';
 import { composeAction, createRequestId, delay, promiseWithResolvers } from './helpers.js';
-import { Message } from './protocol/messageCodec.js';
+import { Message, MessagePayload } from './protocol/messageCodec.js';
 import { HandshakeErr } from './protocol/v1/handshake.js';
-const isConnected = (status) => status === 'connected';
+function isConnected(status) {
+    return status === 'connected';
+}
+function getSubscriptionKey(method, payload) {
+    return `${method}_${toHex(MessagePayload.enc(payload))}`;
+}
 export function createTransport(provider) {
     let codecVersion = JAM_CODEC_PROTOCOL_ID;
     const handshakeAbortController = new AbortController();
@@ -39,6 +44,8 @@ export function createTransport(provider) {
         throwIfIncorrectEnvironment();
         throwIfInvalidCodecVersion();
     }
+    // subscriptions management (multiplexing)
+    const activeSubscriptions = new Map();
     const transport = {
         provider,
         isCorrectEnvironment() {
@@ -137,39 +144,77 @@ export function createTransport(provider) {
         subscribe(method, payload, callback) {
             checks();
             const events = createNanoEvents();
-            const requestId = createRequestId();
             const startAction = composeAction(method, 'start');
-            const stopAction = composeAction(method, 'stop');
-            const interruptAction = composeAction(method, 'interrupt');
-            const receiveAction = composeAction(method, 'receive');
-            const unsubscribeReceive = transport.listenMessages(receiveAction, (receivedId, data) => {
-                if (receivedId === requestId) {
-                    callback(data.value);
-                }
-            });
-            const unsubscribeInterrupt = transport.listenMessages(interruptAction, receivedId => {
-                if (receivedId === requestId) {
-                    events.emit('interrupt');
-                    stopSubscription();
+            const startPayload = enumValue(startAction, payload);
+            const subscriptionKey = getSubscriptionKey(method, startPayload);
+            let subscription = activeSubscriptions.get(subscriptionKey);
+            function unsub() {
+                const subscription = activeSubscriptions.get(subscriptionKey);
+                if (subscription) {
+                    const newListeners = subscription.listeners.filter(listener => listener.call !== callback);
+                    if (newListeners.length === 0) {
+                        activeSubscriptions.delete(subscriptionKey);
+                        subscription.kill();
+                    }
+                    else {
+                        subscription.listeners = newListeners;
+                    }
                 }
-            });
-            const stopSubscription = () => {
-                unsubscribeReceive();
-                unsubscribeInterrupt();
-                events.events = {};
+            }
+            const listener = {
+                call: callback,
+                unsubscribe: unsub,
             };
-            const startPayload = enumValue(startAction, payload);
-            transport.postMessage(requestId, startPayload);
-            return {
-                unsubscribe() {
-                    stopSubscription();
-                    const stopPayload = enumValue(stopAction, undefined);
-                    transport.postMessage(requestId, stopPayload);
-                },
+            const publicSubscription = {
+                unsubscribe: unsub,
                 onInterrupt(callback) {
                     return events.on('interrupt', callback);
                 },
             };
+            // wiring up a real subscription
+            if (!subscription) {
+                const requestId = createRequestId();
+                const stopAction = composeAction(method, 'stop');
+                const interruptAction = composeAction(method, 'interrupt');
+                const receiveAction = composeAction(method, 'receive');
+                const unsubscribeReceive = transport.listenMessages(receiveAction, (receivedId, data) => {
+                    if (receivedId === requestId) {
+                        const subscription = activeSubscriptions.get(subscriptionKey);
+                        if (subscription) {
+                            for (const listener of subscription.listeners) {
+                                listener.call(data.value);
+                            }
+                        }
+                    }
+                });
+                const unsubscribeInterrupt = transport.listenMessages(interruptAction, receivedId => {
+                    if (receivedId === requestId) {
+                        events.emit('interrupt');
+                        stopSubscription();
+                    }
+                });
+                const stopSubscription = () => {
+                    unsubscribeReceive();
+                    unsubscribeInterrupt();
+                    events.events = {};
+                };
+                // creating subscription
+                subscription = {
+                    requestId,
+                    kill: () => {
+                        stopSubscription();
+                        const stopPayload = enumValue(stopAction, undefined);
+                        transport.postMessage(requestId, stopPayload);
+                    },
+                    listeners: [listener],
+                };
+                activeSubscriptions.set(subscriptionKey, subscription);
+                transport.postMessage(requestId, startPayload);
+            }
+            else {
+                subscription.listeners.push(listener);
+            }
+            return publicSubscription;
         },
         handleSubscription(method, handler) {
             checks();

package/dist/transport.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/transport.spec.js

@@ -0,0 +1,58 @@
+import { createNanoEvents } from 'nanoevents';
+import { describe, expect, it, vi } from 'vitest';
+import { createDefaultLogger } from './logger.js';
+import { createTransport } from './transport.js';
+function createProviders() {
+    const bus = createNanoEvents();
+    function createProvider(listenTo, postTo) {
+        return {
+            logger: createDefaultLogger(),
+            isCorrectEnvironment: () => true,
+            dispose: () => delete bus.events[listenTo],
+            subscribe: callback => bus.on(listenTo, callback),
+            postMessage: message => bus.emit(postTo, message),
+        };
+    }
+    return {
+        host: createProvider('toHost', 'toSdk'),
+        sdk: createProvider('toSdk', 'toHost'),
+    };
+}
+describe('transport', () => {
+    describe('subscription', () => {
+        it('should multiplex subscriptions', () => {
+            const providers = createProviders();
+            const events = createNanoEvents();
+            const host = createTransport(providers.host);
+            const sdk = createTransport(providers.sdk);
+            const hostUnsubscribe = vi.fn();
+            const containerHandler = vi.fn((_, send) => {
+                const unsub = events.on('push', () => {
+                    send({ tag: 'v1', value: 'connected' });
+                });
+                return () => {
+                    unsub();
+                    hostUnsubscribe();
+                };
+            });
+            host.handleSubscription('host_account_connection_status_subscribe', containerHandler);
+            const s1Handler = vi.fn();
+            const s1 = sdk.subscribe('host_account_connection_status_subscribe', { tag: 'v1', value: undefined }, s1Handler);
+            const s2Handler = vi.fn();
+            const s2 = sdk.subscribe('host_account_connection_status_subscribe', { tag: 'v1', value: undefined }, s2Handler);
+            events.emit('push');
+            expect(s1Handler).toHaveBeenCalledTimes(1);
+            expect(s2Handler).toHaveBeenCalledTimes(1);
+            s1.unsubscribe();
+            expect(hostUnsubscribe).not.toBeCalled();
+            events.emit('push');
+            expect(s1Handler).toHaveBeenCalledTimes(1);
+            expect(s2Handler).toHaveBeenCalledTimes(2);
+            s2.unsubscribe();
+            expect(hostUnsubscribe).toHaveBeenCalledTimes(1);
+            events.emit('push');
+            expect(s1Handler).toHaveBeenCalledTimes(1);
+            expect(s2Handler).toHaveBeenCalledTimes(2);
+        });
+    });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-api",
   "type": "module",
-  "version": "0.6.5",
+  "version": "0.6.6-1",
   "description": "Host API: transport implementation for host - product integration.",
   "license": "Apache-2.0",
   "repository": {
@@ -21,7 +21,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@novasamatech/scale": "0.6.5",
+    "@novasamatech/scale": "0.6.6-1",
     "@polkadot-api/utils": "^0.2.0",
     "nanoevents": "9.1.0",
     "nanoid": "5.1.6",