modpack-lock 0.4.0 → 0.5.0

package/src/modpack_info.js

@@ -1,135 +1,215 @@
 import prompts from 'prompts';
 import slugify from 'slugify';
 import * as config from './config/index.js';
+import { getLicenseList, getLicenseText } from './github_interactions.js';
+import { getMinecraftVersions, getModloaders } from './modrinth_interactions.js';
+
+/**
+ * @typedef {import('./config/types.js').ModpackInfo} ModpackInfo
+ */
+
+/**
+* Capitalizes a string
+*/
+function capitalize(string) {
+    return `${string.charAt(0).toUpperCase()}${string.slice(1)}`;
+}
 
 /**
  * Validate that a value is not empty
  */
 function validateNotEmpty(value, field) {
-    if (value.trim().length === 0) {
+    if (value === undefined || value?.trim().length === 0) {
         return `${field} cannot be empty`;
     }
     return true;
 }
 
 /**
- * @typedef {import('./config/types.js').ModpackInfo} ModpackInfo
- * @typedef {import('./config/types.js').Options} Options
- * @typedef {import('./config/types.js').Lockfile} Lockfile
+* Returns a required text prompt
+*/
+function requiredText(name, message, initial) {
+    return {
+        type: 'text',
+        name: name,
+        message: `${capitalize(message)}`,
+        initial: initial,
+        validate: (value) => {
+            return validateNotEmpty(value, name);
+        }
+    }
+}
+
+/**
+* Returns an optional text prompt
+*/
+function optionalText(name, message, initial) {
+    return {
+        type: 'text',
+        name: name,
+        message: `${capitalize(message)}`,
+        initial: initial,
+    }
+}
+
+/**
+ * Get an other answer from the user
  */
+async function getOtherAnswer(value, message, initial) {
+    if (value && value !== config.OTHER_OPTION.value) {
+        return value;
+    }
+    const question = await prompts(
+        requiredText(
+            'other',
+            message,
+            initial
+        ),
+        config.PROMPTS_OPTIONS
+    );
+
+    return question.other || config.OTHER_OPTION.value;
+}
+
+/**
+* Returns a required autocomplete prompt with a fallback to the other option
+*/
+function requiredAutocomplete(name, message, initial, choices, defaultValue) {
+    initial = initial || defaultValue || config.OTHER_OPTION.value;
+    if (initial && !choices.some(choice => choice.value === initial)) {
+        choices.push({ title: initial, value: initial });
+    }
+
+    return {
+        type: 'autocomplete',
+        name: name,
+        message: `${capitalize(message)}`,
+        initial: initial,
+        choices: choices,
+        fallback: config.OTHER_OPTION.value,
+        format: async (value) => {
+            return await getOtherAnswer(value, ` └─𜰙 Other ${message}`, initial);
+        }
+    }
+}
+
+/**
+* Returns an confirmation prompt to generate an optional file
+*/
+function fileGenerationConfirm(name, message, showPrompt) {
+    return {
+        type: showPrompt ? 'confirm' : null,
+        name: name,
+        message: `${capitalize(message)}`,
+        initial: true,
+    }
+}
 
 /**
  * Get user input for modpack information
  * @param {ModpackInfo} defaults - The initial/default modpack information
  * @returns {Promise<ModpackInfo>} The modpack information from the user
  */
-export default async function promptUserForInfo(defaults = {}) {
-    let name = await prompts({
-        type: 'text',
-        name: 'name',
-        message: 'Modpack name',
-        initial: defaults.name,
-        validate: (value) => {
-            return validateNotEmpty(value, 'Name');
-        },
-    });
-    let version = await prompts({
-        type: 'text',
-        name: 'version',
-        message: 'Modpack version',
-        initial: defaults.version || config.DEFAULT_MODPACK_VERSION,
-        validate: (value) => {
-            return validateNotEmpty(value, 'Version');
-        },
-    });
-    let id = await prompts({
-        type: 'text',
-        name: 'id',
-        message: 'Modpack slug/ID',
-        initial: slugify(defaults.id || name.name, config.SLUGIFY_OPTIONS),
-        validate: (value) => {
-            return validateNotEmpty(value, 'ID');
-        },
-    });
-    let description = await prompts({
-        type: 'text',
-        name: 'description',
-        message: 'Modpack description',
-        initial: defaults.description,
-    });
-    let author = await prompts({
-        type: 'text',
-        name: 'author',
-        message: 'Modpack author',
-        initial: defaults.author,
-        validate: (value) => {
-            return validateNotEmpty(value, 'Author');
-        },
-    });
+export async function promptUserForInfo(defaults = {}) {
+    const licenseList = await getLicenseList();
+    const minecraftVersions = await getMinecraftVersions();
+    const modloaders = await getModloaders();
     let answers = await prompts([
-        {
-            type: 'text',
-            name: 'projectUrl',
-            message: 'Modpack URL',
-            initial: defaults.projectUrl || config.DEFAULT_PROJECT_URL(id.id),
-        },
-        {
-            type: 'text',
-            name: 'sourceUrl',
-            message: 'Modpack source code URL',
-            initial: defaults.sourceUrl || config.DEFAULT_SOURCE_URL(id.id, author.author),
-        },
-        {
-            type: 'text',
-            name: 'license',
-            message: 'Modpack license',
-            initial: defaults.license || config.DEFAULT_MODPACK_LICENSE,
-        },
-        {
-            type: 'autocomplete',
-            name: 'modloader',
-            message: 'Modpack modloader',
-            initial: defaults.modloader,
-            choices: [
-                { title: 'fabric' },
-                { title: 'forge' },
-                { title: 'quilt' },
-                { title: 'neoforge' },
-                { title: 'sponge' },
-                { title: 'paper' },
-                { title: 'velocity' },
-                { title: 'bungeecord' },
-                { title: 'waterfall' },
-                { title: 'travertia' },
-                { title: 'nukkit' },
-                { title: 'pufferfish' },
-                { title: 'purpur' },
-            ],
-            validate: (value) => {
-                return validateNotEmpty(value, 'Modloader');
-            },
-        },
-        {
-            type: 'text',
-            name: 'targetModloaderVersion',
-            message: 'Target modloader version',
-            initial: defaults.targetModloaderVersion,
-        },
-        {
-            type: 'text',
-            name: 'targetMinecraftVersion',
-            message: 'Target Minecraft version',
-            initial: defaults.targetMinecraftVersion,
-            validate: (value) => {
-                return validateNotEmpty(value, 'Minecraft Version');
-            },
-        }
-    ]);
+        requiredText(
+            'name',
+            config.infoFields.name.prompt,
+            defaults.name
+        ),
+        requiredText(
+            'version',
+            config.infoFields.version.prompt,
+            defaults.version || config.DEFAULT_MODPACK_VERSION
+        ),
+        requiredText(
+            'id',
+            config.infoFields.id.prompt,
+            (prev, values) => slugify(defaults.id || values.name, config.SLUGIFY_OPTIONS)
+        ),
+        optionalText(
+            'description',
+            config.infoFields.description.prompt,
+            defaults.description
+        ),
+        requiredText(
+            'author',
+            config.infoFields.author.prompt,
+            defaults.author
+        ),
+        optionalText(
+            'projectUrl',
+            config.infoFields.projectUrl.prompt,
+            (prev, values) => defaults.projectUrl || config.DEFAULT_PROJECT_URL(values.id)
+        ),
+        optionalText(
+            'sourceUrl',
+            config.infoFields.sourceUrl.prompt,
+            (prev, values) => defaults.sourceUrl || config.DEFAULT_SOURCE_URL(values.id, values.author)
+        ),
+        requiredAutocomplete(
+            'license',
+            config.infoFields.license.prompt,
+            defaults.license,
+            licenseList,
+            config.DEFAULT_MODPACK_LICENSE
+        ),
+        requiredAutocomplete(
+            'modloader',
+            config.infoFields.modloader.prompt,
+            defaults.modloader,
+            modloaders,
+            config.FALLBACK_MODLOADERS[0].value
+        ),
+        optionalText(
+            'targetModloaderVersion',
+            config.infoFields.targetModloaderVersion.prompt,
+            defaults.targetModloaderVersion
+        ),
+        requiredAutocomplete(
+            'targetMinecraftVersion',
+            config.infoFields.targetMinecraftVersion.prompt,
+            defaults.targetMinecraftVersion,
+            minecraftVersions,
+            minecraftVersions[0].value
+        )
+    ], config.PROMPTS_OPTIONS);
 
-    let modpackInfo = {...name, ...version, ...id, ...description, ...author, ...answers};
-    if (Object.keys(modpackInfo).length < 11) {
-        console.warn('Modpack initialization was interrupted');
-        process.exit(1);
-    }
-    return modpackInfo;
+    return answers;
+}
+
+/**
+ * Prompt the user about adding the license text to the modpack
+ * @param {ModpackInfo} modpackInfo - The modpack information
+ * @returns {Promise<Object>} The answers from the user
+ */
+export async function promptUserAboutOptionalFiles(modpackInfo, defaults = {}) {
+
+    const licenseText = await getLicenseText(modpackInfo.license);
+    const answers = await (prompts([
+        fileGenerationConfirm(
+            'addLicense',
+            `${config.fileFields.addLicense.prompt}?`,
+            licenseText && defaults.addLicense === undefined
+        ),
+        fileGenerationConfirm(
+            'addReadme',
+            `${config.fileFields.addReadme.prompt}?`,
+            defaults.addReadme === undefined
+        ),
+        fileGenerationConfirm(
+            'addGitignore',
+            `${config.fileFields.addGitignore.prompt}?`,
+            defaults.addGitignore === undefined
+        ),
+    ], config.PROMPTS_OPTIONS));
+
+    answers.addLicense = answers.addLicense === undefined ? (licenseText ? defaults.addLicense : false) : answers.addLicense;
+    answers.addReadme = answers.addReadme === undefined ? defaults.addReadme : answers.addReadme;
+    answers.addGitignore = answers.addGitignore === undefined ? defaults.addGitignore : answers.addGitignore;
+
+    return answers;
 }

