export async function activate()

in src/extension.ts [34:178]
117 lines of code
3 McCabe index (conditional complexity)

export async function activate(context: vscode.ExtensionContext): Promise<void> {

    const wskEntityProvider = new WskEntityProvider(context);
    const wskEntityView = vscode.window.createTreeView('wskEntities', {
        treeDataProvider: wskEntityProvider,
    });
    wskEntityView.onDidChangeVisibility(() => wskEntityProvider.refresh());
    const disp = vscode.commands.registerCommand('wskEntities.refreshEntry', () =>
        wskEntityProvider.refresh()
    );

    const wskActivationProvider = new WskActivationProvider(context, wskEntityView);
    vscode.window.registerTreeDataProvider('wskActivations', wskActivationProvider);

    // `a`ction, `p`ackage, `t`rigger, `r`ule
    const triggerCharacters = 'aptr'.split('');
    context.subscriptions.push(
        vscode.languages.registerCompletionItemProvider(
            { scheme: 'file', language: 'yaml' },
            new WskdeployYamlCompletionItemProvider(),
            ...triggerCharacters
        )
    );

    // register TextDocumentContentProviders
    const actionCodeProvider = new ActionCodeProvider();
    const activationProvider = new ActivationProvider();
    vscode.workspace.registerTextDocumentContentProvider(
        ActionCodeProvider.scheme,
        actionCodeProvider
    );
    vscode.workspace.registerTextDocumentContentProvider(
        ActivationProvider.scheme,
        activationProvider
    );

    vscode.commands.registerCommand('wskAction.openActionCode', async (action: WskAction) => {
        commands.openActionCode(action);
    });

    vscode.commands.registerCommand('wskAction.editActionMetadata', async (action: WskAction) => {
        commands.editActionMetadata(action, context);
    });

    vscode.commands.registerCommand('wskAction.editActionCode', async (action: WskAction) => {
        commands.editAction(action);
    });

    vscode.commands.registerCommand('wskAction.deleteAction', async (action: WskAction) => {
        await commands.deleteAction(action);
        wskEntityProvider.refresh();
    });

    vscode.commands.registerCommand('wskAction.invokeAction', (action) =>
        commands.invokeAction(action, context)
    );

    vscode.commands.registerCommand('wskTrigger.deleteTrigger', async (trigger: WskTrigger) => {
        await commands.deleteTrigger(trigger);
        wskEntityProvider.refresh();
    });

    vscode.commands.registerCommand('wskEntities.addEndpoint', async () => {
        await addEndpoint(context);
        wskEntityProvider.refresh();
    });

    vscode.commands.registerCommand('wskEndpoint.addNamespace', async (endpoint: WskEndpoint) => {
        await addNamespace(endpoint.apihost, context);
        wskEntityProvider.refresh();
    });

    vscode.commands.registerCommand('wskEndpoint.rename', async (endpoint: WskEndpoint) => {
        await renameEndpoint(endpoint.apihost, context);
        wskEntityProvider.refresh();
    });

    vscode.commands.registerCommand('wskTrigger.showInfo', async (trigger: WskTrigger) => {
        commands.showTriggerInfo(trigger, context);
    });

    vscode.commands.registerCommand('wskActivation.showDetails', showActivationDetails);

    vscode.commands.registerCommand('wskActivations.refresh', () =>
        wskActivationProvider.refresh()
    );

    vscode.commands.registerCommand('wskEndpoint.remove', async (endpoint: WskEndpoint) => {
        const confirmed = await showConfirmMessage(
            `Are you sure you want to remove '${endpoint.label}' endpoint from the explorer?`
        );
        if (confirmed) {
            await removeEndpoint(endpoint, context);
            wskEntityProvider.refresh();
        }
    });

    vscode.commands.registerCommand('wskNamespace.remove', async (namespace: WskNamespace) => {
        const confirmed = await showConfirmMessage(
            `Are you sure you want to remove '${namespace.label}' namespace from the explorer?`
        );
        if (confirmed) {
            await removeNamespace(namespace, context);
            wskEntityProvider.refresh();
        }
    });

    vscode.commands.registerCommand(
        'wskNamespace.createAction',
        async (namespace: WskNamespace) => {
            await commands.createAction(namespace);
            wskEntityProvider.refresh();
        }
    );

    vscode.commands.registerCommand(
        'wskNamespace.createPackage',
        async (namespace: WskNamespace) => {
            await commands.createPackage(namespace);
            wskEntityProvider.refresh();
        }
    );

    vscode.commands.registerCommand('wskPackage.createAction', async (pkg: WskPackage) => {
        await commands.createAction(pkg);
        wskEntityProvider.refresh();
    });

    vscode.commands.registerCommand('wskPackage.editPackageMetadata', async (pkg: WskPackage) => {
        commands.editPackageMetadata(pkg, context);
    });

    vscode.commands.registerCommand('wskPackage.deletePackage', async (pkg: WskPackage) => {
        await commands.deletePackage(pkg);
        wskEntityProvider.refresh();
    });

    vscode.commands.registerCommand('wskdeploy.createProject', () =>
        commands.createWskdeployProject()
    );

    vscode.window.registerTreeDataProvider('wskdeploy', new WskDeployManifestProvider(context));

    context.subscriptions.push(disp);
}