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(`./${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/AbilityType.ts

@@ -3,6 +3,12 @@ export interface AbilityTypeSimple {
 	name: string
 }
 
+export type AbilityTypeSingle = {
+	id: AbilityType
+	name: string
+	cards: string
+}
+
 enum AbilityType {
 	POKEBODY,
 	POKEPOWER,

interfaces/Card.ts

@@ -11,6 +11,7 @@ import Set from "./Set";
 
 export interface CardSimple {
 	id: string
+	localId: string|number
 	name: string
 	image: string
 }
@@ -32,16 +33,19 @@ export interface CardSingle {
 		name: string
 		code: string
 	}
-	cardTypes?: {
+
-		normal: boolean
+	/**
-		reverse: boolean
+	 * Some Pokémons have item like a berry
-		holo: boolean
+	 */
-		firstEd: boolean
+	item?: {
+		name: string
+		effect: string
 	}
 
 	// Pokémon only
 	hp?: number
 	dexId?: number
+	lvl?: number
 	type?: Array<TypeSimple>
 	evolveFrom?: string
 	evolveTo?: Array<string>
@@ -95,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/Illustrator.ts

@@ -1,4 +1,5 @@
 import { CardSimple } from "./Card";
+import { List } from "./General";
 
 export type IllustratorSingle = {
 	id: number,
@@ -11,10 +12,7 @@ export interface IllustratorSimple {
 	name: string
 }
 
-export interface IllustratorsList {
+export type IllustratorsList = List<IllustratorSimple>
-	count: number
-	list: Array<IllustratorSimple>
-}
 
 interface Illustrator {
 	id: number

interfaces/Rarity.ts

@@ -1,3 +1,6 @@
+import { List } from "./General"
+import { CardSimple } from "./Card"
+
 export enum Rarity {
 	Common,
 	Uncommon,
@@ -30,3 +33,11 @@ export interface RaritySimple {
 	id: Rarity
 	name: string
 }
+
+export type RaritySingle = {
+	id: Rarity
+	name: string
+	cards: Array<CardSimple>
+}
+
+export type RarityList = List<RaritySimple>

interfaces/Retreat.ts

@@ -1,4 +1,5 @@
 import { CardSimple } from "./Card";
+import { List } from "./General";
 
 export type RetreatSimple = number
 
@@ -7,7 +8,4 @@ export interface RetreatSingle {
 	cards: Array<CardSimple>
 }
 
-export interface RetreatList {
+export type RetreatList = List<RetreatSimple>
-	count: number,
-	list: Array<RetreatSimple>
-}

interfaces/Set.ts

@@ -36,6 +36,8 @@ export type SetSingle = {
 export type SetSimple = {
 	code: string
 	name: string
+	logo?: string
+	symbol?: string
 	total: number
 }
 

interfaces/Tag.ts

@@ -1,5 +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,
@@ -13,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
@@ -29,3 +73,11 @@ export interface TagSimple {
 	id: Tag
 	name: string
 }
+
+export type TagSingle = {
+	id: Tag
+	name: string
+	cards: Array<CardSimple>
+}
+
+export type TagList = List<TagSimple>

interfaces/Type.ts

@@ -1,3 +1,6 @@
+import { List } from "./General"
+import { CardSimple } from "./Card"
+
 enum Type {
 	COLORLESS,
 	DARKNESS,
@@ -17,4 +20,12 @@ export interface TypeSimple {
 	name: string
 }
 
+export type TypeSingle = {
+	id: Type
+	name: string
+	cards: Array<CardSimple>
+}
+
+export type TypeList = List<TypeSimple>
+
 export default Type

package.json

@@ -1,8 +1,8 @@
 {
 	"name": "@tcgdex/sdk",
-	"version": "1.0.6",
+	"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 } from './interfaces/Set'
+import { SetSingle, SetSimple, SetList } from './interfaces/Set'
-import { CardSingle } from './interfaces/Card'
+import { CardSingle, CardList, CardSimple } from './interfaces/Card'
-import { ExpansionSingle } from './interfaces/Expansion'
+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,47 +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()
+	public async getCards(set?: string): Promise<Array<CardSimple>> {
-			} catch (e) {
+		if (set) {
-				throw e
+			const setSingle = await this.getSet(set)
-			}
+			return setSingle.list
-		} 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()
+	public async getExpansions(): Promise<ExpansionList> {
-			} catch (e) {
+		const req = this.rwgr<ExpansionList>(`${this.gbu()}/expansions/`)
-				throw e
+		return req.get()
-			}
+	}
-		} catch (e) {
+
-			throw e
+	public async getSets(expansion?: string): Promise<Array<SetSimple>> {
+		if (expansion) {
+			const expansionSingle = await this.getExpansion(expansion)
+			return expansionSingle.sets
 		}
+		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)
 	}
 }