@pkmn/data 0.6.4 → 0.7.0

package/README.md

@@ -90,7 +90,7 @@ import {Generations} from '@pkmn/data';
 
 const gens = new Generations(Dex);
 assert(gens.get(1).types.get('Ghost').effectiveness['Psychic'] === 0);
-assert(gens.get(8).types.totalEffectiveness('Dark', ['Ghost', 'Psychic']) === 4);
+assert(gens.get(9).types.totalEffectiveness('Dark', ['Ghost', 'Psychic']) === 4);
 assert(gens.get(5).species.get('Dragapult') === undefined);
 assert(gens.get(3).species.get('Chansey').prevo === undefined);
 assert(Array.from(gens.get(1).species).length === 151);
@@ -118,9 +118,9 @@ release. This can be accomplished by passing an `ExistsFn` implementation as the
 the `Generations` constructor:
 
 ```ts
-// These species are unobtainable outside of their own generations, but this data gets lost in the 
-// Pokémon Showdown data files because isNonstandard is a scalar value and isNonstandard = 'Past'
-// overwrites the isNonstandard = 'Unobtainable' designation
+// These species are unobtainable outside of their own generations, but @pkmn/dex doesn't contain
+// the artificial 'natDexTier' field which allows Pokémon Showdown to track this so we harcode it.
+// If using @pkmn/sim instead, this list can be replaced with a `d.natDexTier !== 'Illegal'` check.
 const NATDEX_UNOBTAINABLE_SPECIES = [
   'Eevee-Starter', 'Floette-Eternal', 'Pichu-Spiky-eared', 'Pikachu-Belle', 'Pikachu-Cosplay',
   'Pikachu-Libre', 'Pikachu-PhD', 'Pikachu-Pop-Star', 'Pikachu-Rock-Star', 'Pikachu-Starter',
@@ -128,14 +128,14 @@ const NATDEX_UNOBTAINABLE_SPECIES = [
 ];
 
 const NATDEX_EXISTS = (d: Data, g: GenerationNum) => {
-  // The "National Dex" rules only apply to gen 8, but this ExistsFn gets called on all generations
-  if (g !== 8) return Generations.DEFAULT_EXISTS(d, g);
+  // The "National Dex" rules only apply to gen 8+, but this ExistsFn gets called on all generations
+  if (g < 8) return Generations.DEFAULT_EXISTS(d, g);
   // These checks remain unchanged from the default existence filter
   if (!d.exists) return false;
   if (d.kind === 'Ability' && d.id === 'noability') return false;
   // "National Dex" rules allows for data from the past, but not other forms of nonstandard-ness
   if ('isNonstandard' in d && d.isNonstandard && d.isNonstandard !== 'Past') return false;
-  // Unlike the check in the default existence function we don't want to filter out the 'Illegal' tier
+  // Unlike the check in the default existence function we don't want to filter the 'Illegal' tier
   if ('tier' in d && d.tier === 'Unreleased') return false;
   // Filter out the unobtainable species
   if (d.kind === 'Species' && NATDEX_UNOBTAINABLE_SPECIES.includes(d.name)) return false;
@@ -180,10 +180,10 @@ typechecking, but in the case of `@pkmn/data` the wrapper is required as `Genera
 The recommended way of using `@pkmn/data` in a web browser is to **configure your bundler**
 ([Webpack](https://webpack.js.org/), [Rollup](https://rollupjs.org/),
 [Parcel](https://parceljs.org/), etc) to minimize it and package it with the rest of your
-application. If you do not use a bundler, a convenience `production.min.js` is included in the
-package. You simply need to depend on `./node_modules/@pkmn/data/build/production.min.js` in a
-`script` tag (which is what the unpkg shortcut above is doing), after which **`Generations` will be
-accessible as a global.**
+application. If you do not use a bundler, a convenience `index.min.js` is included in the package.
+You simply need to depend on `./node_modules/@pkmn/data/build/index.min.js` in a `script` tag (which
+is what the unpkg shortcut above is doing), after which **`pkmn.data` will be accessible as a
+global.**
 
 ## Limitations
 

package/build/index.d.ts

@@ -1,8 +1,11 @@
-import { AbilityName, Condition, Data, Dex, EggGroup, EvoType, FormeName, GenderName, GenerationNum, ID, ItemName, Move, MoveCategory, MoveName, MoveSource, Nature, Nonstandard, Species as DexSpecies, SpeciesAbility, SpeciesName, SpeciesTag, StatID, StatsTable, Tier, Type as DexType, TypeName } from '@pkmn/dex-types';
-export declare type ExistsFn = (d: Data, g: GenerationNum) => boolean;
-declare type BoundExistsFn = (d: Data) => boolean;
-export declare function toID(text: any): ID;
-export declare class Generations {
+import * as _pkmn_dex_types from '@pkmn/dex-types';
+import { Data, GenerationNum, ID, Dex, Move, Species as Species$1, SpeciesName, Nonstandard, StatsTable, FormeName, SpeciesAbility, AbilityName, TypeName, EggGroup, SpeciesTag, Tier, MoveName, ItemName, GenderName, EvoType, Condition, Nature, MoveCategory, Type as Type$1, MoveSource, StatID } from '@pkmn/dex-types';
+export { Ability, AbilityData, AbilityName, As, BasicEffect, BoostID, BoostsTable, Condition, ConditionData, Data, DataKind, Dex, Effect, EffectData, EffectType, EggGroup, EventInfo, EventInfoData, EvoType, FieldCondition, FormeName, GameType, GenID, GenderName, GenerationNum, HPColor, HPTypeName, HitEffect, ID, Item, ItemData, ItemName, Learnset, LearnsetData, Move, MoveCategory, MoveData, MoveName, MoveSource, MoveTarget, Nature, NatureData, NatureName, Nonstandard, Player, PokemonSet, SecondaryEffect, SideCondition, SideID, SpeciesData, SpeciesName, StatID, StatsTable, StatusName, Tier, TypeData, TypeName, Weather } from '@pkmn/dex-types';
+
+type ExistsFn = (d: Data, g: GenerationNum) => boolean;
+type BoundExistsFn = (d: Data) => boolean;
+declare function toID(text: any): ID;
+declare class Generations {
     private readonly cache;
     private readonly dex;
     private readonly exists;
@@ -11,7 +14,7 @@ export declare class Generations {
     get(g: string | number): Generation;
     [Symbol.iterator](): Generator<Generation, void, unknown>;
 }
-export declare class Generation {
+declare class Generation {
     readonly abilities: Abilities;
     readonly items: Items;
     readonly moves: Moves;
@@ -29,28 +32,28 @@ export declare class Generation {
     toString(): string;
     toJSON(): string;
 }
-export declare class Abilities {
+declare class Abilities {
     private readonly dex;
     private readonly exists;
     constructor(dex: Dex, exists: BoundExistsFn);
-    get(name: string): import("@pkmn/dex-types").Ability | undefined;
-    [Symbol.iterator](): Generator<import("@pkmn/dex-types").Ability, void, unknown>;
+    get(name: string): _pkmn_dex_types.Ability | undefined;
+    [Symbol.iterator](): Generator<_pkmn_dex_types.Ability, void, unknown>;
 }
-export declare class Items {
+declare class Items {
     private readonly dex;
     private readonly exists;
     constructor(dex: Dex, exists: BoundExistsFn);
-    get(name: string): import("@pkmn/dex-types").Item | undefined;
-    [Symbol.iterator](): Generator<import("@pkmn/dex-types").Item, void, unknown>;
+    get(name: string): _pkmn_dex_types.Item | undefined;
+    [Symbol.iterator](): Generator<_pkmn_dex_types.Item, void, unknown>;
 }
-export declare class Moves {
+declare class Moves {
     private readonly dex;
     private readonly exists;
     constructor(dex: Dex, exists: BoundExistsFn);
     get(name: string): Move | undefined;
     [Symbol.iterator](): Generator<Move, void, unknown>;
 }
-export declare class Species {
+declare class Species {
     private readonly cache;
     private readonly dex;
     private readonly exists;
@@ -58,7 +61,7 @@ export declare class Species {
     get(name: string): Specie | undefined;
     [Symbol.iterator](): Generator<Specie, void, unknown>;
 }
-export declare class Specie implements DexSpecies {
+declare class Specie implements Species$1 {
     readonly id: ID;
     readonly name: SpeciesName;
     readonly fullname: string;
@@ -120,32 +123,32 @@ export declare class Specie implements DexSpecies {
     readonly canHatch: boolean;
     private readonly dex;
     private static readonly EXCLUDE;
-    constructor(dex: Dex, exists: BoundExistsFn, species: DexSpecies);
+    constructor(dex: Dex, exists: BoundExistsFn, species: Species$1);
     get formeNum(): number;
     toString(): SpeciesName;
     toJSON(): {
         [key: string]: any;
     };
 }
-export declare class Conditions {
+declare class Conditions {
     private readonly dex;
     private readonly exists;
     constructor(dex: Dex, exists: BoundExistsFn);
     get(name: string): Condition | undefined;
 }
-export declare class Natures {
+declare class Natures {
     private readonly dex;
     private readonly exists;
     constructor(dex: Dex, exists: BoundExistsFn);
     get(name: string): Nature | undefined;
     [Symbol.iterator](): Generator<Nature, void, unknown>;
 }
-declare type TypeTarget = {
+type TypeTarget = {
     getTypes: () => TypeName[];
 } | {
     types: TypeName[];
 } | TypeName[] | TypeName;
-export declare class Types {
+declare class Types {
     private readonly cache;
     private readonly unknown;
     private readonly dex;
@@ -164,8 +167,8 @@ export declare class Types {
         type: TypeName;
     } | TypeName, target: TypeTarget): number;
 }
-export declare type TypeEffectiveness = 0 | 0.5 | 1 | 2;
-export declare class Type {
+type TypeEffectiveness = 0 | 0.5 | 1 | 2;
+declare class Type {
     readonly id: ID;
     readonly name: TypeName;
     readonly effectType: 'Type';
@@ -179,7 +182,7 @@ export declare class Type {
     readonly HPdvs: Partial<StatsTable>;
     readonly category?: Exclude<MoveCategory, 'Status'>;
     private readonly types;
-    constructor(type: DexType, dex: Dex, types: Types);
+    constructor(type: Type$1, dex: Dex, types: Types);
     canDamage(target: TypeTarget): boolean;
     totalEffectiveness(target: TypeTarget): number;
     toString(): TypeName;
@@ -187,23 +190,23 @@ export declare class Type {
         [key: string]: any;
     };
 }
-declare type Restriction = 'Pentagon' | 'Plus' | 'Galar';
-export declare class Learnsets {
+type Restriction = 'Pentagon' | 'Plus' | 'Galar' | 'Paldea';
+declare class Learnsets {
     private readonly cache;
     private readonly gen;
     private readonly dex;
     private readonly exists;
     constructor(gen: Generation, dex: Dex, exists: BoundExistsFn);
-    get(name: string): Promise<import("@pkmn/dex-types").Learnset | undefined>;
-    [Symbol.iterator](): AsyncGenerator<import("@pkmn/dex-types").Learnset, void, unknown>;
-    all(species: Specie): AsyncGenerator<import("@pkmn/dex-types").Learnset, void, unknown>;
+    get(name: string): Promise<_pkmn_dex_types.Learnset | undefined>;
+    [Symbol.iterator](): AsyncGenerator<_pkmn_dex_types.Learnset, void, unknown>;
+    all(species: Specie): AsyncGenerator<_pkmn_dex_types.Learnset, void, unknown>;
     learnable(name: string, restriction?: Restriction): Promise<{
         [moveid: string]: string[];
     } | undefined>;
     canLearn(name: string, move: Move | string, restriction?: Restriction): Promise<boolean>;
     isLegal(move: Move, sources: MoveSource[] | undefined, gen: Generation | Restriction): boolean | undefined;
 }
-export declare class Stats {
+declare class Stats {
     private readonly dex;
     constructor(dex: Dex);
     calc(stat: StatID, base: number, iv?: number, ev?: number, level?: number, nature?: Nature): number;
@@ -215,4 +218,5 @@ export declare class Stats {
     toDV(iv: number): number;
     toIV(dv: number): number;
 }
-export { ID, As, Weather, FieldCondition, SideCondition, GenerationNum, GenderName, StatID, StatsTable, BoostID, BoostsTable, MoveCategory, MoveTarget, Nonstandard, EvoType, EggGroup, SideID, Player, GameType, HPColor, StatusName, NatureName, TypeName, HPTypeName, Tier, PokemonSet, AbilityName, ItemName, MoveName, SpeciesName, FormeName, EffectType, Effect, DataKind, Data, EffectData, HitEffect, SecondaryEffect, ConditionData, AbilityData, ItemData, MoveData, SpeciesData, MoveSource, EventInfoData, LearnsetData, TypeData, NatureData, BasicEffect, Condition, Ability, Item, Move, EventInfo, Learnset, Nature, GenID, Dex, } from '@pkmn/dex-types';
+
+export { Abilities, Conditions, ExistsFn, Generation, Generations, Items, Learnsets, Moves, Natures, Specie, Species, Stats, Type, TypeEffectiveness, Types, toID };