17f00e6fea
* Fool behavior * Add leading underscore to packaged datapack package if it starts with a number * Hide mod status card for all approved statuses without mod messages * Fix project id sanitization
574 lines
16 KiB
JavaScript
574 lines
16 KiB
JavaScript
import JSZip from 'jszip'
|
|
import TOML from '@iarna/toml'
|
|
import yaml from 'js-yaml'
|
|
import { formatBytes } from '~/plugins/shorthands'
|
|
|
|
/**
|
|
* @param {File | Blob} file the file to validate
|
|
* @param {{ maxSize: number, alertOnInvalid: boolean }} validationOptions the
|
|
* constraints to validate the file against
|
|
* @param validationOptions.maxSize the max file size in bytes
|
|
* @param validationOptions.alertOnInvalid if an alert should pop up describing
|
|
* each validation error
|
|
* @returns `true` if the file is valid; `false` otherwise
|
|
*/
|
|
export const fileIsValid = (file, validationOptions) => {
|
|
const { maxSize, alertOnInvalid } = validationOptions
|
|
if (maxSize !== null && maxSize !== undefined && file.size > maxSize) {
|
|
if (alertOnInvalid) {
|
|
alert(
|
|
`File ${file.name} is too big! Must be less than ${formatBytes(
|
|
maxSize
|
|
)}`
|
|
)
|
|
}
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
export const acceptFileFromProjectType = (projectType) => {
|
|
switch (projectType) {
|
|
case 'mod':
|
|
return '.jar,.zip,.litemod,application/java-archive,application/x-java-archive,application/zip'
|
|
case 'plugin':
|
|
return '.jar,.zip,application/java-archive,application/x-java-archive,application/zip'
|
|
case 'resourcepack':
|
|
return '.zip,application/zip'
|
|
case 'shader':
|
|
return '.zip,application/zip'
|
|
case 'datapack':
|
|
return '.zip,application/zip'
|
|
case 'modpack':
|
|
return '.mrpack,application/x-modrinth-modpack+zip,application/zip'
|
|
default:
|
|
return '*'
|
|
}
|
|
}
|
|
|
|
export const inferVersionInfo = async function (
|
|
rawFile,
|
|
project,
|
|
gameVersions
|
|
) {
|
|
function versionType(number) {
|
|
if (number.includes('alpha')) {
|
|
return 'alpha'
|
|
} else if (
|
|
number.includes('beta') ||
|
|
number.match(/[^A-z](rc)[^A-z]/) || // includes `rc`
|
|
number.match(/[^A-z](pre)[^A-z]/) // includes `pre`
|
|
) {
|
|
return 'beta'
|
|
} else {
|
|
return 'release'
|
|
}
|
|
}
|
|
|
|
// TODO: This func does not handle accurate semver parsing. We should eventually
|
|
function gameVersionRange(gameVersionString, gameVersions) {
|
|
if (!gameVersionString) {
|
|
return []
|
|
}
|
|
|
|
// Truncate characters after `-` & `+`
|
|
const gameString = gameVersionString.replace(/-|\+.*$/g, '')
|
|
|
|
let prefix = ''
|
|
if (gameString.includes('~')) {
|
|
// Include minor versions
|
|
// ~1.2.3 -> 1.2
|
|
prefix = gameString.replace('~', '').split('.').slice(0, 2).join('.')
|
|
} else if (gameString.includes('>=')) {
|
|
// Include minor versions
|
|
// >=1.2.3 -> 1.2
|
|
prefix = gameString.replace('>=', '').split('.').slice(0, 2).join('.')
|
|
} else if (gameString.includes('^')) {
|
|
// Include major versions
|
|
// ^1.2.3 -> 1
|
|
prefix = gameString.replace('^', '').split('.')[0]
|
|
} else if (gameString.includes('x')) {
|
|
// Include versions that match `x.x.x`
|
|
// 1.2.x -> 1.2
|
|
prefix = gameString.replace(/\.x$/, '')
|
|
} else {
|
|
// Include exact version
|
|
// 1.2.3 -> 1.2.3
|
|
prefix = gameString
|
|
}
|
|
|
|
const simplified = gameVersions
|
|
.filter((it) => it.version_type === 'release')
|
|
.map((it) => it.version)
|
|
return simplified.filter((version) => version.startsWith(prefix))
|
|
}
|
|
|
|
const inferFunctions = {
|
|
// Forge 1.13+
|
|
'META-INF/mods.toml': async (file, zip) => {
|
|
const metadata = TOML.parse(file)
|
|
|
|
// TODO: Parse minecraft version ranges, handle if version is set to value from manifest
|
|
if (metadata.mods && metadata.mods.length > 0) {
|
|
let versionNum = metadata.mods[0].version
|
|
|
|
// ${file.jarVersion} -> Implementation-Version from manifest
|
|
const manifestFile = zip.file('META-INF/MANIFEST.MF')
|
|
if (
|
|
// eslint-disable-next-line no-template-curly-in-string
|
|
metadata.mods[0].version.includes('${file.jarVersion}') &&
|
|
manifestFile !== null
|
|
) {
|
|
const manifestText = await manifestFile.async('text')
|
|
const regex = /Implementation-Version: (.*)$/m
|
|
const match = manifestText.match(regex)
|
|
if (match) {
|
|
// eslint-disable-next-line no-template-curly-in-string
|
|
versionNum = versionNum.replace('${file.jarVersion}', match[1])
|
|
}
|
|
}
|
|
|
|
return {
|
|
name: `${project.title} ${versionNum}`,
|
|
version_number: versionNum,
|
|
version_type: versionType(versionNum),
|
|
loaders: ['forge'],
|
|
}
|
|
} else {
|
|
return {}
|
|
}
|
|
},
|
|
// Old Forge
|
|
'mcmod.info': (file) => {
|
|
const metadata = JSON.parse(file)
|
|
|
|
return {
|
|
name: metadata.version ? `${project.title} ${metadata.version}` : '',
|
|
version_number: metadata.version,
|
|
version_type: versionType(metadata.version),
|
|
loaders: ['forge'],
|
|
game_versions: gameVersions
|
|
.filter(
|
|
(x) =>
|
|
x.version.startsWith(metadata.mcversion) &&
|
|
x.version_type === 'release'
|
|
)
|
|
.map((x) => x.version),
|
|
}
|
|
},
|
|
// Fabric
|
|
'fabric.mod.json': (file) => {
|
|
const metadata = JSON.parse(file)
|
|
|
|
return {
|
|
name: `${project.title} ${metadata.version}`,
|
|
version_number: metadata.version,
|
|
loaders: ['fabric'],
|
|
version_type: versionType(metadata.version),
|
|
game_versions: metadata.depends
|
|
? gameVersionRange(metadata.depends.minecraft, gameVersions)
|
|
: [],
|
|
}
|
|
},
|
|
// Quilt
|
|
'quilt.mod.json': (file) => {
|
|
const metadata = JSON.parse(file)
|
|
|
|
return {
|
|
name: `${project.title} ${metadata.quilt_loader.version}`,
|
|
version_number: metadata.quilt_loader.version,
|
|
loaders: ['quilt'],
|
|
version_type: versionType(metadata.quilt_loader.version),
|
|
game_versions: metadata.quilt_loader.depends
|
|
? gameVersionRange(
|
|
metadata.quilt_loader.depends.find((x) => x.id === 'minecraft')
|
|
? metadata.quilt_loader.depends.find(
|
|
(x) => x.id === 'minecraft'
|
|
).versions
|
|
: [],
|
|
gameVersions
|
|
)
|
|
: [],
|
|
}
|
|
},
|
|
// Bukkit + Other Forks
|
|
'plugin.yml': (file) => {
|
|
const metadata = yaml.load(file)
|
|
|
|
return {
|
|
name: `${project.title} ${metadata.version}`,
|
|
version_number: metadata.version,
|
|
version_type: versionType(metadata.version),
|
|
// We don't know which fork of Bukkit users are using
|
|
loaders: [],
|
|
game_versions: gameVersions
|
|
.filter(
|
|
(x) =>
|
|
x.version.startsWith(metadata['api-version']) &&
|
|
x.version_type === 'release'
|
|
)
|
|
.map((x) => x.version),
|
|
}
|
|
},
|
|
// Bungeecord + Waterfall
|
|
'bungee.yml': (file) => {
|
|
const metadata = yaml.load(file)
|
|
|
|
return {
|
|
name: `${project.title} ${metadata.version}`,
|
|
version_number: metadata.version,
|
|
version_type: versionType(metadata.version),
|
|
loaders: ['bungeecord'],
|
|
}
|
|
},
|
|
// Modpacks
|
|
'modrinth.index.json': (file) => {
|
|
const metadata = JSON.parse(file)
|
|
|
|
const loaders = []
|
|
if ('forge' in metadata.dependencies) loaders.push('forge')
|
|
if ('fabric-loader' in metadata.dependencies) loaders.push('fabric')
|
|
if ('quilt-loader' in metadata.dependencies) loaders.push('quilt')
|
|
|
|
return {
|
|
name: `${project.title} ${metadata.versionId}`,
|
|
version_number: metadata.versionId,
|
|
version_type: versionType(metadata.versionId),
|
|
loaders,
|
|
game_versions: gameVersions
|
|
.filter((x) => x.version === metadata.dependencies.minecraft)
|
|
.map((x) => x.version),
|
|
}
|
|
},
|
|
// Resource Packs + Data Packs
|
|
'pack.mcmeta': (file) => {
|
|
const metadata = JSON.parse(file)
|
|
|
|
function getRange(versionA, versionB) {
|
|
const startingIndex = gameVersions.findIndex(
|
|
(x) => x.version === versionA
|
|
)
|
|
const endingIndex = gameVersions.findIndex(
|
|
(x) => x.version === versionB
|
|
)
|
|
|
|
const final = []
|
|
const filterOnlyRelease =
|
|
gameVersions[startingIndex].version_type === 'release'
|
|
|
|
for (let i = startingIndex; i >= endingIndex; i--) {
|
|
if (
|
|
gameVersions[i].version_type === 'release' ||
|
|
!filterOnlyRelease
|
|
) {
|
|
final.push(gameVersions[i].version)
|
|
}
|
|
}
|
|
|
|
return final
|
|
}
|
|
|
|
const loaders = []
|
|
let newGameVersions = []
|
|
|
|
if (project.actualProjectType === 'mod') {
|
|
loaders.push('datapack')
|
|
|
|
switch (metadata.pack.pack_format) {
|
|
case 4:
|
|
newGameVersions = getRange('1.13', '1.14.4')
|
|
break
|
|
case 5:
|
|
newGameVersions = getRange('1.15', '1.16.1')
|
|
break
|
|
case 6:
|
|
newGameVersions = getRange('1.16.2', '1.16.5')
|
|
break
|
|
case 7:
|
|
newGameVersions = getRange('1.17', '1.17.1')
|
|
break
|
|
case 8:
|
|
newGameVersions = getRange('1.18', '1.18.1')
|
|
break
|
|
case 9:
|
|
newGameVersions.push('1.18.2')
|
|
break
|
|
case 10:
|
|
newGameVersions = getRange('1.19', '1.19.3')
|
|
break
|
|
default:
|
|
}
|
|
}
|
|
|
|
if (project.actualProjectType === 'resourcepack') {
|
|
loaders.push('minecraft')
|
|
|
|
switch (metadata.pack.pack_format) {
|
|
case 1:
|
|
newGameVersions = getRange('1.6.1', '1.8.9')
|
|
break
|
|
case 2:
|
|
newGameVersions = getRange('1.9', '1.10.2')
|
|
break
|
|
case 3:
|
|
newGameVersions = getRange('1.11', '1.12.2')
|
|
break
|
|
case 4:
|
|
newGameVersions = getRange('1.13', '1.14.4')
|
|
break
|
|
case 5:
|
|
newGameVersions = getRange('1.15', '1.16.1')
|
|
break
|
|
case 6:
|
|
newGameVersions = getRange('1.16.2', '1.16.5')
|
|
break
|
|
case 7:
|
|
newGameVersions = getRange('1.17', '1.17.1')
|
|
break
|
|
case 8:
|
|
newGameVersions = getRange('1.18', '1.18.2')
|
|
break
|
|
case 9:
|
|
newGameVersions = getRange('1.19', '1.19.2')
|
|
break
|
|
case 11:
|
|
newGameVersions = getRange('22w42a', '22w44a')
|
|
break
|
|
case 12:
|
|
newGameVersions.push('1.19.3')
|
|
break
|
|
default:
|
|
}
|
|
}
|
|
|
|
return {
|
|
loaders,
|
|
game_versions: newGameVersions,
|
|
}
|
|
},
|
|
}
|
|
|
|
const zipReader = new JSZip()
|
|
|
|
const zip = await zipReader.loadAsync(rawFile)
|
|
|
|
for (const fileName in inferFunctions) {
|
|
const file = zip.file(fileName)
|
|
|
|
if (file !== null) {
|
|
const text = await file.async('text')
|
|
return inferFunctions[fileName](text, zip)
|
|
}
|
|
}
|
|
}
|
|
|
|
export const createDataPackVersion = async function (
|
|
project,
|
|
version,
|
|
primaryFile,
|
|
members,
|
|
allGameVersions,
|
|
loaders
|
|
) {
|
|
// force version to start with number, as required by FML
|
|
const newVersionNumber = version.version_number.match(/^\d/)
|
|
? version.version_number
|
|
: `1-${version.version_number}`
|
|
|
|
const targetStartingDigitsRegex = /^(\d+)(\D+)$/g
|
|
const newSlug = `${project.slug
|
|
.replace('-', '_')
|
|
.replace(/\W/g, '')
|
|
.replace(targetStartingDigitsRegex, '$2')
|
|
.replace(/^(\d+)$/g, project.id.replace(targetStartingDigitsRegex, '$2'))
|
|
.substring(0, 63)}_mr`
|
|
|
|
const iconPath = `${project.slug}_pack.png`
|
|
|
|
const fabricModJson = {
|
|
schemaVersion: 1,
|
|
id: newSlug,
|
|
version: newVersionNumber,
|
|
name: project.title,
|
|
description: project.description,
|
|
authors: members.map((x) => x.name),
|
|
contact: {
|
|
homepage: `${process.env.domain}/${project.project_type}/${
|
|
project.slug ?? project.id
|
|
}`,
|
|
},
|
|
license: project.license.id,
|
|
icon: iconPath,
|
|
environment: '*',
|
|
depends: {
|
|
'fabric-resource-loader-v0': '*',
|
|
},
|
|
}
|
|
|
|
const quiltModJson = {
|
|
schema_version: 1,
|
|
quilt_loader: {
|
|
group: 'com.modrinth',
|
|
id: newSlug,
|
|
version: newVersionNumber,
|
|
metadata: {
|
|
name: project.title,
|
|
description: project.description,
|
|
contributors: members.reduce(
|
|
(acc, x) => ({
|
|
...acc,
|
|
[x.name]: x.role,
|
|
}),
|
|
{}
|
|
),
|
|
contact: {
|
|
homepage: `${process.env.domain}/${project.project_type}/${
|
|
project.slug ?? project.id
|
|
}`,
|
|
},
|
|
icon: iconPath,
|
|
},
|
|
intermediate_mappings: 'net.fabricmc:intermediary',
|
|
depends: [
|
|
{
|
|
id: 'quilt_resource_loader',
|
|
versions: '*',
|
|
unless: 'fabric-resource-loader-v0',
|
|
},
|
|
],
|
|
},
|
|
}
|
|
|
|
const cutoffIndex = allGameVersions.findIndex((x) => x.version === '1.18.2')
|
|
|
|
let maximumIndex = Number.MIN_VALUE
|
|
for (const val of version.game_versions) {
|
|
const index = allGameVersions.findIndex((x) => x.version === val)
|
|
if (index > maximumIndex) {
|
|
maximumIndex = index
|
|
}
|
|
}
|
|
|
|
const newForge = maximumIndex < cutoffIndex
|
|
|
|
const forgeModsToml = {
|
|
modLoader: newForge ? 'lowcodefml' : 'javafml',
|
|
loaderVersion: newForge ? '[40,)' : '[25,)',
|
|
license: project.license.id,
|
|
showAsResourcePack: false,
|
|
mods: [
|
|
{
|
|
modId: newSlug,
|
|
version: newVersionNumber,
|
|
displayName: project.title,
|
|
description: project.description,
|
|
logoFile: iconPath,
|
|
updateJSONURL: `${process.env.authURLBase.replace(
|
|
'/v2/',
|
|
''
|
|
)}/updates/${project.id}/forge_updates.json`,
|
|
credits: 'Generated by Modrinth',
|
|
authors: members.map((x) => x.name).join(', '),
|
|
displayURL: `${process.env.domain}/${project.project_type}/${
|
|
project.slug ?? project.id
|
|
}`,
|
|
},
|
|
],
|
|
}
|
|
|
|
if (project.source_url) {
|
|
quiltModJson.quilt_loader.metadata.contact.sources = project.source_url
|
|
fabricModJson.contact.sources = project.source_url
|
|
}
|
|
|
|
if (project.issues_url) {
|
|
quiltModJson.quilt_loader.metadata.contact.issues = project.issues_url
|
|
fabricModJson.contact.issues = project.issues_url
|
|
forgeModsToml.issueTrackerURL = project.issues_url
|
|
}
|
|
|
|
const primaryFileData = await (await fetch(primaryFile.url)).blob()
|
|
|
|
const primaryZipReader = new JSZip()
|
|
await primaryZipReader.loadAsync(primaryFileData)
|
|
|
|
if (loaders.includes('fabric'))
|
|
primaryZipReader.file('fabric.mod.json', JSON.stringify(fabricModJson))
|
|
if (loaders.includes('quilt'))
|
|
primaryZipReader.file('quilt.mod.json', JSON.stringify(quiltModJson))
|
|
if (loaders.includes('forge'))
|
|
primaryZipReader.file('META-INF/mods.toml', TOML.stringify(forgeModsToml))
|
|
|
|
if (!newForge && loaders.includes('forge')) {
|
|
const classFile = new Uint8Array(
|
|
await (
|
|
await fetch(
|
|
'https://cdn.modrinth.com/wrapper/ModrinthWrapperRestiched.class'
|
|
)
|
|
).arrayBuffer()
|
|
)
|
|
|
|
let binary = ''
|
|
for (let i = 0; i < classFile.byteLength; i++) {
|
|
binary += String.fromCharCode(classFile[i])
|
|
}
|
|
|
|
let sanitizedId = project.id
|
|
|
|
if (project.id.match(/^(\d+)/g)) {
|
|
sanitizedId = '_' + sanitizedId
|
|
}
|
|
|
|
sanitizedId = sanitizedId.substring(0, 8)
|
|
|
|
binary = binary
|
|
.replace(
|
|
String.fromCharCode(32) + 'needs1to1be1changed1modrinth1mod',
|
|
String.fromCharCode(newSlug.length) + newSlug
|
|
)
|
|
.replace('/wrappera/', `/${sanitizedId}/`)
|
|
|
|
const newArr = []
|
|
for (let i = 0; i < binary.length; i++) {
|
|
newArr.push(binary.charCodeAt(i))
|
|
}
|
|
|
|
primaryZipReader.file(
|
|
`com/modrinth/${sanitizedId}/ModrinthWrapper.class`,
|
|
new Uint8Array(newArr)
|
|
)
|
|
}
|
|
|
|
const resourcePack = version.files.find(
|
|
(x) => x.file_type === 'required-resource-pack'
|
|
)
|
|
|
|
const resourcePackData = resourcePack
|
|
? await (await fetch(resourcePack.url)).blob()
|
|
: null
|
|
|
|
if (resourcePackData) {
|
|
const resourcePackReader = new JSZip()
|
|
await resourcePackReader.loadAsync(resourcePackData)
|
|
|
|
for (const [path, file] of Object.entries(resourcePackReader.files)) {
|
|
if (!primaryZipReader.file(path) && !path.includes('.mcassetsroot')) {
|
|
primaryZipReader.file(path, await file.async('uint8array'))
|
|
}
|
|
}
|
|
}
|
|
|
|
if (primaryZipReader.file('pack.png')) {
|
|
primaryZipReader.file(
|
|
iconPath,
|
|
await primaryZipReader.file('pack.png').async('uint8array')
|
|
)
|
|
}
|
|
|
|
return await primaryZipReader.generateAsync({
|
|
type: 'blob',
|
|
mimeType: 'application/java-archive',
|
|
})
|
|
}
|