How to use the vscode-nls.MessageFormat function in vscode-nls

import {ExecutableTarget} from '@cmt/api';
import {CMakeCache} from '@cmt/cache';
import * as proc from '@cmt/proc';
import {createLogger} from './logging';
import * as nls from 'vscode-nls';

nls.config({ messageFormat: nls.MessageFormat.bundle, bundleFormat: nls.BundleFormat.standalone })();
const localize: nls.LocalizeFunc = nls.loadMessageBundle();

const log = createLogger('debugger');


export enum DebuggerType {
  VisualStudio = 'Visual Studio',
  LLDB = 'LLDB',
  GDB = 'GDB',
  // LAUNCH // Future
}

/**
 * Describes configuration options for debugger in kit
 */
export interface DebuggerConfiguration {

* SPDX-License-Identifier: EPL-2.0                                                *
*                                                                                 *
* Copyright Contributors to the Zowe Project.                                     *
*                                                                                 *
*/

import { IProfileLoaded, Logger, CliProfileManager, Imperative, ImperativeConfig, IProfile, Session, ISession } from "@brightside/imperative";
import * as nls from "vscode-nls";
import * as os from "os";
import * as fs from "fs";
import * as path from "path";
import { URL } from "url";
import * as vscode from "vscode";
import * as zowe from "@brightside/core";
import * as ProfileLoader from "./ProfileLoader";
const localize = nls.config({ messageFormat: nls.MessageFormat.file })();
interface IUrlValidator {
    valid: boolean;
    host: string;
    port: number;
}

let IConnection: {
    name: string;
    host: string;
    port: number;
    user: string;
    password: string;
    rejectUnauthorized: boolean;
};

export class Profiles { // Processing stops if there are no profiles detected

import {createLogger} from '@cmt/logging';
import * as nls from 'vscode-nls';

nls.config({ messageFormat: nls.MessageFormat.bundle, bundleFormat: nls.BundleFormat.standalone })();
const localize: nls.LocalizeFunc = nls.loadMessageBundle();

const log = createLogger('code-pages');

export interface CodePageTable {
  [key: number]: undefined|string;
}

export function getCodePageTable(): CodePageTable {
  return {
    [37]: 'IBM037',
    [437]: 'IBM437',
    [500]: 'IBM500',
    [708]: 'ASMO-708',
    [709]: '',
    [710]: '',

* Copyright Contributors to the Zowe Project.                                     *
*                                                                                 *
*/

import * as zowe from "@brightside/core";
import { IProfileLoaded, Logger } from "@brightside/imperative";
import * as path from "path";
import * as vscode from "vscode";
import * as nls from "vscode-nls";
import * as extension from "../src/extension";
import { PersistentFilters } from "./PersistentFilters";
import { Profiles } from "./Profiles";
import { sortTreeItems, applyIcons, FilterDescriptor, FilterItem, getAppName, resolveQuickPickHelper } from "./utils";
import { IZoweTree } from "./ZoweTree";
import { ZoweNode } from "./ZoweNode";
const localize = nls.config({ messageFormat: nls.MessageFormat.file })();

/**
 * Creates the Dataset tree that contains nodes of sessions and data sets
 *
 * @export
 */
export async function createDatasetTree(log: Logger) {
    const tree = new DatasetTree();
    await tree.initialize(log);
    await tree.addSession();
    return tree;
}

/**
 * A tree that contains nodes of sessions and data sets
 *

* SPDX-License-Identifier: EPL-2.0                                                *
*                                                                                 *
* Copyright Contributors to the Zowe Project.                                     *
*                                                                                 *
*/

import * as path from "path";
import * as os from "os";
import * as zowe from "@brightside/core";
import { CliProfileManager } from "@brightside/imperative";
import { TreeItem, QuickPickItem, QuickPick } from "vscode";
import * as extension from "../src/extension";
import * as nls from "vscode-nls";
import { ZoweUSSNode } from "./ZoweUSSNode";
import { ZoweNode } from "./ZoweNode";
const localize = nls.config({ messageFormat: nls.MessageFormat.file })();

/*
 * Created this file to be a place where commonly used functions will be defined.
 * I noticed we have a lot of repetition of some common
 * functionality in many places.
 */
export function applyIcons(node: TreeItem, state?: string ): any {
    let light: string;
    let dark: string;

    if ([extension.DS_PDS_CONTEXT, extension.DS_PDS_CONTEXT + extension.FAV_SUFFIX,
            extension.USS_DIR_CONTEXT,
            extension.USS_DIR_CONTEXT + extension.FAV_SUFFIX,
            extension.JOBS_JOB_CONTEXT,
            extension.JOBS_JOB_CONTEXT + extension.FAV_SUFFIX].includes(node.contextValue)) {
        if (state === extension.ICON_STATE_OPEN) {

import {populateCollection} from './diagnostics/util';
import {CMakeDriver, CMakePreconditionProblems} from '@cmt/drivers/driver';
import {expandString, ExpansionOptions} from './expand';
import {CMakeGenerator, Kit} from './kit';
import {LegacyCMakeDriver} from '@cmt/drivers/legacy-driver';
import * as logging from './logging';
import {fs} from './pr';
import {buildCmdStr} from './proc';
import {Property} from './prop';
import rollbar from './rollbar';
import * as telemetry from './telemetry';
import {setContextValue} from './util';
import {VariantManager} from './variant';
import * as nls from 'vscode-nls';

nls.config({ messageFormat: nls.MessageFormat.bundle, bundleFormat: nls.BundleFormat.standalone })();
const localize: nls.LocalizeFunc = nls.loadMessageBundle();

const open = require('open') as ((url: string, appName?: string, callback?: Function) => void);

const log = logging.createLogger('main');
const BUILD_LOGGER = logging.createLogger('build');
const CMAKE_LOGGER = logging.createLogger('cmake');

enum ConfigureType {
  Normal,
  Clean,
}

/**
 * Class implementing the extension. It's all here!
 *