package/src/modrinth_interactions.js

@@ -38,7 +38,7 @@ export async function getVersionsFromHashes(hashes) {
 
         return await response.json();
     } catch (error) {
-        console.error(`Error querying Modrinth API: ${error.message}`);
+        console.error(`Error fetching version information from hashes: ${error.message}`);
         throw error;
     }
 }
@@ -106,3 +106,59 @@ export async function getUsers(userIds) {
 
     return results;
 }
+
+/**
+ * Fetch Minecraft versions from Modrinth
+ * @returns {Promise<Array<Object>>} The Minecraft versions
+ */
+export async function getMinecraftVersions() {
+    try {
+        const url = config.MODRINTH_MINECRAFT_VERSIONS_ENDPOINT;
+        const response = await fetch(url);
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Modrinth API error (${response.status}): ${errorText}`);
+        }
+
+        const json = await response.json();
+        if (json) {
+            //sort by version type (in the order of the MINECRAFT_VERSION_TYPES array)
+            json.sort((a, b) => {
+                return config.MINECRAFT_VERSION_TYPES.indexOf(a.version_type) - config.MINECRAFT_VERSION_TYPES.indexOf(b.version_type);
+            });
+            return json.map(version => ({ title: version.version, value: version.version }));
+        } else {
+            throw new Error();
+        }
+        return null;
+    } catch (error) {
+        console.warn(`Warning: could not fetch Minecraft versions. Using fallbacks.`, error);
+        return config.FALLBACK_TARGET_MINECRAFT_VERSIONS;
+    }
+}
+
+/**
+ * Fetch Modloaders from Modrinth
+ * @returns {Promise<Array<Object>>} The Modloaders
+ */
+export async function getModloaders() {
+    try {
+        const url = config.MODRINTH_MODLOADERS_ENDPOINT;
+        const response = await fetch(url);
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Modrinth API error (${response.status}): ${errorText}`);
+        }
+
+        const json = await response.json();
+        if (json) {
+            return json.map(loader => ({ title: loader.name, value: loader.name }));
+        } else {
+            throw new Error();
+        }
+        return null;
+    } catch (error) {
+        console.warn(`Warning: could not fetch Modloaders. Using fallbacks.`, error);
+        return config.FALLBACK_MODLOADERS;
+    }
+}