@snap/camera-kit/dist/uri-handlers/uriHandlersRegister.js

Camera Kit Web

import { isState } from "@snap/state-management";
import { Injectable } from "@snap/ts-inject";
import { metricsClientFactory } from "../clients/metricsClient";
import { lensKeyboardFactory } from "../session/LensKeyboard";
import { lensStateFactory } from "../session/lensState";
import { lensRepositoryFactory } from "../lens/LensRepository";
import { sessionStateFactory } from "../session/sessionState";
import { getLogger } from "../logger/logger";
import { lensCoreFactory } from "../lens-core-module/loader/lensCoreFactory";
import { configurationToken } from "../configuration";
import { remoteApiSpecsClientFactory } from "../clients/remoteApiSpecsClient";
import { createHttpUriHandler } from "./internal-handlers/httpUriHandler";
import { extractSchemeAndRoute, isUriHandlers, isUriResponse, uriHandlersFactory } from "./UriHandlers";
import { createRemoteApiUriHandler, remoteApiServicesFactory } from "./internal-handlers/remoteApiUriHandler";
const logger = getLogger("uriHandlersRegister");
export const registerUriHandlers = Injectable("registerUriHandlers", [
    configurationToken,
    lensCoreFactory.token,
    lensStateFactory.token,
    uriHandlersFactory.token,
    lensKeyboardFactory.token,
    remoteApiServicesFactory.token,
    lensRepositoryFactory.token,
    sessionStateFactory.token,
    metricsClientFactory.token,
    remoteApiSpecsClientFactory.token,
], (configuration, lensCore, lensState, userHandlers, lensKeyboard, remoteApiServices, lensRepository, sessionState, metrics, remoteApiSpecsClient) => {
    if (!isUriHandlers(userHandlers)) {
        throw new Error("Expected an array of UriHandler objects");
    }
    const allHandlers = [
        createHttpUriHandler(lensState, sessionState, remoteApiSpecsClient, configuration.lensHttpHandler, configuration.lensHttpValidationStrategy),
        ...userHandlers,
        lensKeyboard.uriHandler,
        createRemoteApiUriHandler(remoteApiServices, sessionState, lensState, lensRepository, metrics),
    ];
    for (const { uri, handleRequest, cancelRequest } of allHandlers) {
        const uris = Array.isArray(uri) ? uri : [uri];
        for (const { scheme, route } of uris.map(extractSchemeAndRoute)) {
            lensCore.registerUriListener(scheme, route, {
                handleRequest: (request) => {
                    const reply = (response) => {
                        if (!isUriResponse(response)) {
                            throw new Error("Expected UriResponse object");
                        }
                        lensCore.provideUriResponse(request.identifier, response);
                    };
                    const state = lensState.getState();
                    if (isState(state, "noLensApplied")) {
                        logger.warn(`Got a URI request for ${request.uri}, but there is no active lens. The ` +
                            `request will not be processed.`);
                        return;
                    }
                    handleRequest(request, reply, state.data);
                },
                cancelRequest: (request) => {
                    if (cancelRequest) {
                        const state = lensState.getState();
                        if (isState(state, "noLensApplied")) {
                            logger.warn(`Got a URI cancel request for ${request.uri}, but there is no active ` +
                                `lens. The cancel request will not be processed.`);
                            return;
                        }
                        cancelRequest(request, state.data);
                    }
                },
            });
        }
    }
});
//# sourceMappingURL=uriHandlersRegister.js.map