@ledgerhq/live-common/lib-es/apps/inlineAppInstall.js

Common ground for the Ledger Live apps

import { concat, of, from, EMPTY, defer } from "rxjs";
import getDeviceInfo from "../hw/getDeviceInfo";
import { listAppsUseCase } from "../device/use-cases/listAppsUseCase";
import { execWithTransport } from "../device/use-cases/execWithTransport";
import { reducer, initState, isOutOfMemoryState, predictOptimisticState } from "./logic";
import { runAllWithProgress } from "./runner";
import { mergeMap, map, throttleTime } from "rxjs/operators";
import { LocalTracer } from "@ledgerhq/logs";
/**
 * Tries to install a list of apps
 *
 * @param transport Transport instance
 * @param appNames List of app names to install
 * @param onSuccessObs Optional observable to run after the installation
 * @param allowPartialDependencies If true, keep installing apps even if some are missing
 * @returns Observable of InlineAppInstallEvent or ConnectAppEvent
 * - Event "inline-install" contains a global progress of the installation
 */
const inlineAppInstall = ({ transport, appNames, onSuccessObs, allowPartialDependencies = false, }) => {
    const tracer = new LocalTracer("hw", {
        ...transport.getTraceContext(),
        function: "inlineAppInstall",
    });
    tracer.trace("Starting inline app install");
    return concat(of({
        type: "listing-apps",
    }), from(getDeviceInfo(transport)).pipe(mergeMap(deviceInfo => {
        tracer.trace("Got device info", { deviceInfo });
        return listAppsUseCase(transport, deviceInfo);
    }), mergeMap(e => {
        // Bubble up events
        if (e.type === "device-permission-granted" || e.type === "device-permission-requested") {
            return of(e);
        }
        if (e.type === "result") {
            // Figure out the operations that need to happen
            const state = appNames.reduce((state, name) => reducer(state, {
                type: "install",
                name,
                allowPartialDependencies,
            }), initState(e.result));
            // Failed appOps in this flow will throw by default but if we're here
            // it means we didn't throw, so we wan't to notify the action about it.
            const maybeSkippedEvent = state.skippedAppOps.length
                ? of({
                    type: "some-apps-skipped",
                    skippedAppOps: state.skippedAppOps,
                })
                : EMPTY;
            if (!state.installQueue.length) {
                // There's nothing to install, we can consider this a success.
                return defer(onSuccessObs || (() => EMPTY));
            }
            if (isOutOfMemoryState(predictOptimisticState(state))) {
                // In this case we can't install either by lack of storage, or permissions,
                // we fallback to the error case listing the missing apps.
                const missingAppNames = state.installQueue;
                tracer.trace("Out of memory", {
                    appNames: missingAppNames,
                    appName: missingAppNames[0] || appNames[0],
                });
                return of({
                    type: "app-not-installed",
                    appNames: missingAppNames,
                    appName: missingAppNames[0] || appNames[0], // TODO remove when LLD/LLM integrate appNames
                });
            }
            const exec = execWithTransport(transport);
            return concat(of({
                type: "listed-apps",
                installQueue: state.installQueue,
            }), maybeSkippedEvent, runAllWithProgress(state, exec).pipe(throttleTime(100), map(({ globalProgress, itemProgress, installQueue, currentAppOp }) => ({
                type: "inline-install",
                progress: globalProgress,
                itemProgress,
                installQueue,
                currentAppOp,
            }))), defer(onSuccessObs || (() => EMPTY)));
        }
        return EMPTY;
    })));
};
export default inlineAppInstall;
//# sourceMappingURL=inlineAppInstall.js.map