v1.4.1

Signed-off-by: Avior <florian.bouillon@delta-wings.net>

Request.ts

@@ -0,0 +1,51 @@
+import fetch from 'isomorphic-unfetch'
+
+export default class RequestWrapper {
+	private static cache: Array<Request<any>> = []
+
+	public static getRequest<T>(url: string) {
+		let req = this.cache.find((req) => req.url === url) as Request<T>|undefined
+		if (!req) {
+			req = new Request<T>(url)
+			this.cache.push(req)
+		}
+		return req
+	}
+}
+
+export class Request<T = any> {
+	public static ttl = 1000 * 60 * 60 // 1 hour
+	private response?: T
+	private fetched?: Date
+	public url: string // url is public for quick url test
+
+	public constructor(url: string) {
+		this.url = url
+	}
+
+	public async get(): Promise<T> {
+		const now = new Date()
+		if (
+			this.fetched &&
+			this.response &&
+			now.getTime() - this.fetched.getTime() < Request.ttl
+		) {
+			return this.response
+		}
+
+		// Fetch Response
+		try {
+			const resp = await fetch(this.url)
+			if (resp.status !== 200) {
+				throw new Error(`Error request ended with the code (${resp.status})`)
+			}
+			const response = await resp.json()
+			this.response = response
+			this.fetched = now
+			return response
+		} catch (e) {
+			console.error(e)
+			throw new Error('An error occured')
+		}
+	}
+}

TranslationUtil.ts

@@ -5,6 +5,12 @@ import Rarity from "./interfaces/Rarity";
 import Tag from "./interfaces/Tag";
 import Type from "./interfaces/Type";
 
