Contents

function init(context) {
  // You can't call api functionality directly inside the init function (the api isn't ready at that point)
  // context.once is executed only 'once', after the API finished loading and it's therefore safe to show the dialog.
  context.once(() => {
    context.api.showDialog(
      'question', // This is the type
      'Enter the expected result', // This is the title
      { text: '2 + 2 = ?' }, // This is the content
      [ { label: '3', default: true }, { label: '4' } ], // These are the actions
      'this-is-the-dialog-id') // Dialog id
      .then((result) => {
        // Dialogs are asynchronous and can be used to block functionality (i.e. mod installation) until the user clicks a button.
        if (result['action'] === '3') { // Notice we're using the label value to identify which button was pressed.
          // Tell the user he's wrong.
        } else {
          // Tell the user he's right.
        }
      });
  });
  return true;

const path = require('path');
const { fs, util } = require('vortex-api');

function prepareForModding(api, discovery) {
  return api.showDialog(
    'question', // type
    'Some Mod Loader is Needed', // title
    { text: 'This game requires a mod loader for mods to function correctly, please download the mod loader using the buttons below' }, // content
    [ { label: 'Download', default: true }, { label: 'Close' } ]) // Actions
    .then((result) => {
      // We don't actually download the dependency for them, we just
      //  open up an external browser with the proper url so they can download it manually
      //  from there.
      return (result['action'] === 'Download')
        ? util.opn('www.someWebsite.com')
        : Promise.reject(new util.UserCanceled());
    })
    // Below code will only run if the user chooses to download the mod loader.
    //  Given that we return a rejected promise if the user chooses not to download the
    //  mod loader, the game extension will not load. We could just return a resolved promise
    //  instead and allow the user to manage the game in Vortex even without the mod loader.
    .then(() => fs.ensureDirAsync(path.join(discovery.path, MODS_PATH)));
}

function init(context) {
  context.registerGame({
    ...
    // Omitted all other required game properties as we only want to
    //  touch upon the setup stage of the game extension which is run
    //  whenever the game mode is activated within Vortex.
    //
    // The setup callback will provide the game extension with the
    //  game's discovery information (game path, tools, etc)
    //  but in order to show the dialog in the game's setup stage we will
    //  need to forward the api object to the extension function that
    //  deals with the setup, in this case we called it 'prepareForModding'.
    setup: (discovery) => prepareForModding(context.api, discovery),
  });

  return true;
}

module.exports = {
  default: init
};

api.showDialog('question', 'Authentication Required, {
      text: 'Please provide a username and password'
      input: [
        { id: 'Username', type: 'text', label: 'Username' },
        { id: 'Password', type: 'password', label: 'Password' },
      ],
      condition: (content) => {
       // Loop through the input fields and make sure the user
       //  provided a value.
        const errors = content.input.map((inp) => {
          if (!inp.value) {
            return {
              actions: ['Continue'], // The action/button we want to disable
              errorText: `${inp.label} field is empty`, // Tell the user what went wrong
              id: inp.id, // this needs to be the id of the input so that Vortex highlights it as invalid
            };
          } else {
            return undefined;
          }
        }).filter(err => err !== undefined);
        return errors;
      }
    }, [
      { label: 'Cancel' },
      { label: 'Continue', default: true },
    ]).then(res => {
      if (res.action === 'Cancel') {
        return Promise.reject(new util.UserCanceled());
      } else {
          // access the username input field value
          res.input['Username']; 
          // access the password input field value
          res.input['Password'];
      }
    })

const Bluebird = require('bluebird');
const { util } = require('vortex-api');

async function installZipContent(files, destinationPath) {
    // first of all we need to cater for any double-zipped files. They're technically already in a format that
    // the game supports so we can just install those files as they are.
    const zipFiles = files.filter(file => ['.zip', '.7z'].includes(path.extname(file)));
    // If it's a double zip, we don't need to repack. 
    if (zipFiles.length > 0) {
        const instructions = zipFiles.map(file => {
            return {
                type: 'copy',
                source: file,
                destination: path.basename(file),
            }
        });
        return Promise.resolve({ instructions });
    }
    // The mod archive contains loose files, we need to repack it.
    else {
        // Create the 7zip instance - note this is using 'util' as imported from the 'vortex-api' module
        const szip = new util.SevenZip();

        // Define the name of the newly created archive and make sure it's placed inside the current destination path.
        const archiveName = path.basename(destinationPath, '.installing') + '.zip';
        const archivePath = path.join(destinationPath, archiveName);

        // Read the contents of the destination path (the extracted mod's root path). This does not have
        //  to be recursive unless you're planning on changing the structure of the archive.
        const rootRelPaths = await fs.readdirAsync(destinationPath);

        // Tell the 7zip module to add the files (and folders) we found in the mod's root directory. Note that
        //  we specify an optional 'raw' property. The Vortex 7zip module acts as a JS wrapper for the 7zip
        //  application, the 'raw' property simply adds the recursive switch '-r' as used with the 7zip command line
        //  interface; this tells 7zip to go through any directories recursively and maintain the folder structure it finds
        //  when adding the filepaths.
        await szip.add(archivePath, rootRelPaths.map(relPath => path.join(destinationPath, relPath)), { raw: ['-r'] });

        // The installer instructions should only copy over the archive we just created.
        const instructions = [{
            type: 'copy',
            source: archiveName,
            destination: path.basename(archivePath),
        }];
        return Promise.resolve({ instructions });
    }
}

// Conversion function from global promises to Bluebird promises.
function toBlue(func) {
  return (...args) => Bluebird.Promise.resolve(func(...args));
}

function main(context) {
  context.registerInstaller('doom-zip-mod', 25, toBlue(testZipContent), toBlue(installZipContent));
  return true;
}

function toBlue(func) {
  return (...args) => Bluebird.resolve(func(...args));
}

const trending = await api.ext.nexusGetTrendingMods('fallout4');`
console.log('trending:', trending.mods);