@interopio/desktop 6.6.0 → 6.7.0-next.0

package/dist/desktop.es.js

@@ -2927,7 +2927,7 @@ const ContextMessageReplaySpec = {
     }
 };
 
-var version$1 = "6.3.4";
+var version$1 = "6.4.0-next.0";
 
 function prepareConfig$1 (configuration, ext, glue42gd) {
     let nodeStartingContext;
@@ -17567,6 +17567,9 @@ async function setupInterop(interopLib, channels) {
             channels.handleRestrictionsChanged(restrictions, targetWindowId);
             return;
         }
+        if (command === "isFdc3DataWrappingSupported") {
+            return { isSupported: true };
+        }
         throw new Error(`unknown command ${command}`);
     });
     const result = await interop.invoke("T42.Channels.Announce", { swId: windowId, instance: interop.instance.instance });
@@ -17665,8 +17668,7 @@ class SharedContextSubscriber {
         const contextName = this.createContextName(name);
         const contextData = await this.contexts.get(contextName);
         if (contextData[LATEST_FDC3_TYPE]) {
-            const { latest_fdc3_type, ...data } = contextData;
-            return data;
+            return this.getContextWithFdc3Data(contextData);
         }
         return contextData;
     }
@@ -17745,6 +17747,21 @@ class SharedContextSubscriber {
         }
         return fdc3PropsArr[0].split("_").slice(1).join("_");
     }
