scryfall-api 4.0.4 → 5.0.0

package/dist/scryfall-api.mjs

@@ -0,0 +1,401 @@
+// src/error/invalid.error.ts
+var InvalidScryfallArgumentError = class extends Error {};
+
+// src/error/scryfall.error.ts
+var ScryfallError = class extends Error {
+	code;
+	status;
+	type;
+	warnings;
+	constructor(code, details, status, type, warnings) {
+		super(details);
+		this.code = code;
+		this.status = status;
+		this.type = type;
+		this.warnings = warnings;
+	}
+};
+
+// src/error/unknown.error.ts
+var UnknownScryfallError = class extends Error {};
+
+// src/fetcher/debounce.fetcher.ts
+const defaultNow = () => Date.now();
+async function sleep(milliseconds) {
+	await new Promise((resolve) => {
+		setTimeout(resolve, milliseconds);
+	});
+}
+function createDebounceFetcher(fetcher, { maxRequestsPerSecond, now, sleep: sleepFunction }) {
+	const interval = 1e3 / maxRequestsPerSecond;
+	const clock = now ?? defaultNow;
+	const wait = sleepFunction ?? sleep;
+	let lastRequestAt = -Infinity;
+	return async function debounceFetcher(...arguments_) {
+		for (;;) {
+			const currentTime = clock();
+			const timeUntilNextRequest = lastRequestAt + interval - currentTime;
+			if (timeUntilNextRequest <= 0) {
+				lastRequestAt = currentTime;
+				break;
+			}
+			await wait(timeUntilNextRequest);
+		}
+		return fetcher(...arguments_);
+	};
+}
+
+// src/fetcher/retry.fetcher.ts
+const defaultCanRetry = (object) => {
+	const status = "status" in object ? Number(object.status) : void 0;
+	if (status && status >= 500) return true;
+	const code = "code" in object && typeof object.code === "string" ? object.code : void 0;
+	return code !== "not_found" && code !== "bad_request";
+};
+function createRetryFetcher(fetcher = fetch, { canRetry = defaultCanRetry, maxAttempts = 3 } = {}) {
+	let retries = 0;
+	return async function retryFetcher(...arguments_) {
+		retries++;
+		const response = await fetcher(...arguments_);
+		if (response.ok) return response;
+		const object = await response.json();
+		const code = "code" in object && typeof object.code === "string" ? object.code : void 0;
+		const status = "status" in object ? Number(object.status) : void 0;
+		const details = "details" in object && typeof object.details === "string" ? object.details : void 0;
+		const type = "type" in object && typeof object.type === "string" ? object.type : void 0;
+		const warnings = "warnings" in object && Array.isArray(object.warnings) ? object.warnings : void 0;
+		if (retries >= maxAttempts) {
+			if (code && details && status) throw new ScryfallError(code, details, status, type, warnings);
+			throw new UnknownScryfallError(`Request failed with status ${response.status.toFixed(0)}`);
+		}
+		if (canRetry(object)) return retryFetcher(...arguments_);
+		if (code && details && status) throw new ScryfallError(code, details, status, type, warnings);
+		throw new UnknownScryfallError(`Request failed with status ${response.status.toFixed(0)}`);
+	};
+}
+
+// src/fetcher/fetcher.ts
+const scryfallEndpoint = "https://api.scryfall.com";
+const defaultRequestsPerSecond = 10;
+const DATE_REGEXP = /^\d{4}-\d{2}-\d{2}?$/;
+const dateParser = (_key, value) => {
+	if (typeof value === "string" && DATE_REGEXP.test(value)) return new Date(value);
+	return value;
+};
+const globallyLimitedFetch = createDebounceFetcher(fetch, { maxRequestsPerSecond: defaultRequestsPerSecond });
+function createFetcher({ fetch: fetchFunction, maxRequestsPerSecond = defaultRequestsPerSecond, now, sleep } = {}) {
+	const globalFetch = fetchFunction ? createDebounceFetcher(fetchFunction, {
+		maxRequestsPerSecond: defaultRequestsPerSecond,
+		now,
+		sleep
+	}) : globallyLimitedFetch;
+	const retryingFetch = createRetryFetcher(globalFetch);
+	const simpleFetcher = maxRequestsPerSecond === defaultRequestsPerSecond ? retryingFetch : createDebounceFetcher(retryingFetch, {
+		maxRequestsPerSecond,
+		now,
+		sleep
+	});
+	return async function fetcher(apiPath, parameters, body) {
+		let path = "";
+		if (typeof apiPath === "number" || typeof apiPath === "string") path = apiPath;
+		else if (apiPath) path = apiPath.join("/");
+		const url = new URL(`${scryfallEndpoint}/${String(path)}`);
+		if (parameters) {
+			for (const [key, value] of Object.entries(parameters)) if (value !== void 0) url.searchParams.append(key, value.toString());
+		}
+		try {
+			const init = { method: body ? "POST" : "GET" };
+			if (body) {
+				init.body = JSON.stringify(body);
+				init.headers = { "Content-Type": "application/json" };
+			}
+			const content = await (await simpleFetcher(url, init)).text();
+			return JSON.parse(content, dateParser);
+		} catch (error) {
+			if (error instanceof ScryfallError) {
+				if (error.warnings) console.warn(error.warnings);
+				if (error.code === "not_found" || error.code === "bad_request") return;
+			}
+			throw error;
+		}
+	};
+}
+const fetcher = createFetcher();
+
+// src/fetcher/page.result.ts
+var MagicPageResult = class {
+	apiPath;
+	query;
+	fetcher;
+	#count = 0;
+	#hasMore = true;
+	constructor(apiPath, query, fetcher$1 = fetcher) {
+		this.apiPath = apiPath;
+		this.query = query;
+		this.fetcher = fetcher$1;
+	}
+	get count() {
+		return this.#count;
+	}
+	get hasMore() {
+		return this.#hasMore;
+	}
+	async all() {
+		const r = [];
+		while (this.#hasMore) {
+			const result = await this.next();
+			r.push(...result);
+		}
+		return r;
+	}
+	async get(limit) {
+		const r = [];
+		while (this.#hasMore) {
+			const result = await this.next();
+			r.push(...result);
+			if (r.length === limit) return r;
+			if (r.length > limit) return r.slice(0, limit);
+		}
+		return r;
+	}
+	async next() {
+		const results = await this.fetcher(this.apiPath, this.query);
+		this.#hasMore = results?.has_more ?? false;
+		this.#count = Number.parseInt(results?.total_cards?.toFixed(0) ?? "0", 10);
+		if (this.#hasMore) this.setNextPage();
+		return results?.data ?? [];
+	}
+	async page(page) {
+		this.query.page = page;
+		return this.next();
+	}
+	setNextPage() {
+		this.query.page += 1;
+	}
+};
+
+// src/api/card/card.api.ts
+const cardsPerSecond = 2;
+const collectionFetcher = createFetcher({ maxRequestsPerSecond: cardsPerSecond });
+const namedFetcher = createFetcher({ maxRequestsPerSecond: cardsPerSecond });
+const randomFetcher = createFetcher({ maxRequestsPerSecond: cardsPerSecond });
+const searchFetcher = createFetcher({ maxRequestsPerSecond: cardsPerSecond });
+var CardApi = class {
+	async autoCompleteName(name) {
+		return (await fetcher("cards/autocomplete", { q: name }))?.data ?? [];
+	}
+	async byArenaId(id) {
+		return fetcher(["cards/arena", id]);
+	}
+	async byId(id) {
+		return fetcher(["cards", id]);
+	}
+	async byMtgoId(id) {
+		return fetcher(["cards/mtgo", id]);
+	}
+	async byMultiverseId(id) {
+		return fetcher(["cards/multiverse", id]);
+	}
+	async byName(name, set, isFuzzySearch = false) {
+		let isF = isFuzzySearch;
+		let s = set;
+		if (typeof set === "boolean") {
+			isF = set;
+			s = void 0;
+		}
+		return namedFetcher("cards/named", {
+			[isF ? "fuzzy" : "exact"]: name,
+			set: s
+		});
+	}
+	async bySet(set, collectorNumber, lang) {
+		const path = [
+			"cards",
+			set,
+			collectorNumber
+		];
+		if (lang) path.push(lang);
+		return fetcher(path);
+	}
+	async byTcgPlayerId(id) {
+		return fetcher(["cards/tcgplayer", id]);
+	}
+	async collection(...identifiers) {
+		const cards = [];
+		for (let index = 0; index < identifiers.length; index += 75) {
+			const collectionSection = { identifiers: identifiers.slice(index, index + 75) };
+			const result = await collectionFetcher("cards/collection", void 0, collectionSection);
+			cards.push(...result?.data ?? []);
+		}
+		return cards;
+	}
+	async random() {
+		return randomFetcher("cards/random");
+	}
+	search(query, options) {
+		return new MagicPageResult("cards/search", {
+			q: query,
+			...typeof options === "number" ? { page: options } : {
+				...options,
+				page: options?.page ?? 1
+			}
+		}, searchFetcher);
+	}
+};
+const cards = new CardApi();
+
+// src/api/card-identifier/card-identifier.api.ts
+var CardIdentifierApi = class {
+	static byId(id) {
+		return { id };
+	}
+	static byIllustrationId(id) {
+		return { illustration_id: id };
+	}
+	static byMtgoId(id) {
+		return { mtgo_id: id };
+	}
+	static byMultiverseId(id) {
+		return { multiverse_id: id };
+	}
+	static byName(name, set) {
+		if (set) return {
+			name,
+			set
+		};
+		return { name };
+	}
+	static byOracleId(id) {
+		return { oracle_id: id };
+	}
+	static bySet(set, collectorNumber) {
+		return {
+			collector_number: String(collectorNumber),
+			set
+		};
+	}
+};
+
+// src/api/catalog/catalog.api.ts
+var CatalogApi = class {
+	async artifactTypes() {
+		return (await fetcher("catalog/artifact-types"))?.data ?? [];
+	}
+	async artistNames() {
+		return (await fetcher("catalog/artist-names"))?.data ?? [];
+	}
+	async cardNames() {
+		return (await fetcher("catalog/card-names"))?.data ?? [];
+	}
+	async creatureTypes() {
+		return (await fetcher("catalog/creature-types"))?.data ?? [];
+	}
+	async enchantmentTypes() {
+		return (await fetcher("catalog/enchantment-types"))?.data ?? [];
+	}
+	async landTypes() {
+		return (await fetcher("catalog/land-types"))?.data ?? [];
+	}
+	async loyalties() {
+		return (await fetcher("catalog/loyalties"))?.data ?? [];
+	}
+	async planeswalkerTypes() {
+		return (await fetcher("catalog/planeswalker-types"))?.data ?? [];
+	}
+	async powers() {
+		return (await fetcher("catalog/powers"))?.data ?? [];
+	}
+	async spellTypes() {
+		return (await fetcher("catalog/spell-types"))?.data ?? [];
+	}
+	async toughnesses() {
+		return (await fetcher("catalog/toughnesses"))?.data ?? [];
+	}
+	async watermarks() {
+		return (await fetcher("catalog/watermarks"))?.data ?? [];
+	}
+	async wordBank() {
+		return (await fetcher("catalog/word-bank"))?.data ?? [];
+	}
+};
+const catalog = new CatalogApi();
+
+// src/api/ruling/ruling.api.ts
+var RulingApi = class {
+	async byArenaId(id) {
+		return (await fetcher([
+			"cards/arena",
+			id,
+			"rulings"
+		]))?.data ?? [];
+	}
+	async byId(id) {
+		return (await fetcher([
+			"cards",
+			id,
+			"rulings"
+		]))?.data ?? [];
+	}
+	async byMtgoId(id) {
+		return (await fetcher([
+			"cards/mtgo",
+			id,
+			"rulings"
+		]))?.data ?? [];
+	}
+	async byMultiverseId(id) {
+		return (await fetcher([
+			"cards/multiverse",
+			id,
+			"rulings"
+		]))?.data ?? [];
+	}
+	async bySet(set, collectorNumber) {
+		return (await fetcher([
+			"cards",
+			set,
+			String(collectorNumber),
+			"rulings"
+		]))?.data ?? [];
+	}
+};
+const rulings = new RulingApi();
+
+// src/api/set/set.api.ts
+var SetApi = class {
+	async all() {
+		return (await fetcher("sets"))?.data ?? [];
+	}
+	async byCode(code) {
+		return await fetcher(["sets", code]);
+	}
+	async byId(id) {
+		return fetcher(["sets", id]);
+	}
+	async byTcgPlayerId(id) {
+		return fetcher(["sets/tcgplayer", id]);
+	}
+};
+const set = new SetApi();
+
+// src/api/symbology/symbology.api.ts
+var SymbologyApi = class {
+	async all() {
+		return (await fetcher("symbology"))?.data ?? [];
+	}
+	async parseMana(shorthand) {
+		if (!shorthand || typeof shorthand !== "string") throw new InvalidScryfallArgumentError("shorthand must be a string");
+		return await fetcher("symbology/parse-mana", { cost: shorthand }) ?? {
+			cmc: 0,
+			colorless: false,
+			colors: [],
+			cost: "",
+			monocolored: false,
+			multicolored: false,
+			object: "mana_cost"
+		};
+	}
+};
+const symbology = new SymbologyApi();
+
+export { CardIdentifierApi as CardIdentifierBuilder, cards as Cards, catalog as Catalogs, InvalidScryfallArgumentError, MagicPageResult, rulings as Rulings, ScryfallError, set as Sets, symbology as SymbologyApi, UnknownScryfallError };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "scryfall-api",
-	"version": "4.0.4",
+	"version": "5.0.0",
 	"description": "A Javascript library for https://scryfall.com/docs/api written in Typescript.",
 	"keywords": [
 		"magic",
@@ -28,37 +28,35 @@
 	"files": [
 		"dist"
 	],
-	"main": "./dist/scryfall-api.js",
-	"module": "./dist/scryfall-api.js",
-	"types": "./dist/scryfall-api.d.ts",
+	"main": "./dist/scryfall-api.mjs",
+	"types": "./dist/scryfall-api.d.mts",
 	"exports": {
 		".": {
-			"import": {
-				"types": "./dist/scryfall-api.d.ts",
-				"default": "./dist/scryfall-api.js"
-			},
-			"require": {
-				"types": "./dist/scryfall-api.d.cts",
-				"default": "./dist/scryfall-api.cjs"
-			},
-			"default": "./dist/scryfall-api.js"
+			"import": "./dist/scryfall-api.d.mts"
 		}
 	},
 	"scripts": {
-		"build": "tsup",
-		"lint": "eslint .",
-		"lint:fix": "eslint --fix .",
-		"prepublishOnly": "tsup",
+		"build": "tsdown",
+		"commitlint": "commitlint --edit",
+		"lint": "eslint --cache .",
+		"lint:ci": "eslint --cache --cache-strategy content .",
+		"lint:fix": "eslint --cache --fix .",
+		"prepare": "husky",
+		"prepublishOnly": "tsdown",
 		"test": "bun test --timeout 50000",
 		"typecheck": "tsc --noEmit"
 	},
 	"devDependencies": {
-		"@changesets/cli": "2.29.7",
-		"@hexadrop/eslint-config": "0.1.9",
+		"@changesets/cli": "3.0.3",
+		"@commitlint/cli": "21.2.4",
+		"@commitlint/config-conventional": "21.2.4",
+		"@hexadrop/eslint-config": "1.3.1",
 		"@hexadrop/tsconfig": "0.0.5",
-		"@types/bun": "1.2.23",
-		"eslint": "9.37.0",
-		"tsup": "8.5.0",
-		"typescript": "5.9.3"
+		"@types/bun": "1.4.4",
+		"eslint": "10.13.0",
+		"husky": "9.1.7",
+		"lint-staged": "17.6.0",
+		"tsdown": "0.23.4",
+		"typescript": "6.0.3"
 	}
 }