TCGdex/compiler
1
0
Fork 0
mirror of https://github.com/tcgdex/compiler.git synced 2025-07-28 23:19:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update in progress

Browse Source 
Signed-off-by: Avior <florian.bouillon@delta-wings.net>
This commit is contained in:
Florian Bouillon
2021-02-03 01:14:26 +01:00
parent 557dad7e33
commit 1e4a9ba9d1
27 changed files with 272 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
endpoints/cardUtil.ts
View File

@ -6,18 +6,33 @@ import { tagToTagSimple } from "./TagUtil";
import Category from "@tcgdex/sdk/interfaces/Category";
import { attackToAttackSingle } from "./attackUtil";
import { abilityToAbilitySingle } from "./abilityUtil";
import { getExpansion } from "./expansionUtil";
import { getExpansion, getExpansionFromSetName } from "./expansionUtil";
import { getSet } from "./setUtil";
import Expansion from "@tcgdex/sdk/interfaces/Expansion";
import { fetchIllustratorsSync } from "./illustratorUtil";
import TranslationUtil from "@tcgdex/sdk/TranslationUtil";
import { fetchRemoteFile } from "./util";
interface ObjectList<T = any> {
[key: string]: T
}
type RemoteData = ObjectList<ObjectList<ObjectList<boolean>>>
export async function cardToCardSimple(card: Card, lang: Langs): Promise<CardSimple> {
let image: string = undefined
const file: RemoteData = await fetchRemoteFile(`https://assets.tcgdex.net/data-${lang}.json`)
const expansion = getExpansionFromSetName(card.set.code)
if (file[expansion.code] && file[expansion.code][card.set.code] && file[expansion.code][card.set.code][card.localId]) {
const basePath = `https://assets.tcgdex.net/${lang}/${expansion.code}/${card.set.code}/${card.localId}`
image = `${basePath}/low`
}
export function cardToCardSimple(card: Card, lang: Langs): CardSimple {
return {
id: card.id,
localId: card.localId,
name: card.name[lang],
image: card.image && card.image.low[lang]
image
}
}
@ -25,14 +40,21 @@ export function getCardExpansion(card: Card): Expansion {
return getExpansion(getSet(card))
}
export function cardToCardSingle(card: Card, lang: Langs): CardSingle {
export async function cardToCardSingle(card: Card, lang: Langs): Promise<CardSingle> {
const images: {
low: string,
high?: string
} = card.image && {
low: card.image.low[lang],
high: card.image.high && card.image.high[lang]
let images: {
low: string;
high?: string;
} = undefined
const file: RemoteData = await fetchRemoteFile(`https://assets.tcgdex.net/data-${lang}.json`)
const expansion = getExpansionFromSetName(card.set.code)
if (file[expansion.code] && file[expansion.code][card.set.code] && file[expansion.code][card.set.code][card.localId]) {
const basePath = `https://assets.tcgdex.net/${lang}/${expansion.code}/${card.set.code}/${card.localId}`
images = {
low: `${basePath}/low`,
high: `${basePath}/high`
}
}
return {

2
endpoints/cards/index.ts
View File

@ -19,7 +19,7 @@ export default async () => {
if (!isCardAvailable(card, lang)) continue
items.push(
cardToCardSimple(card, lang)
await cardToCardSimple(card, lang)
)
// if (if (typeof card.set.availability === "undefined"))

8
endpoints/cards/item.ts
View File

@ -17,8 +17,12 @@ export default async () => {
if (!isCardAvailable(card, lang)) continue
await fs.mkdir(`${endpoint}/${card.id}/`, {recursive: true})
await fs.writeFile(`${endpoint}/${card.id}/index.json`, JSON.stringify(cardToCardSingle(card, lang)))
try {
await fs.mkdir(`${endpoint}/${encodeURI(card.id)}/`, {recursive: true})
await fs.writeFile(`${endpoint}/${encodeURI(card.id)}/index.json`, JSON.stringify(await cardToCardSingle(card, lang)))
} catch {
}
// if (if (typeof card.set.availability === "undefined"))
}

7
endpoints/categories/index.ts
View File

@ -3,12 +3,15 @@ import Category, { CategorySimple, CategoryList } from '@tcgdex/sdk/interfaces/C
import TranslationUtil from "@tcgdex/sdk/TranslationUtil"
import { Langs } from "@tcgdex/sdk/interfaces/LangList"
import { promises as fs } from 'fs'
import Logger from '@dzeio/logger'
const lang = process.env.CARDLANG as Langs || "en"
const endpoint = getBaseFolder(lang, "categories")
const logger = new Logger('Category/Index')
export default async () => {
console.log(endpoint)
logger.log(endpoint)
const list: Array<CategorySimple> = []
for (const cat of Object.values(Category)) {
@ -26,5 +29,5 @@ export default async () => {
await fs.mkdir(endpoint, {recursive: true})
await fs.writeFile(`${endpoint}/index.json`, JSON.stringify(res))
console.log('ended ' + endpoint)
logger.log('ended')
}

2
endpoints/categories/item.ts
View File

@ -37,7 +37,7 @@ export default async () => {
const toSave: CategorySingle = {
id: rCat,
name: TranslationUtil.translate("category", rCat, lang),
cards: cards.map(el => cardToCardSimple(el, lang))
cards: await Promise.all(cards.map(el => cardToCardSimple(el, lang)))
}
const index = `${endpoint}/${toSave.id}`

27
endpoints/expansionUtil.ts
View File

@ -11,12 +11,33 @@ export function getExpansion(set: Set): Expansion {
return require(`../../db/expansions/${set.expansionCode}`)
}
export function getAllExpansions(): Array<string> {
return glob.sync("./db/expansions/*.ts").map(el => el.substr(16, el.length-15-1-3)) // -15 = start -1 = 0 index -3 = .ts
const setExpansionLink: Record<string, string> = {}
export function getExpansionFromSetName(setName: string): Expansion {
try {
if (!setExpansionLink[setName]) {
setExpansionLink[setName] = glob.sync(`./db/sets/**/${setName}.ts`)[0].split('/')[3]
}
const expansionName = setExpansionLink[setName]
return fetchExpansion(expansionName)
} catch (e) {
console.error(glob.sync(`./db/sets/**/${setName}`))
throw new Error(setName)
}
}
export function getAllExpansions(): Array<string> {
return glob.sync("./db/expansions/*.ts").map(el => el.split('/')[3].substr(0, el.length-1-3)) // -15 = start -1 = 0 index -3 = .ts
}
const expansionCache: Record<string, Expansion> = {}
export function fetchExpansion(name: string): Expansion {
return require(`../db/expansions/${name}.js`).default
name = name.replace('.ts', '')
if (!expansionCache[name]) {
expansionCache[name] = require(`../db/expansions/${name}.js`).default
}
return expansionCache[name]
}
export function expansionToExpansionSimple(expansion: Expansion, lang: Langs) {

2
endpoints/hp/item.ts
View File

@ -31,7 +31,7 @@ export default async () => {
const toSave: HpSingle = {
hp: hp as unknown as number,
cards: cards.map(el => cardToCardSimple(el, lang))
cards: await Promise.all(cards.map(el => cardToCardSimple(el, lang)))
}
await fs.mkdir(`${endpoint}/${toSave.hp}/`, {recursive: true})

2
endpoints/illustrators/item.ts
View File

@ -38,7 +38,7 @@ export default async () => {
const toSave: IllustratorSingle = {
id: db.indexOf(illustrator),
name: illustrator,
cards: list.map(el => cardToCardSimple(el, lang))
cards: await Promise.all(list.map(el => cardToCardSimple(el, lang)))
}
await fs.mkdir(`${endpoint}/${toSave.id}`, {recursive: true})

4
endpoints/rarities/index.ts
View File

@ -4,6 +4,10 @@ import { Langs } from "@tcgdex/sdk/interfaces/LangList"
import { promises as fs } from 'fs'
import Rarity, { RaritySimple, RarityList } from "@tcgdex/sdk/interfaces/Rarity"
import { logger as console } from '@dzeio/logger'
console.prefix = 'Rarities/Index'
const lang = process.env.CARDLANG as Langs || "en"
const endpoint = getBaseFolder(lang, "rarities")

6
endpoints/rarities/item.ts
View File

@ -6,6 +6,10 @@ import TranslationUtil from "@tcgdex/sdk/TranslationUtil"
import { promises } from "fs"
import Rarity, { RaritySingle } from "@tcgdex/sdk/interfaces/Rarity"
import { logger as console } from '@dzeio/logger'
console.prefix = 'Rarities/Item'
type rarityCards = {
[key in Rarity]?: Array<Card>
}
@ -37,7 +41,7 @@ export default async () => {
const toSave: RaritySingle = {
id: rCat,
name: TranslationUtil.translate("rarity", rCat, lang),
cards: cards.map(el => cardToCardSimple(el, lang))
cards: await Promise.all(cards.map(el => cardToCardSimple(el, lang)))
}
const index = `${endpoint}/${toSave.id}`

3
endpoints/retreat/index.ts
View File

@ -5,6 +5,9 @@ import { isCardAvailable } from "../cardUtil"
import { RetreatList } from '@tcgdex/sdk/interfaces/Retreat'
import { Langs } from "@tcgdex/sdk/interfaces/LangList"
import { logger as console } from '@dzeio/logger'
console.prefix = 'Retreat/Index'
const lang = (process.env.CARDLANG || "en") as Langs
const endpoint = getBaseFolder(lang, "retreat")

5
endpoints/retreat/item.ts
View File

@ -5,6 +5,9 @@ import { isCardAvailable, cardToCardSimple } from "../cardUtil"
import { RetreatSingle } from '@tcgdex/sdk/interfaces/Retreat'
import { Langs } from "@tcgdex/sdk/interfaces/LangList"
import { logger as console } from '@dzeio/logger'
console.prefix = 'Retreat/Item'
const lang = (process.env.CARDLANG || "en") as Langs
const endpoint = getBaseFolder(lang, "retreat")
@ -30,7 +33,7 @@ export default async () => {
const item: RetreatSingle = {
id: retreat as unknown as number,
cards: cardArr.map((val) => cardToCardSimple(val, lang))
cards: await Promise.all(cardArr.map(el => cardToCardSimple(el, lang)))
}
await fs.mkdir(`${endpoint}/${item.id}`, {recursive: true})

11
endpoints/setUtil.ts
View File

@ -46,7 +46,7 @@ export function setToSetSimple(set: Set, lang: Langs): SetSimple {
}
}
export function getSetCards(set: Set, lang: Langs): Array<CardSimple> {
export async function getSetCards(set: Set, lang: Langs): Promise<Array<CardSimple>> {
const cardes = getAllCards2(set.code)
const cards: Array<Card> = []
for (let el of cardes) {
@ -57,16 +57,15 @@ export function getSetCards(set: Set, lang: Langs): Array<CardSimple> {
card
)
}
return cards.sort((a, b) => {
return await Promise.all(cards.sort((a, b) => {
if (!isNaN(parseInt(a.localId + "")) && !isNaN(parseInt(b.localId + ""))) {
return parseInt(a.localId + "") - parseInt(b.localId + "")
}
return a.localId > b.localId ? 1 : -1
}).map(el => cardToCardSimple(el, lang))
}).map(el => cardToCardSimple(el, lang)))
}
export function setToSetSingle(set: Set, lang: Langs): SetSingle {
export async function setToSetSingle(set: Set, lang: Langs): Promise<SetSingle> {
return {
name: set.name[lang],
code: set.code,
@ -85,6 +84,6 @@ export function setToSetSingle(set: Set, lang: Langs): SetSingle {
symbol: set.images.symbol,
logo: set.images.logo
},
list: getSetCards(set, lang)
list: await getSetCards(set, lang)
}
}

4
endpoints/sets/index.ts
View File

@ -5,6 +5,10 @@ import { SetSimple, SetList } from "@tcgdex/sdk/interfaces/Set"
import { getAllSets, getBaseFolder } from "../util"
import { isSetAvailable, setToSetSimple } from "../setUtil"
import { logger as console } from '@dzeio/logger'
console.prefix = 'Sets/Index'
const lang = process.env.CARDLANG as Langs || "en"
const endpoint = getBaseFolder(lang, "sets")

5
endpoints/sets/item.ts
View File

@ -4,6 +4,9 @@ import { Langs } from "@tcgdex/sdk/interfaces/LangList"
import { promises as fs } from 'fs'
import { isSetAvailable, setToSetSingle } from "../setUtil"
import { logger as console } from '@dzeio/logger'
console.prefix = 'Sets/Item'
const lang = process.env.CARDLANG as Langs || "en"
const endpoint = getBaseFolder(lang, "sets")
@ -18,7 +21,7 @@ export default async () => {
if (!isSetAvailable(set, lang)) continue
await fs.mkdir(`${endpoint}/${set.code}/`, {recursive: true})
await fs.writeFile(`${endpoint}/${set.code}/index.json`, JSON.stringify(setToSetSingle(set, lang)))
await fs.writeFile(`${endpoint}/${set.code}/index.json`, JSON.stringify(await setToSetSingle(set, lang)))
}

6
endpoints/sets/subitem.ts
View File

@ -7,6 +7,10 @@ import { getAllCards2 } from "../util"
import Card from "@tcgdex/sdk/interfaces/Card"
import { cardToCardSingle, isCardAvailable } from "../cardUtil"
import { logger as console } from '@dzeio/logger'
console.prefix = 'Sets/SubItem'
const lang = process.env.CARDLANG as Langs || "en"
const endpoint = getBaseFolder(lang, "sets")
@ -28,7 +32,7 @@ export default async () => {
if (!isCardAvailable(card, lang)) continue
await fs.mkdir(`${endpoint}/${set.code}/${card.localId}`, {recursive: true})
await fs.writeFile(`${endpoint}/${set.code}/${card.localId}/index.json`, JSON.stringify(cardToCardSingle(card, lang)))
await fs.writeFile(`${endpoint}/${set.code}/${card.localId}/index.json`, JSON.stringify(await cardToCardSingle(card, lang)))
}
}

7
endpoints/tags/index.ts
View File

@ -4,11 +4,14 @@ import { Langs } from "@tcgdex/sdk/interfaces/LangList"
import { promises as fs } from 'fs'
import Tag, { TagSimple, TagList } from "@tcgdex/sdk/interfaces/Tag"
import Logger from '@dzeio/logger'
const logger = new Logger('Tags/Index')
const lang = process.env.CARDLANG as Langs || "en"
const endpoint = getBaseFolder(lang, "tags")
export default async () => {
console.log(endpoint)
logger.log(endpoint)
const list: Array<TagSimple> = []
for (const cat of Object.values(Tag)) {
@ -26,5 +29,5 @@ export default async () => {
await fs.mkdir(endpoint, {recursive: true})
await fs.writeFile(`${endpoint}/index.json`, JSON.stringify(res))
console.log('ended ' + endpoint)
logger.log('ended ' + endpoint)
}

21
endpoints/tags/item.ts
View File

@ -1,5 +1,5 @@
import { getAllCards, getBaseFolder, urlize } from "../util"
import { fetchCard, isCardAvailable, cardToCardSimple } from "../cardUtil"
import { fetchCard, isCardAvailable, cardToCardSimple, fetchCardAsync } from "../cardUtil"
import Type, { TypeSingle } from "@tcgdex/sdk/interfaces/Type"
import Card from "@tcgdex/sdk/interfaces/Card"
import { Langs } from "@tcgdex/sdk/interfaces/LangList"
@ -7,6 +7,10 @@ import TranslationUtil from "@tcgdex/sdk/TranslationUtil"
import { promises } from "fs"
import Tag, { TagSingle } from "@tcgdex/sdk/interfaces/Tag"
import Logger from '@dzeio/logger'
import { objectKeys, objectSize } from '@dzeio/object-util'
const logger = new Logger('Tags/Item')
type tagCards = {
[key in Tag]?: Array<Card>
}
@ -16,28 +20,31 @@ const endpoint = getBaseFolder(lang, "tags")
export default async () => {
console.log(endpoint)
logger.log('part 1')
const list = getAllCards()
const arr: tagCards = {}
for (const i of list) {
const card = await fetchCard(i)
const card = await fetchCardAsync(i)
if (!isCardAvailable(card, lang)) continue
if (!isCardAvailable(card, lang) || !card.tags) continue
for (const tag of card.tags) {
if (!(tag in arr)) arr[tag] = []
arr[tag].push(card)
}
}
logger.log('part 2')
for (const type in arr) {
if (arr.hasOwnProperty(type)) {
const cards: Array<Card> = arr[type];
const rTag: Tag = parseInt(type)
logger.log('Working on tag', TranslationUtil.translate("tag", rTag, lang), `${type}/${objectSize(arr)}`)
const toSave: TagSingle = {
id: rTag,
name: TranslationUtil.translate("tag", rTag, lang),
cards: cards.map(el => cardToCardSimple(el, lang))
cards: await Promise.all(cards.map(el => cardToCardSimple(el, lang)))
}
const index = `${endpoint}/${toSave.id}`
@ -50,5 +57,5 @@ export default async () => {
await promises.writeFile(`${name}/index.json`, JSON.stringify(toSave))
}
}
console.log('ended ' + endpoint)
logger.log('ended')
}

3
endpoints/types/index.ts
View File

@ -8,6 +8,9 @@ import { List } from "@tcgdex/sdk/interfaces/General"
const lang = process.env.CARDLANG as Langs || "en"
const endpoint = getBaseFolder(lang, "types")
import { logger as console } from '@dzeio/logger'
console.prefix = 'Types/Index'
export default async () => {
console.log(endpoint)
const typeArr: Array<TypeSimple> = []

5
endpoints/types/item.ts
View File

@ -6,6 +6,9 @@ import { Langs } from "@tcgdex/sdk/interfaces/LangList"
import TranslationUtil from "@tcgdex/sdk/TranslationUtil"
import { promises } from "fs"
import { logger as console } from '@dzeio/logger'
console.prefix = 'Types/Item'
type typeCards = {
[key in Type]?: Array<Card>
}
@ -36,7 +39,7 @@ export default async () => {
const toSave: TypeSingle = {
id: rType,
name: TranslationUtil.translate("type", rType, lang),
cards: cards.map(el => cardToCardSimple(el, lang))
cards: await Promise.all(cards.map(el => cardToCardSimple(el, lang)))
}
const index = `${endpoint}/${toSave.id}`

16
endpoints/util.ts
View File

@ -1,5 +1,6 @@
import { promises as fs, promises } from 'fs'
import * as glob from 'glob'
import fetch from 'node-fetch'
const VERSION = 'v1'
@ -68,3 +69,18 @@ export function urlize(str: string): string {
str = str.normalize('NFD').replace(/[\u0300-\u036f]/g, "")
return str.replace(/ /g, "-").toLowerCase()
}
interface fileCacheInterface {
[key: string]: any
}
const fileCache: fileCacheInterface = {}
export async function fetchRemoteFile<T = any>(url: string): Promise<T> {
// console.log(Object.keys(fileCache))
if (!fileCache[url]) {
const resp = await fetch(url)
// console.log(await resp.text(), url)
fileCache[url] = resp.json()
}
return fileCache[url]
}