+    getContextWithFdc3Data(channelContext) {
+        const { latest_fdc3_type, ...rest } = channelContext;
+        const parsedType = latest_fdc3_type.split("&").join(".");
+        const fdc3Context = { type: parsedType, ...rest.data[`fdc3_${latest_fdc3_type}`] };
+        delete rest.data[`fdc3_${latest_fdc3_type}`];
+        const context = {
+            name: channelContext.name,
+            meta: channelContext.meta,
+            data: {
+                ...rest.data,
+                fdc3: fdc3Context
+            }
+        };
+        return context;
+    }
 }
 
 class ChannelsImpl {
@@ -17774,17 +17791,7 @@ class ChannelsImpl {
         }
         const id = Utils.generateId();
         this.pendingReplays[id] = true;
-        const callbackWithPermissionCheck = async (data, context, updaterId) => {
-            const restrictionByChannel = await this.getRestrictionsByChannel(context.name);
-            if (restrictionByChannel.read) {
-                callback(data, context, updaterId);
-            }
-            else {
-                this.onRestrictionsChanged(() => {
-                    callback(data, context, updaterId);
-                }, id, context.name);
-            }
-        };
+        const wrappedCallback = this.getWrappedSubscribeCallback(callback, id);
         if (this.lastUpdate) {
             let lastUpdate = Object.assign({}, this.lastUpdate);
             setTimeout(async () => {
@@ -17792,12 +17799,12 @@ class ChannelsImpl {
                     if (this.lastUpdate) {
                         lastUpdate = this.lastUpdate;
                     }
-                    callbackWithPermissionCheck(lastUpdate.context.data, lastUpdate.context, lastUpdate.updaterId);
+                    wrappedCallback(lastUpdate.context.data, lastUpdate.context, lastUpdate.updaterId);
                 }
                 delete this.pendingReplays[id];
             }, 0);
         }
-        const unsub = this.registry.add(this.subsKey, callbackWithPermissionCheck);
+        const unsub = this.registry.add(this.subsKey, wrappedCallback);
         return () => {
             this.pendingReplays[id] = false;
             this.pendingRestrictionCallbacks.delete(id);
@@ -17812,46 +17819,35 @@ class ChannelsImpl {
             throw new Error("Please provide the callback as a function!");
         }
         const id = Utils.generateId();
-        const callbackWithPermissionCheck = async (data, context, updaterId) => {
-            const restrictionByChannel = await this.getRestrictionsByChannel(context.name);
-            if (restrictionByChannel.read) {
-                callback(data, context, updaterId);
-            }
-            else {
-                this.onRestrictionsChanged(() => {
-                    callback(data, context, updaterId);
-                }, id, context.name);
-            }
-        };
-        const unsub = await this.shared.subscribeFor(name, callbackWithPermissionCheck);
+        const wrappedCallback = this.getWrappedSubscribeCallback(callback, id);
+        const unsub = await this.shared.subscribeFor(name, wrappedCallback);
         return () => {
             this.pendingRestrictionCallbacks.delete(id);
             unsub();
         };
     }
-    async publish(data, name) {
+    async publish(data, options) {
         if (typeof data !== "object") {
             throw new Error("Please provide the data as an object!");
         }
-        if (name) {
-            if (typeof name !== "string") {
-                throw new Error("Please provide the name as a string!");
-            }
-            if (!this.shared.isChannel(name)) {
-                return Promise.reject(new Error(`A channel with name: ${name} doesn't exist!`));
-            }
-            if (!(await this.getRestrictionsByChannel(name)).write) {
-                throw new Error(`Window does not have permission to write to channel ${name}`);
-            }
-            return this.shared.updateData(name, data);
+        if (options) {
+            this.validatePublishOptions(options);
         }
-        if (!this.currentContext) {
+        if (typeof options === "object") {
+            return this.publishWithOptions(data, options);
+        }
+        const channelName = typeof options === "string" ? options : this.currentContext;
+        if (!channelName) {
             throw new Error("Not joined to any channel!");
         }
-        if (!(await this.getRestrictionsByChannel(this.currentContext)).write) {
+        if (!this.shared.isChannel(channelName)) {
+            return Promise.reject(new Error(`A channel with name: ${channelName} doesn't exist!`));
+        }
+        const canPublish = (await this.getRestrictionsByChannel(channelName)).write;
+        if (!canPublish) {
             throw new Error(`Window does not have permission to write to channel ${this.currentContext}`);
         }
-        return this.shared.updateData(this.currentContext, data);
+        return this.shared.updateData(channelName, data);
     }
     async setPaths(paths, name) {
         if (name) {
@@ -18155,6 +18151,82 @@ class ChannelsImpl {
             throw new Error(`path property is not a valid string from the Path Value argument: ${JSON.stringify(path)}`);
         }
     }
+    validatePublishOptions(options) {
+        if ((typeof options !== "string" && typeof options !== "object") || Array.isArray(options)) {
+            throw new Error("Provide options as a string or an object");
+        }
+        if (typeof options === "object") {
+            this.validatePublishOptionsObject(options);
+            return;
+        }
+        if (options === "string" && !options.length) {
+            throw new Error("Provide options as a non-empty string");
+        }
+    }
+    validatePublishOptionsObject(options) {
+        if (typeof options !== "object" || Array.isArray(options)) {
+            throw new Error("Provide options as an object");
+        }
+        if (options.name && (typeof options.name !== "string" || !options.name.length)) {
+            throw new Error("Provide options.name as a non-empty string");
+        }
+        if (Object.keys(options).includes("fdc3") && typeof options.fdc3 !== "boolean") {
+            throw new Error("Provide options.fdc3 as a boolean");
+        }
+    }
+    async publishWithOptions(data, options) {
+        const channelName = options.name || this.currentContext;
+        if (!this.shared.isChannel(channelName)) {
+            throw new Error(`A channel with name: ${options.name} doesn't exist!`);
+        }
+        if (!channelName) {
+            throw new Error("Cannot publish to channel, because not joined to a channel!");
+        }
+        const canPublish = (await this.getRestrictionsByChannel(channelName)).write;
+        if (!canPublish) {
+            throw new Error(`Window does not have permission to write to channel ${this.currentContext}`);
+        }
+        if (!options.fdc3) {
+            return this.shared.updateData(channelName, data);
+        }
+        return this.publishFdc3Data(channelName, data);
+    }
+    async publishFdc3Data(channelName, data) {
+        var _a;
+        if (typeof data.type !== "string" || !((_a = data.type) === null || _a === void 0 ? void 0 : _a.length)) {
+            throw new Error("Expected a valid FDC3 Context with compulsory 'type' field");
+        }
+        const { type, ...rest } = data;
+        const parsedType = type.split(".").join("&");
+        const fdc3DataToPublish = { [`fdc3_${parsedType}`]: rest };
+        return this.shared.updateData(channelName, fdc3DataToPublish);
+    }
+    getWrappedSubscribeCallback(callback, id) {
+        const wrappedCallback = async (_, context, updaterId) => {
+            const restrictionByChannel = await this.getRestrictionsByChannel(context.name);
+            const channelData = this.getDataWithFdc3Encoding(context);
+            if (restrictionByChannel.read) {
+                callback(channelData, context, updaterId);
+            }
+            else {
+                this.onRestrictionsChanged(() => {
+                    callback(channelData, context, updaterId);
+                }, id, context.name);
+            }
+        };
+        return wrappedCallback;
+    }
+    getDataWithFdc3Encoding(context) {
+        const { data, latest_fdc3_type } = context;
+        if (!latest_fdc3_type) {
+            return data;
+        }
+        const parsedType = latest_fdc3_type.split("&").join(".");
+        const latestTypePropName = `fdc3_${latest_fdc3_type}`;
+        const fdc3Data = { type: parsedType, ...data[latestTypePropName] };
+        const { [latestTypePropName]: latestFDC3Type, ...rest } = data;
+        return { ...rest, fdc3: fdc3Data };
+    }
 }
 
 function factory$4(contexts, agm, getWindows, logger) {
@@ -18278,7 +18350,7 @@ function factory$3(agm) {
     };
 }
 
-var version = "6.5.1";
+var version = "6.6.0";
 
 var prepareConfig = (options) => {
     function getLibConfig(value, defaultMode, trueMode) {
@@ -19186,28 +19258,6 @@ const validateIntentHandlerAsResponse = (handler) => {
     }
     return { isValid: true, ok: handler };
 };
-const validateRaiseIntentsResolverResponse = (responseObj) => {
-    const invalidKey = Object.keys(responseObj).some((key) => key !== "intent" && key !== "handler");
-    if (invalidKey) {
-        return { isValid: false, error: "Response is not a valid object. Expected { intent: string, handler: IntentHandler }" };
-    }
-    if (typeof responseObj.intent !== "string") {
-        return { isValid: false, error: `Response object has invalid 'intent' key. Expected a string, got ${typeof responseObj.intent}` };
-    }
-    const { isValid, error } = validateIntentHandlerAsResponse(responseObj.handler);
-    return isValid
-        ? { isValid: true, ok: { intent: responseObj.intent, handler: responseObj.handler } }
-        : { isValid: false, error };
-};
-const validateFilterHandlersResolverResponse = (responseObj) => {
-    if (!responseObj.handler) {
-        return { isValid: false, error: "Response is not a valid object. Expected { handler: IntentHandler }" };
-    }
-    const { isValid, error } = validateIntentHandlerAsResponse(responseObj.handler);
-    return isValid
-        ? { isValid: true, ok: { handler: responseObj.handler } }
-        : { isValid: false, error };
-};
 const validateIntentRequestTarget = (target) => {
     if (!target) {
         return;
@@ -19294,14 +19344,27 @@ const validateHandlerFilter = (handlerFilter) => {
         throw new Error(errorMsg);
     }
 };
-const validateIntentsResolverResponse = (method, responseObj) => {
-    return method === "raise" ? validateRaiseIntentsResolverResponse(responseObj) : validateFilterHandlersResolverResponse(responseObj);
+const validateResolverResponse = (responseObj) => {
+    var _a, _b;
+    if (typeof responseObj.intent !== "string") {
+        return { isValid: false, error: `Response object has invalid 'intent' key. Expected a string, got ${typeof responseObj.intent}` };
+    }
+    if (((_a = responseObj.userSettings) === null || _a === void 0 ? void 0 : _a.preserveChoice) && typeof ((_b = responseObj.userSettings) === null || _b === void 0 ? void 0 : _b.preserveChoice) !== "boolean") {
+        return { isValid: false, error: `Response object has invalid 'userSettings.preserveChoice' key. Expected a boolean, got ${typeof responseObj.userSettings.preserveChoice}` };
+    }
+    const { isValid, error } = validateIntentHandlerAsResponse(responseObj.handler);
+    return isValid
+        ? { isValid: true, ok: responseObj }
+        : { isValid, error };
 };
 const validateIntentRequest = (request) => {
     validateIntentRequestContext(request.context);
     validateIntentRequestTarget(request.target);
     validateIntentRequestTimeout(request.timeout);
     validateWaitUserResponseIndefinitely(request.waitUserResponseIndefinitely);
+    if (typeof request.clearSavedHandler !== "undefined" && typeof request.clearSavedHandler !== "boolean") {
+        throw new Error("Please provide 'clearSavedHandler' as a boolean");
+    }
     if (request.handlers) {
         request.handlers.forEach((handler) => validateIntentRequestHandler(handler));
     }
@@ -19350,10 +19413,11 @@ const clearNullUndefined = (obj) => {
 };
 
 class Intents {
-    constructor(interop, windows, logger, options, appManager) {
+    constructor(interop, windows, logger, options, prefsController, appManager) {
         this.interop = interop;
         this.windows = windows;
         this.logger = logger;
+        this.prefsController = prefsController;
         this.appManager = appManager;
         this.myIntents = new Set();
         this.intentsResolverResponsePromises = {};
@@ -19395,8 +19459,16 @@ class Intents {
         }
         validateIntentRequest(intentRequest);
         await Promise.all(this.unregisterIntentPromises);
-        const timeout = intentRequest.timeout || DEFAULT_RAISE_TIMEOUT_MS;
+        if (intentRequest.clearSavedHandler) {
+            this.logger.trace(`User removes saved handler for intent ${intentRequest.intent}`);
+            await this.removeRememberedHandler(intentRequest.intent);
+        }
         const resolverInstance = {};
+        const timeout = intentRequest.timeout || DEFAULT_RAISE_TIMEOUT_MS;
+        const resultFromRememberedHandler = await this.checkHandleRaiseWithRememberedHandler(intentRequest, resolverInstance, timeout);
+        if (resultFromRememberedHandler) {
+            return resultFromRememberedHandler;
+        }
         const coreRaiseIntentFn = this.coreRaiseIntent.bind(this, { request: intentRequest, resolverInstance, timeout });
         if (intentRequest.waitUserResponseIndefinitely) {
             return coreRaiseIntentFn();
@@ -19597,6 +19669,10 @@ class Intents {
         this.logger.trace(`Returning intents for handler ${JSON.stringify(handler)}`);
         return { intents: intentsWithInfo };
     }
+    async clearSavedHandlers() {
+        this.logger.trace("Removing all saved handlers from prefs storage for current app");
+        await this.prefsController.update({ intents: undefined });
+    }
     filterHandlersBy(intents, filter) {
         const filteredIntentsWithHandlers = intents.filter((intent) => {
             if (filter.intent && filter.intent !== intent.name) {
@@ -19698,7 +19774,7 @@ class Intents {
     async startResolverApp({ request, method, resolverInstance }) {
         var _a, _b, _c, _d;
         (_a = this.logger) === null || _a === void 0 ? void 0 : _a.trace(`Intents Resolver UI with app name ${this.intentsResolverAppName} will be used for request: ${JSON.stringify(request)}`);
-        const responseMethodName = await this.registerIntentResolverMethod(method);
+        const responseMethodName = await this.registerIntentResolverMethod();
         (_b = this.logger) === null || _b === void 0 ? void 0 : _b.trace(`Registered interop method ${responseMethodName}`);
         const startContext = this.buildStartContext(method, request, responseMethodName);
         const startOptions = await this.buildStartOptions();
@@ -19717,7 +19793,7 @@ class Intents {
                 ? `for intent ${request.intent}`
                 : `for '${method}' method with filter ${JSON.stringify(request)}`}`
         });
-        const handler = await this.handleInstanceResponse(instance.id, method);
+        const handler = await this.handleInstanceResponse({ instanceId: instance.id, caller: startContext.initialCaller, method, request });
         return handler;
     }
     async windowsIdToTitle(id, windowsInfos) {
@@ -19729,13 +19805,24 @@ class Intents {
         const title = await (window === null || window === void 0 ? void 0 : window.getTitle());
         return title;
     }
-    async handleInstanceResponse(instanceId, method) {
-        var _a, _b;
+    async handleInstanceResponse({ instanceId, method, request, caller }) {
+        var _a, _b, _c;
         try {
             const response = await this.intentsResolverResponsePromises[instanceId].promise;
-            (_a = this.logger) === null || _a === void 0 ? void 0 : _a.trace(`Intent handler chosen ${method === "raise" ? `for intent ${response.intent} ` : ""}: ${JSON.stringify(response.handler)}. Stopping resolver instance with id ${instanceId}`);
+            const subMessage = method === "raise" ? `for intent ${response.intent} ` : "";
+            (_a = this.logger) === null || _a === void 0 ? void 0 : _a.trace(`Intent handler chosen ${subMessage}: ${JSON.stringify(response.handler)}. Stopping resolver instance with id ${instanceId}`);
             this.stopResolverInstance(instanceId);
             (_b = this.logger) === null || _b === void 0 ? void 0 : _b.trace(`Instance with id ${instanceId} successfully stopped`);
+            if ((_c = response.userSettings) === null || _c === void 0 ? void 0 : _c.preserveChoice) {
+                await this.saveUserChoice({
+                    intent: response.intent,
+                    handler: response.handler,
+                    filter: method === "filterHandlers"
+                        ? { applicationNames: request.applicationNames, contextTypes: request.contextTypes, resultType: request.resultType }
+                        : undefined,
+                    caller
+                });
+            }
             return response.handler;
         }
         catch (error) {
@@ -19743,14 +19830,14 @@ class Intents {
             throw new Error(error);
         }
     }
-    async registerIntentResolverMethod(method) {
+    async registerIntentResolverMethod() {
         const methodName = INTENTS_RESOLVER_INTEROP_PREFIX + Utils.generateId();
-        await this.interop.register(methodName, (args, callerId) => this.resolverResponseHandler(args, callerId, method));
+        await this.interop.register(methodName, (args, callerId) => this.resolverResponseHandler(args, callerId));
         return methodName;
     }
-    resolverResponseHandler(args, callerId, method) {
+    resolverResponseHandler(args, callerId) {
         const { instance } = callerId;
-        const isValid = validateIntentsResolverResponse(method, args);
+        const isValid = validateResolverResponse(args);
         if (!isValid) {
             this.logger.trace(`Intent Resolver instance with id ${callerId.instance} sent invalid response. Error: ${isValid.error}`);
             this.intentsResolverResponsePromises[instance].reject(isValid.error);
@@ -19762,7 +19849,15 @@ class Intents {
         this.cleanUpIntentResolverPromise(instance);
     }
     buildStartContext(method, request, methodName) {
-        const baseStartContext = { callerId: this.interop.instance.instance, methodName };
+        var _a;
+        const myAppName = this.interop.instance.application || this.interop.instance.applicationName;
+        const myAppTitle = ((_a = this.appManager.application(myAppName)) === null || _a === void 0 ? void 0 : _a.title) || "";
+        const baseStartContext = {
+            callerId: this.interop.instance.instance,
+            methodName,
+            initialCaller: { id: this.interop.instance.instance, applicationName: myAppName, applicationTitle: myAppTitle },
+            resolverApi: "1.0"
+        };
         return method === "raise"
             ? { ...baseStartContext, intent: request }
             : { ...baseStartContext, handlerFilter: request };
@@ -19950,6 +20045,64 @@ class Intents {
         }, []);
         return intentsWithInfo;
     }
+    async removeRememberedHandler(intentName) {
+        var _a;
+        this.logger.trace(`Removing saved handler from prefs storage for intent ${intentName}`);
+        const prefs = await this.prefsController.get();
+        const intentPrefs = (_a = prefs.data) === null || _a === void 0 ? void 0 : _a.intents;
+        if (!intentPrefs) {
+            this.logger.trace("No app prefs found for current app");
+            return;
+        }
+        delete intentPrefs[intentName];
+        const updatedPrefs = {
+            ...prefs.data,
+            intents: intentPrefs
+        };
+        await this.prefsController.update(updatedPrefs);
+        this.logger.trace(`Handler saved choice for intent ${intentName} removed successfully`);
+    }
+    async checkForRememberedHandler(intentRequest) {
+        var _a, _b;
+        const prefs = await this.prefsController.get();
+        const prefsForIntent = (_b = (_a = prefs.data) === null || _a === void 0 ? void 0 : _a.intents) === null || _b === void 0 ? void 0 : _b[intentRequest.intent];
+        return prefsForIntent === null || prefsForIntent === void 0 ? void 0 : prefsForIntent.handler;
+    }
+    async checkHandleRaiseWithRememberedHandler(intentRequest, resolverInstance, timeout) {
+        const rememberedHandler = await this.checkForRememberedHandler(intentRequest);
+        if (!rememberedHandler) {
+            return;
+        }
+        const request = {
+            ...intentRequest,
+            target: {
+                app: rememberedHandler.applicationName,
+                instance: rememberedHandler.instanceId
+            }
+        };
+        try {
+            const response = await this.coreRaiseIntent({ request, resolverInstance, timeout });
+            return response;
+        }
+        catch (error) {
+            this.logger.trace("Could not raise intent to remembered handler. Removing it from Prefs store");
+            await this.removeRememberedHandler(intentRequest.intent);
+        }
+    }
+    async saveUserChoice({ intent, handler, filter, caller }) {
+        var _a, _b;
+        const prevPrefs = await this.prefsController.get(caller.applicationName);
+        const prevIntentsPrefs = ((_a = prevPrefs === null || prevPrefs === void 0 ? void 0 : prevPrefs.data) === null || _a === void 0 ? void 0 : _a.intents) || {};
+        const prefsToUpdate = {
+            ...prevPrefs.data,
+            intents: {
+                ...prevIntentsPrefs,
+                [intent]: { handler, filter }
+            }
+        };
+        await this.prefsController.update(prefsToUpdate, { app: caller.applicationName });
+        (_b = this.logger) === null || _b === void 0 ? void 0 : _b.info(`Saved user's choice of handler for '${caller.applicationName}' app`);
+    }
 }
 
 class FactoryCallInfo {
@@ -20196,6 +20349,7 @@ const factoryCore = async (options, glue42gd) => {
     let _windows;
     let _displays;
     let _channels;
+    let _prefs;
     const _browserEventsDispatcher = new EventsDispatcher(glueConfig);
     function createWindows(core) {
         if (glueConfig.windows) {
@@ -20292,7 +20446,7 @@ const factoryCore = async (options, glue42gd) => {
         return hotkeysAPI;
     }
     function createIntents(core) {
-        const intentsAPI = new Intents(core.agm, _windows, core.logger.subLogger("intents"), options, _appManager);
+        const intentsAPI = new Intents(core.agm, _windows, core.logger.subLogger("intents"), options, _prefs, _appManager);
         debugLog(intentsAPI);
         return intentsAPI;
     }
@@ -20320,9 +20474,9 @@ const factoryCore = async (options, glue42gd) => {
     function createPrefs(core) {
         var _a, _b;
         const appName = (_b = (_a = options.application) !== null && _a !== void 0 ? _a : glue42gd === null || glue42gd === void 0 ? void 0 : glue42gd.applicationName) !== null && _b !== void 0 ? _b : core.interop.instance.application;
-        const prefs = new Prefs(appName, core.interop);
-        debugLog(prefs);
-        return prefs;
+        _prefs = new Prefs(appName, core.interop);
+        debugLog(_prefs);
+        return _prefs;
     }
     function createCookies(core) {
         const api = factory$1(core.interop, T42GDExecuteMethod);
@@ -20351,10 +20505,10 @@ const factoryCore = async (options, glue42gd) => {
             { name: "channels", create: createChannels },
             { name: "hotkeys", create: createHotkeys },
             { name: "displays", create: createDisplaysApi },
+            { name: "prefs", create: createPrefs },
             { name: "intents", create: createIntents },
             { name: "notifications", create: createNotifications },
             { name: "themes", create: createThemes },
-            { name: "prefs", create: createPrefs },
             { name: "cookies", create: createCookies }
         ],
         version,