+import atTrans from './translations/abilityType'
+import cTrans from './translations/category'
+import rTrans from './translations/rarity'
+import taTrans from './translations/tag'
+import tyTrans from './translations/type'
+
 type possibilities = "abilityType" | "category" | "rarity" | "tag" | "type"
 
 export default class TranslationUtil {
@@ -14,8 +20,31 @@ export default class TranslationUtil {
 	public static translate(master: "tag",a: Tag, lang: Langs): string|undefined;
 	public static translate(master: "type",a: Type, lang: Langs): string|undefined;
 	public static translate(master: possibilities,a: number, lang: Langs): string|undefined {
-		const trans = require(`./translations/${master}`).default as translations
+		let langlist: LangList<Array<string>>|undefined
-		const tmp = trans[lang]
+		switch (master) {
+			case 'abilityType':
+				langlist = atTrans
+				break
+			case 'category':
+				langlist = cTrans
+				break
+
+			case 'rarity':
+				langlist = rTrans
+				break
+
+			case 'tag':
+				langlist = taTrans
+				break
+
+			case 'type':
+				langlist = tyTrans
+				break
+			default:
+				break;
+		}
+		if (!langlist) return
+		const tmp = langlist[lang]
 		if (!tmp) return
 		return tmp[a]
 	}

interfaces/Card.ts

@@ -33,40 +33,19 @@ export interface CardSingle {
 		name: string
 		code: string
 	}
-	cardTypes?: {
+
-		/**
+	/**
-		 * normal card without anything special
+	 * Some Pokémons have item like a berry
-		 *
+	 */
-		 *
+	item?: {
-		 * @type {boolean} consider `undefined` to true
+		name: string
-		 */
+		effect: string
-		normal?: boolean
-		/**
-		 * Card which has a holographic background
-		 * but not the picture
-		 *
-		 * @type {boolean} `undefined` === `true`
-		 */
-		reverse?: boolean
-		/**
-		 * Card which has a hologaphic picture
-		 *
-		 * @type {boolean} `undefined` === `false`
-		 */
-		holo?: boolean
-		/**
-		 * Card which can have a `1st ed` icon
-		 *
-		 * only the base expansion should received it
-		 *
-		 * @type {boolean} `undefined` === `false`
-		 */
-		firstEd?: boolean
 	}
 
 	// Pokémon only
 	hp?: number
 	dexId?: number
+	lvl?: number
 	type?: Array<TypeSimple>
 	evolveFrom?: string
 	evolveTo?: Array<string>
@@ -120,6 +99,11 @@ type Card = {
 	// If card is trainer or energy effect is here
 	effect?: LangList<string>
 
+	item?: {
+		name: LangList<string>
+		effect: LangList<string>
+	}
+
 	weaknesses?: Array<{
 		type: Type
 		value?: string

interfaces/Tag.ts

@@ -1,8 +1,19 @@
 import { List } from "./General"
 import { CardSimple } from "./Card"
-
+/**
+ * Anum of "Tags" each card can contains
+ *
+ * @enum {number}
+ */
 enum Tag {
+	/**
+	 * basic pokémon
+	 */
 	BASIC,
+
+	/**
+	 * Basic Energy
+	 */
 	BASICENERGY,
 	BREAK,
 	EX,
@@ -16,14 +27,44 @@ enum Tag {
 	SP,
 	SPECIAL,
 	STADIUM,
+	/**
+	 * Stage 1 pokémon
+	 */
 	STAGE1,
+
+	/**
+	 * Stage 2 Pokémon
+	 */
 	STAGE2,
 	SUPPORTER,
 	TAGTEAM,
 	TECHNICALMACHINE,
 	TOOL,
+
+	/**
+	 * V Pokémon
+	 */
 	V,
+
+	/**
+	 * VMAX Pokémon
+	 */
 	VMAX,
+
+	/**
+	 * The card is available with the holographic picture
+	 */
+	HASHOLO,
+
+	/**
+	 * Card can have a 1st badge
+	 */
+	HAS1ST,
+
+	/**
+	 * Card is full art (art is not in the frame)
+	 */
+	ISFULLART,
 }
 
 export default Tag

package.json

@@ -1,8 +1,8 @@
 {
 	"name": "@tcgdex/sdk",
-	"version": "1.2.0-beta.1",
+	"version": "1.4.1",
 	"main": "./tcgdex.js",
-	"types": "./types/tcgdex.d.ts",
+	"types": "./tcgdex.d.ts",
 	"repository": "https://git.delta-wings.net/tcgdex/javascript-sdk.git",
 	"license": "MIT",
 	"devDependencies": {

tcgdex.ts

@@ -1,18 +1,24 @@
-import fetch from 'isomorphic-unfetch'
 import { Langs } from './interfaces/Langs'
-import { SetSingle, SetRequest, SetSimple } from './interfaces/Set'
+import { SetSingle, SetSimple, SetList } from './interfaces/Set'
-import { CardSingle } from './interfaces/Card'
+import { CardSingle, CardList, CardSimple } from './interfaces/Card'
 import { ExpansionSingle, ExpansionList } from './interfaces/Expansion'
+import RequestWrapper from './Request'
 
 export default class TCGdex {
-	public lang: Langs = "en"
+	public static defaultLang: Langs = "en"
+	public lang?: Langs
 
 	public constructor(lang?: Langs) {
 		if (lang) this.lang = lang
 	}
 
+	public getLang() {
+		return this.lang || TCGdex.defaultLang
+	}
+
+
 	private getBaseUrl() {
-		return `https://api.tcgdex.net/${this.lang}`
+		return `https://api.tcgdex.net/${this.getLang()}`
 	}
 
 	private gbu() {
@@ -22,112 +28,49 @@ export default class TCGdex {
 	public async getCard(id: string|number, set: string): Promise<CardSingle>;
 	public async getCard(id: string): Promise<CardSingle>;
 	public async getCard(id: string|number, set?: string): Promise<CardSingle> {
-		try {
+		const txt = set ? `sets/${set}` : "cards"
-			const txt = set ? `sets/${set}` : "cards"
+		const req = this.rwgr<CardSingle>(`${this.gbu()}/${txt}/${id}/`)
-			const resp = await fetch(`${this.gbu()}/${txt}/${id}/`)
+		return req.get()
-			if (resp.status !== 200) throw new Error("Card not found")
-			try {
-				return await resp.json()
-			} catch (e) {
-				throw e
-			}
-		} catch (e) {
-			throw e
-		}
 	}
 
-	public async getCards(set?: string) {
+	public async getCards(set?: string): Promise<Array<CardSimple>> {
 		if (set) {
-			try {
+			const setSingle = await this.getSet(set)
-				const setSingle = await this.getSet(set)
+			return setSingle.list
-				return setSingle.list
-			} catch (e) {
-				throw e
-			}
-		}
-		try {
-			console.warn("note: while it's possible to fetch every cards at once it's not recommended as it take much more time than any other requests")
-			const resp = await fetch(`${this.gbu()}/cards/`)
-			if (resp.status !== 200) {
-				throw new Error("Could not fetch cards")
-			}
-			try {
-				return resp.json()
-			} catch (e) {
-				throw e
-			}
-		} catch (e) {
-			throw e
 		}
+		console.warn("note: while it's possible to fetch every cards at once it's not recommended as it take much more time than any other requests")
+		const req = this.rwgr<CardList>(`${this.gbu()}/cards/`)
+		const resp = await req.get()
+		return resp.list
 	}
 
 	public async getSet(set: string): Promise<SetSingle> {
-		try {
+		const req = this.rwgr<SetSingle>(`${this.gbu()}/sets/${set}/`)
-			const resp = await fetch(`${this.gbu()}/sets/${set}/`)
+		const resp = await req.get()
-			console.log(resp.status)
+		return Object.assign(resp, {releaseDate: new Date(resp.releaseDate)}) as SetSingle
-			if (resp.status !== 200) throw new Error("Set not found")
-			try {
-				const setTmp: SetRequest = await resp.json();
-				return Object.assign(setTmp, {releaseDate: new Date(setTmp.releaseDate)}) as SetSingle
-			} catch (e) {
-				throw e
-			}
-		} catch (e) {
-			throw e
-		}
 	}
 
 	public async getExpansion(expansion: string): Promise<ExpansionSingle> {
-		try {
+		const req = this.rwgr<ExpansionSingle>(`${this.gbu()}/expansions/${expansion}/`)
-			const resp = await fetch(`${this.gbu()}/expansions/${expansion}/`)
+		return req.get()
-			if (resp.status !== 200) throw new Error("Expansion not found")
-			try {
-				return await resp.json()
-			} catch (e) {
-				throw e
-			}
-		} catch (e) {
-			throw e
-		}
 	}
 
 	public async getExpansions(): Promise<ExpansionList> {
-		try {
+		const req = this.rwgr<ExpansionList>(`${this.gbu()}/expansions/`)
-			const resp = await fetch(`${this.gbu()}/expansions/`)
+		return req.get()
-			if (resp.status !== 200) throw new Error("Could not fetch expansions")
-			try {
-				return await resp.json()
-			} catch (e) {
-				throw e
-			}
-		} catch (e) {
-			throw e
-		}
 	}
 
 	public async getSets(expansion?: string): Promise<Array<SetSimple>> {
 		if (expansion) {
-			try {
+			const expansionSingle = await this.getExpansion(expansion)
-				const expansionSingle = await this.getExpansion(expansion)
+			return expansionSingle.sets
-				return expansionSingle.sets
-			} catch (e) {
-				throw e
-			}
-		} else {
-			try {
-				const resp = await fetch(`${this.gbu()}/sets/`)
-				if (resp.status !== 200) {
-					throw new Error("Could not fetch sets")
-				}
-				try {
-					return resp.json()
-				} catch (e) {
-					throw e
-				}
-
-			} catch (e) {
-				throw e
-			}
 		}
+		const req = this.rwgr<SetList>(`${this.gbu()}/sets/`)
+		const list = await req.get()
+		return list.list
+	}
+
+	private rwgr<T>(url: string) {
+		return RequestWrapper.getRequest<T>(url)
 	}
 }