Move many things over from Knossos (and other rearrangements) (#102)

lib/helpers/index.js

@@ -1,3 +1,5 @@
 export * from './highlight.js'
 export * from './parse.js'
+export * from './projects.js'
+export * from './users.js'
 export * from './utils.js'

lib/helpers/parse.js

@@ -95,7 +95,9 @@ export const configuredXss = new xss.FilterXSS({
           return xss.safeAttrValue(
             tag,
             name,
-            `https://wsrv.nl/?url=${encodeURIComponent(url.toString())}&n=-1`,
+            `https://wsrv.nl/?url=${encodeURIComponent(
+              url.toString().replaceAll('&', '&')
+            )}&n=-1`,
             cssFilter
           )
         } else {

lib/helpers/projects.js

@@ -0,0 +1,109 @@
+// noinspection JSUnusedGlobalSymbols
+
+export const getProjectTypeForDisplay = (type, categories, tags) => {
+  if (type === 'mod') {
+    const isPlugin = categories.some((category) => {
+      return tags.loaderData.allPluginLoaders.includes(category)
+    })
+    const isMod = categories.some((category) => {
+      return tags.loaderData.modLoaders.includes(category)
+    })
+    const isDataPack = categories.some((category) => {
+      return tags.loaderData.dataPackLoaders.includes(category)
+    })
+
+    if (isMod && isPlugin && isDataPack) {
+      return 'mod, plugin, and data pack'
+    } else if (isMod && isPlugin) {
+      return 'mod and plugin'
+    } else if (isMod && isDataPack) {
+      return 'mod and data pack'
+    } else if (isPlugin && isDataPack) {
+      return 'plugin and data pack'
+    } else if (isDataPack) {
+      return 'data pack'
+    } else if (isPlugin) {
+      return 'plugin'
+    }
+  }
+
+  return type
+}
+
+export const getProjectTypeForUrl = (type, loaders, tags) => {
+  if (type === 'mod') {
+    const isMod = loaders.some((category) => {
+      return tags.loaderData.modLoaders.includes(category)
+    })
+
+    const isPlugin = loaders.some((category) => {
+      return tags.loaderData.allPluginLoaders.includes(category)
+    })
+
+    const isDataPack = loaders.some((category) => {
+      return tags.loaderData.dataPackLoaders.includes(category)
+    })
+
+    if (isDataPack) {
+      return 'datapack'
+    } else if (isPlugin) {
+      return 'plugin'
+    } else if (isMod) {
+      return 'mod'
+    } else {
+      return 'mod'
+    }
+  } else {
+    return type
+  }
+}
+
+export const getProjectLink = (project) => {
+  return `/${getProjectTypeForUrl(project.project_type, project.loaders)}/${
+    project.slug ? project.slug : project.id
+  }`
+}
+
+export const getVersionLink = (project, version) => {
+  if (version) {
+    return getProjectLink(project) + '/version/' + version.id
+  } else {
+    return getProjectLink(project)
+  }
+}
+
+export const isApproved = (project) => {
+  return project && APPROVED_PROJECT_STATUSES.includes(project.status)
+}
+
+export const isListed = (project) => {
+  return project && LISTED_PROJECT_STATUSES.includes(project.status)
+}
+
+export const isUnlisted = (project) => {
+  return project && UNLISTED_PROJECT_STATUSES.includes(project.status)
+}
+
+export const isPrivate = (project) => {
+  return project && PRIVATE_PROJECT_STATUSES.includes(project.status)
+}
+
+export const isRejected = (project) => {
+  return project && REJECTED_PROJECT_STATUSES.includes(project.status)
+}
+
+export const isUnderReview = (project) => {
+  return project && UNDER_REVIEW_PROJECT_STATUSES.includes(project.status)
+}
+
+export const isDraft = (project) => {
+  return project && DRAFT_PROJECT_STATUSES.includes(project.status)
+}
+
+export const APPROVED_PROJECT_STATUSES = ['approved', 'archived', 'unlisted', 'private']
+export const LISTED_PROJECT_STATUSES = ['approved', 'archived']
+export const UNLISTED_PROJECT_STATUSES = ['unlisted', 'withheld']
+export const PRIVATE_PROJECT_STATUSES = ['private', 'rejected', 'processing']
+export const REJECTED_PROJECT_STATUSES = ['rejected', 'withheld']
+export const UNDER_REVIEW_PROJECT_STATUSES = ['processing']
+export const DRAFT_PROJECT_STATUSES = ['draft']

lib/helpers/users.js

@@ -0,0 +1,11 @@
+// noinspection JSUnusedGlobalSymbols
+
+export const getUserLink = (user) => {
+  return `/user/${user.username}`
+}
+
+export const isStaff = (user) => {
+  return user && STAFF_ROLES.includes(user.role)
+}
+
+export const STAFF_ROLES = ['moderator', 'admin']

lib/helpers/utils.js

@@ -1,3 +1,81 @@
+// noinspection JSUnusedGlobalSymbols
+
+import dayjs from 'dayjs'
+
+export const external = (cosmetics) => (cosmetics.externalLinksNewTab ? '_blank' : '')
+
+// Only use on the complete list of versions for a project,
+// partial lists will generate the wrong version slugs
+export const computeVersions = (versions, members) => {
+  const visitedVersions = []
+  const returnVersions = []
+  const authorMembers = {}
+
+  for (const version of versions.sort(
+    (a, b) => dayjs(a.date_published) - dayjs(b.date_published)
+  )) {
+    if (visitedVersions.includes(version.version_number)) {
+      visitedVersions.push(version.version_number)
+      version.displayUrlEnding = version.id
+    } else {
+      visitedVersions.push(version.version_number)
+      version.displayUrlEnding = version.version_number
+    }
+    version.primaryFile = version.files.find((file) => file.primary) ?? version.files[0]
+
+    if (!version.primaryFile) {
+      version.primaryFile = {
+        hashes: {
+          sha1: '',
+          sha512: '',
+        },
+        url: '#',
+        filename: 'unknown',
+        primary: false,
+        size: 0,
+        file_type: null,
+      }
+    }
+
+    version.author = authorMembers[version.author_id]
+    if (!version.author) {
+      version.author = members.find((x) => x.user.id === version.author_id)
+      authorMembers[version.author_id] = version.author
+    }
+
+    returnVersions.push(version)
+  }
+
+  return returnVersions
+    .reverse()
+    .map((version, index) => {
+      const nextVersion = returnVersions[index + 1]
+      if (nextVersion && version.changelog && nextVersion.changelog === version.changelog) {
+        return { duplicate: true, ...version }
+      } else {
+        return { duplicate: false, ...version }
+      }
+    })
+    .sort((a, b) => dayjs(b.date_published) - dayjs(a.date_published))
+}
+
+export const sortedCategories = (tags) => {
+  return tags.categories.slice().sort((a, b) => {
+    const headerCompare = a.header.localeCompare(b.header)
+    if (headerCompare !== 0) {
+      return headerCompare
+    }
+    if (a.header === 'resolutions' && b.header === 'resolutions') {
+      return a.name.replace(/\D/g, '') - b.name.replace(/\D/g, '')
+    } else if (a.header === 'performance impact' && b.header === 'performance impact') {
+      const x = ['potato', 'low', 'medium', 'high', 'screenshot']
+
+      return x.indexOf(a.name) - x.indexOf(b.name)
+    }
+    return 0
+  })
+}
+
 export const formatNumber = (number, abbreviate = true) => {
   const x = +number
   if (x >= 1000000 && abbreviate) {
@@ -66,6 +144,8 @@ export const formatCategory = (name) => {
     return 'BungeeCord'
   } else if (name === 'liteloader') {
     return 'LiteLoader'
+  } else if (name === 'neoforge') {
+    return 'NeoForge'
   } else if (name === 'game-mechanics') {
     return 'Game Mechanics'
   } else if (name === 'worldgen') {
@@ -101,7 +181,7 @@ export const formatCategoryHeader = (name) => {
 
 export const formatProjectStatus = (name) => {
   if (name === 'approved') {
-    return 'Listed'
+    return 'Public'
   } else if (name === 'processing') {
     return 'Under review'
   }
@@ -109,8 +189,8 @@ export const formatProjectStatus = (name) => {
   return capitalizeString(name)
 }
 
-export const formatVersions = (versionArray, store) => {
-  const allVersions = store.state.tag.gameVersions.slice().reverse()
+export const formatVersions = (versionArray, gameVersions) => {
+  const allVersions = gameVersions.slice().reverse()
   const allReleases = allVersions.filter((x) => x.version_type === 'release')
 
   const intervals = []
@@ -176,13 +256,13 @@ export const formatVersions = (versionArray, store) => {
 
   for (const interval of newIntervals) {
     if (interval.length === 2) {
-      output.push(`${interval[0][0]}—${interval[1][0]}`)
+      output.push(`${interval[0][0]}–${interval[1][0]}`)
     } else {
       output.push(interval[0][0])
     }
   }
 
-  return output.join(', ')
+  return (output.length === 0 ? versionArray : output).join(', ')
 }
 
 export function cycleValue(value, values) {