koffing 0.4.0 → 1.0.0

package/LICENSE

@@ -1,6 +1,6 @@
-The MIT License
+MIT License
 
-Copyright (c) 2018 Javi Aguilar (@itsjavi)
+Copyright (c) 2022 Javi Aguilar
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,138 +1,13 @@
 # Koffing
-Koffing is a Pokemon Showdown Team parser that converts your strategies to 
-machine-readable JSON code.
 
-![koffing](docs/assets/img/koffing.png) 🔁![koffing](docs/assets/img/koffing-shiny.png)
+![Build Status](https://github.com/itsjavi/koffing/actions/workflows/CI.yml/badge.svg?branch=develop)
 
-[Pokémon Showdown](https://www.pokemonshowdown.com/) is the most popular online Pokémon battle simulator,
-one of the best ways to quickly try your strategies for the official Pokémon VGC Championships. This library is just
-a parser for the teams generated by the [Showdown Team Builder](https://play.pokemonshowdown.com/teambuilder) exports.
-
-This repository holds the source code for the library as well as the code for the Online Parser.
-The [Online Parser](https://capsulemonsters.github.io/koffing), does not require you to download
-any library or script, it is recommended if all you want is to sanitize, prettify or convert to JSON your
-Showdown team exports.
+Koffing is a Pokemon Showdown importable-syntax parser for JavaScript and TypeScript.
 
 ## Features
 
-- Compatible with web browsers and NodeJS, including ES6+ imports
-- Converts from Showdown code to JSON
-- Converts from JSON to Showdown code
-- Sanitizes Showdown code (removing invalid data, applying max and mins values, etc.)
-- Prettifies Showdown code (proper indentation, line breaks and sorting of the data, etc.)
-- [Online Parser](https://capsulemonsters.github.io/koffing), which is using the library
-featuring all the above mentioned.
-
-## Installation
-
-As a package:
-```bash
-npm i --save koffing
-```
-
-In the browser, using a CDN:
-```html
-<script src="https://cdn.rawgit.com/capsulemonsters/koffing/0.4.0/dist/koffing.min.js"></script>
-```
-
-### Usage
-
-#### Modern Javascript (ES6+)
-```js
-"use strict";
-
-import {Koffing} from 'koffing';
-
-const teamCode = `
-=== [gen7] Folder 1/Example Team ===
-
-Smogon (Koffing) (F) @ Eviolite
-Level: 5
-Ability: Levitate
-Shiny: Yes
-Happiness: 255
-EVs: 36 HP / 236 Def / 236 SpD
-IVs: 31 HP / 30 Atk / 31 SpA / 30 SpD / 31 Spe
-Bold Nature
-- Will-O-Wisp
-- Pain Split
-- Sludge Bomb
-- Fire Blast`;
-
-
-let parsedTeam = Koffing.parse(teamCode);
-
-// This will log a PokémonTeamSet object:
-console.log(parsedTeam);
-// Convert it back to the Showdown format (prettified):
-console.log(parsedTeam.toShowdown());
-// which is the same as:
-console.log(parsedTeam.toString());
-// and the same as:
-console.log(parsedTeam + "");
-// You can also convert the object to JSON:
-console.log(parsedTeam.toJson());
-// which is the same as:
-console.log(Koffing.toJson(teamCode));
-```
-
-#### Web (ES5)
-```html
-<script src="dist/koffing.min.js"></script>
-<script>
-var teamCode = `=== [gen7] Folder 1/Example Team ===`;
-var parsedTeam = Koffing.parse(teamCode);
-console.log(parsedTeam);
-
-// Note that the ShowdownParser class, which is used internally by the Koffing class
-// is also exposed in the global scope:
-console.log(new ShowdownParser(teamCode).parse());
-</script>
-```
-
-#### NodeJS
-```js
-const Koffing = require('koffing').Koffing;
-
-const teamCode = `=== [gen7] Folder 1/Example Team ===`;
-let parsedTeam = Koffing.parse(teamCode);
-console.log(parsedTeam);
-```
-
-
-### Class Reference
-The `Koffing` class is basically a wrapper of the `ShowdownParser` class, the difference is that it can be used statically.
-
-`ShowdownParser` class methods:
-- `parse(): PokemonTeamSet`: Parses the Showdown code and returns a `PokemonTeamSet` object.
-- `format(): String`: Parses the Showdown code and returns a prettified and sanitized version of it.
-- `toString(): String`: Basically returns the internal Showdown code string as it is.
-
-`Koffing` class methods:
-- `static parse(showdownCode): PokemonTeamSet`: Wrapper for `ShowdownParser.prototype.parse()`
-- `static format(showdownCode): String`: Wrapper for `ShowdownParser.prototype.format()`
-- `static toJson(showdownCode): String`: Wrapper for `ShowdownParser.prototype.parse().toJson()`
-- `static toShowdown(jsonCode): String`: Wrapper for `ShowdownParser.prototype.parse().toShowdown()`
-
-## License
-
-This software is copyrighted and licensed under the 
-[MIT license](https://github.com/capsulemonsters/koffing/LICENSE).
-
-### Disclaimer
-
-This software comes bundled with data and graphics extracted from the
-Pokémon series of video games. Some terminology from the Pokémon franchise is
-also necessarily used within the software itself. This is all the intellectual
-property of Nintendo, Creatures, inc., and GAME FREAK, inc. and is protected by
-various copyrights and trademarks.
-
-The authors believe that the use of this intellectual property for a fan reference
-is covered by fair use and that the software is significantly impaired without said
-property included. Any use of this copyrighted property is at your own legal risk.
-
-This software is not affiliated in any way with Nintendo,
-Pokémon or any other game company.
+- Compatible with Gen 9 Pokémon definitions
+- Online parser
+- JS/TS Library
 
-A complete revision history of this software is available from
-https://github.com/capsulemonsters/koffing
+> The full version of this README file can be found at https://github.com/itsjavi/koffing

package/dist/index.d.ts

@@ -0,0 +1,106 @@
+type PokemonStats = {
+    hp: number;
+    atk: number;
+    def: number;
+    spa: number;
+    spd: number;
+    spe: number;
+};
+type PokemonGender = 'M' | 'F';
+declare class Pokemon {
+    name: string | undefined;
+    nickname: string | undefined;
+    gender: PokemonGender | undefined;
+    item: string | undefined;
+    pokeball: string | undefined;
+    ability: string | undefined;
+    level: number | undefined;
+    shiny: boolean | undefined;
+    happiness: number | undefined;
+    nature: string | undefined;
+    evs: PokemonStats | undefined;
+    ivs: PokemonStats | undefined;
+    dynamaxLevel: number | undefined;
+    gigantamax: boolean | undefined;
+    teraType: string | undefined;
+    moves: string[];
+    static fromObject(obj: Pokemon | Record<string, any>): Pokemon;
+    toJson(indentation?: number): string;
+    toShowdown(): string;
+    toString(): string;
+}
+
+declare class PokemonTeam {
+    name: string;
+    format: string;
+    folder: string | undefined;
+    pokemon: Pokemon[];
+    constructor(format?: string, name?: string, folder?: string | undefined);
+    static fromObject(obj: PokemonTeam | Record<string, any>): PokemonTeam;
+    toJson(indentation?: number): string;
+    toShowdown(): string;
+    toString(): string;
+}
+
+declare class PokemonTeamSet {
+    teams: PokemonTeam[];
+    constructor(teams?: PokemonTeam[]);
+    static fromObject(obj: PokemonTeamSet | Record<string, any>): PokemonTeamSet;
+    toJson(indentation?: number): string;
+    toShowdown(): string;
+    toString(): string;
+}
+
+type ParserState = {
+    team: PokemonTeam | null;
+    pokemon: Pokemon | null;
+};
+/**
+ * Ported from Pokemon Showdown Client's exportTeam/importTeam functions.
+ *
+ * @see https://github.com/Zarel/Pokemon-Showdown-Client/blob/master/js/storage.js
+ */
+declare class ShowdownParser {
+    static regexes: Record<string, RegExp>;
+    code: string;
+    constructor(code: string);
+    parse(): PokemonTeamSet;
+    _parseTeam(line: string, team: PokemonTeam): void;
+    _parseNameLine(line: string, pokemon: Pokemon): void;
+    _parseEvsIvs(line: string, pokemon: Pokemon | any): boolean;
+    _parseKeyValuePairs(line: string, pokemon: Pokemon | any): boolean;
+    /**
+     * Saves the current state of the parsed team.
+     */
+    _saveCurrent(teams: PokemonTeam[], current: ParserState): ShowdownParser;
+    /**
+     * Sanitizes and re-formats / prettifies the Showdown code
+     */
+    format(): ShowdownParser;
+    /**
+     * @returns {string}
+     */
+    toString(): string;
+}
+
+type DataType = string | Pokemon | PokemonTeam | PokemonTeamSet | ShowdownParser;
+declare class Koffing {
+    /**
+     * Converts from Showdown to a PokemonTeamSet object.
+     */
+    static parse(data: DataType): Pokemon | PokemonTeam | PokemonTeamSet;
+    /**
+     * Prettifies and sanitizes the given Showdown code.
+     */
+    static format(data: DataType): string;
+    /**
+     * Converts from Showdown to JSON code.
+     */
+    static toJson(data: DataType): string;
+    /**
+     * Converts from JSON string or JSON object to Showdown code.
+     */
+    static toShowdown(data: DataType | object): string;
+}
+
+export { Koffing, Pokemon, PokemonGender, PokemonStats, PokemonTeam, PokemonTeamSet, ShowdownParser };

package/dist/index.js

@@ -0,0 +1,431 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Koffing: () => Koffing,
+  Pokemon: () => Pokemon,
+  PokemonTeam: () => PokemonTeam,
+  PokemonTeamSet: () => PokemonTeamSet,
+  ShowdownParser: () => ShowdownParser
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/Pokemon.ts
+var POKEMON_STAT_NAMES = ["HP", "Atk", "Def", "SpA", "SpD", "Spe"];
+var Pokemon = class {
+  constructor() {
+    this.moves = [];
+  }
+  static fromObject(obj) {
+    const p = new Pokemon();
+    p.name = obj.name;
+    p.nickname = obj.nickname;
+    p.gender = obj.gender;
+    p.item = obj.item;
+    p.ability = obj.ability;
+    p.level = obj.level;
+    p.shiny = obj.shiny;
+    p.happiness = obj.happiness;
+    p.nature = obj.nature;
+    p.evs = obj.evs;
+    p.ivs = obj.ivs;
+    p.teraType = obj.teraType;
+    p.dynamaxLevel = obj.dynamaxLevel;
+    p.gigantamax = obj.gigantamax;
+    p.pokeball = obj.pokeball;
+    p.moves = Array.isArray(obj.moves) ? obj.moves : [];
+    return p;
+  }
+  toJson(indentation = 2) {
+    return JSON.stringify(this, null, indentation);
+  }
+  toShowdown() {
+    let str = "";
+    if (this.nickname) {
+      str += `${this.nickname} (${this.name})`;
+    } else {
+      str += `${this.name}`;
+    }
+    if (this.gender && this.gender.match(/^[MF]$/i)) {
+      str += ` (${this.gender.toUpperCase()})`;
+    }
+    if (this.item) {
+      str += ` @ ${this.item}`;
+    }
+    str += "\n";
+    if (this.ability) {
+      str += `Ability: ${this.ability}
+`;
+    }
+    if (!Number.isNaN(this.level)) {
+      str += `Level: ${this.level}
+`;
+    }
+    if (this.shiny === true) {
+      str += `Shiny: Yes
+`;
+    }
+    if (!Number.isNaN(this.happiness)) {
+      str += `Happiness: ${this.happiness}
+`;
+    }
+    if (this.pokeball) {
+      str += `Pokeball: ${this.pokeball}
+`;
+    }
+    if (!Number.isNaN(this.dynamaxLevel)) {
+      str += `Dynamax Level: ${this.dynamaxLevel}
+`;
+    }
+    if (this.gigantamax === true) {
+      str += `Gigantamax: Yes
+`;
+    }
+    if (this.teraType) {
+      str += `Tera Type: ${this.teraType}
+`;
+    }
+    if (this.evs) {
+      const evs = this.evs;
+      str += `EVs: ` + POKEMON_STAT_NAMES.filter(function(prop) {
+        return !isNaN(evs[prop.toLowerCase()]);
+      }).map(function(prop) {
+        const val = evs[prop.toLowerCase()];
+        return `${val} ${prop}`;
+      }).join(" / ") + "\n";
+    }
+    if (this.nature) {
+      str += `${this.nature} Nature
+`;
+    }
+    if (this.ivs) {
+      const ivs = this.ivs;
+      str += `IVs: ` + POKEMON_STAT_NAMES.filter(function(prop) {
+        return !isNaN(ivs[prop.toLowerCase()]);
+      }).map(function(prop) {
+        const val = ivs[prop.toLowerCase()];
+        return `${val} ${prop}`;
+      }).join(" / ") + "\n";
+    }
+    if (this.moves) {
+      str += this.moves.map(function(move) {
+        return `- ${move}`;
+      }).join("\n") + "\n";
+    }
+    return str.trim();
+  }
+  toString() {
+    return this.toShowdown();
+  }
+};
+
+// src/PokemonTeam.ts
+var PokemonTeam = class {
+  constructor(format = "gen9", name = "Untitled", folder = void 0) {
+    this.pokemon = [];
+    this.name = name;
+    this.format = format;
+    this.folder = folder;
+  }
+  static fromObject(obj) {
+    const team = new PokemonTeam();
+    team.name = obj.name;
+    team.format = obj.format;
+    team.folder = obj.folder;
+    team.pokemon = obj.pokemon ? obj.pokemon.map(function(pokemon) {
+      return Pokemon.fromObject(pokemon);
+    }) : [];
+    return team;
+  }
+  toJson(indentation = 2) {
+    return JSON.stringify(this, null, indentation);
+  }
+  toShowdown() {
+    const name = this.folder ? `${this.folder}/${this.name}` : this.name;
+    let str = `=== [${this.format}] ${name} ===
+
+`;
+    str += this.pokemon.map(function(p) {
+      return p.toString();
+    }).join("\n\n");
+    return str.trim();
+  }
+  toString() {
+    return this.toShowdown();
+  }
+};
+
+// src/PokemonTeamSet.ts
+var PokemonTeamSet = class {
+  constructor(teams = []) {
+    this.teams = teams;
+  }
+  static fromObject(obj) {
+    const teamSet = new PokemonTeamSet();
+    teamSet.teams = obj.teams ? obj.teams.map(function(team) {
+      return PokemonTeam.fromObject(team);
+    }) : [];
+    return teamSet;
+  }
+  toJson(indentation = 2) {
+    return JSON.stringify(this, null, indentation);
+  }
+  toShowdown() {
+    return this.teams.map(function(p) {
+      return p.toString();
+    }).join("\n\n").trim();
+  }
+  toString() {
+    return this.toShowdown();
+  }
+};
+
+// src/ShowdownParser.ts
+var clamp = (num, min, max) => {
+  if (Number.isNaN(num)) {
+    return min;
+  }
+  return Math.min(Math.max(num, min), max);
+};
+var _ShowdownParser = class {
+  constructor(code) {
+    this.code = code.toString().trim();
+  }
+  parse() {
+    const regexes = _ShowdownParser.regexes;
+    const teams = [];
+    const current = {
+      team: null,
+      pokemon: null
+    };
+    const lines = this.code.trim().split("\n").map(function(line) {
+      return line.trim();
+    });
+    lines.forEach((line) => {
+      if (line.match(regexes.team)) {
+        current.team = new PokemonTeam();
+        this._parseTeam(line, current.team);
+        teams.push(current.team);
+        return;
+      }
+      if (line === "" || line.match(/^[- ]+$/)) {
+        this._saveCurrent(teams, current);
+        return;
+      }
+      if (!current.pokemon) {
+        current.pokemon = new Pokemon();
+        this._parseNameLine(line, current.pokemon);
+        return;
+      }
+      if (this._parseKeyValuePairs(line, current.pokemon)) {
+        return;
+      }
+      if (this._parseEvsIvs(line, current.pokemon)) {
+        return;
+      }
+      if (current.pokemon.moves.length < 4 && line.match(regexes.move)) {
+        const moveMatches = regexes.move.exec(line);
+        if (moveMatches !== null) {
+          current.pokemon.moves.push(moveMatches[1].trim());
+        }
+      }
+    });
+    this._saveCurrent(teams, current);
+    return new PokemonTeamSet(teams);
+  }
+  _parseTeam(line, team) {
+    const rg = _ShowdownParser.regexes;
+    const teamDataMatches = rg.team.exec(line);
+    if (teamDataMatches && teamDataMatches.length >= 2) {
+      const teamNames = teamDataMatches[2].split("/");
+      let teamName, teamFolder;
+      if (teamNames.length > 1) {
+        teamFolder = teamNames.shift();
+        teamName = teamNames.join("/");
+      } else {
+        teamName = teamDataMatches[2];
+      }
+      team.format = teamDataMatches[1].trim();
+      team.name = teamName.trim();
+      team.folder = teamFolder ? teamFolder.trim() : void 0;
+    }
+  }
+  _parseNameLine(line, pokemon) {
+    const rg = _ShowdownParser.regexes;
+    if (line.match(rg.nickname_name)) {
+      const nameMatches = rg.nickname_name.exec(line);
+      if (nameMatches) {
+        pokemon.nickname = nameMatches[1].trim();
+        pokemon.name = nameMatches[2].trim();
+      }
+    } else if (line.match(rg.name)) {
+      const nameMatches = rg.name.exec(line);
+      if (nameMatches) {
+        pokemon.name = nameMatches[1].trim();
+      }
+    }
+    if (line.match(rg.gender)) {
+      const genderMatches = rg.gender.exec(line);
+      if (genderMatches) {
+        pokemon.gender = genderMatches[1].toUpperCase().trim();
+      }
+    }
+    if (line.match(rg.item)) {
+      const itemMatches = rg.item.exec(line);
+      if (itemMatches) {
+        pokemon.item = itemMatches[1].trim();
+      }
+    }
+  }
+  _parseEvsIvs(line, pokemon) {
+    const rg = _ShowdownParser.regexes;
+    if (line.match(rg.eivs)) {
+      const data = rg.eivs.exec(line);
+      if (data === null) {
+        return false;
+      }
+      const prop = data[1].toLowerCase();
+      const values = data[2].split("/");
+      const limit = prop === "evs" ? 255 : 31;
+      values.forEach(function(stat) {
+        const statData = rg.eivs_value.exec(stat.trim().toLowerCase());
+        if (!statData) {
+          console.error("Invalid syntax for " + prop + ": " + stat);
+          return;
+        }
+        if (!pokemon[prop]) {
+          pokemon[prop] = {};
+        }
+        pokemon[prop][statData[2]] = clamp(parseInt(statData[1]), 0, limit);
+      });
+      return true;
+    }
+    return false;
+  }
+  _parseKeyValuePairs(line, pokemon) {
+    const propNames = [
+      "nature",
+      "ability",
+      "level",
+      "shiny",
+      "happiness",
+      "pokeball",
+      "dynamaxLevel",
+      "gigantamax",
+      "teraType"
+    ];
+    return propNames.some(function(key) {
+      const matches = _ShowdownParser.regexes[key].exec(line);
+      if (matches === null) {
+        return false;
+      }
+      let value = matches[1].trim();
+      if (key === "happiness") {
+        value = clamp(parseInt(value), 0, 255);
+      } else if (key === "level") {
+        value = clamp(parseInt(value), 1, 100);
+      } else if (key === "dynamaxLevel") {
+        value = clamp(parseInt(value), 0, 10);
+      } else if (key.match(/^(shiny|gigantamax)$/i)) {
+        value = value.match(/yes/i) !== null ? true : void 0;
+      }
+      pokemon[key] = value;
+      return true;
+    });
+  }
+  _saveCurrent(teams, current) {
+    if (!current.team) {
+      current.team = new PokemonTeam();
+      teams.push(current.team);
+    }
+    if (current.pokemon) {
+      current.team.pokemon.push(current.pokemon);
+      current.pokemon = null;
+    }
+    return this;
+  }
+  format() {
+    this.code = this.parse().toString();
+    return this;
+  }
+  toString() {
+    return this.code;
+  }
+};
+var ShowdownParser = _ShowdownParser;
+ShowdownParser.regexes = {
+  team: /^===\s+\[(.*)\]\s+(.*)\s+===$/,
+  nickname_name: /^([^()=@]*)\s+\(([^()=@]{2,})\)/i,
+  name: /^([^()=@]{2,})/i,
+  gender: /\((F|M)\)/i,
+  item: /@\s?(.*)$/i,
+  eivs: /^([EI]Vs):\s?(.*)$/i,
+  eivs_value: /^([0-9]+)\s+(hp|atk|def|spa|spd|spe)$/i,
+  move: /^[-~]\s?(.*)$/i,
+  nature: /^(.*)\s+Nature$/,
+  ability: /^(?:Ability|Trait):\s?(.*)$/i,
+  level: /^Level:\s?([0-9]{1,3})$/i,
+  shiny: /^Shiny:\s?(Yes|No)$/i,
+  happiness: /^(?:Happiness|Friendship):\s?([0-9]{1,3})$/i,
+  pokeball: /^(?:Pokeball|Ball):\s?(.*)$/i,
+  dynamaxLevel: /^Dynamax Level:\s?([0-9]{1,2})$/i,
+  gigantamax: /^Gigantamax:\s?(Yes|No)$/i,
+  teraType: /^Tera Type:\s?(.*)$/i
+};
+
+// src/Koffing.ts
+var Koffing = class {
+  static parse(data) {
+    if (data instanceof PokemonTeamSet || data instanceof PokemonTeam || data instanceof Pokemon) {
+      return data;
+    }
+    if (data instanceof ShowdownParser) {
+      return data.parse();
+    }
+    return new ShowdownParser(data).parse();
+  }
+  static format(data) {
+    return this.parse(data).toShowdown();
+  }
+  static toJson(data) {
+    return this.parse(data).toJson();
+  }
+  static toShowdown(data) {
+    if (data instanceof PokemonTeamSet || data instanceof PokemonTeam || data instanceof Pokemon) {
+      return data.toShowdown();
+    }
+    if (data instanceof ShowdownParser) {
+      return data.parse().toShowdown();
+    }
+    if (typeof data === "string") {
+      data = JSON.parse(data);
+    }
+    return PokemonTeamSet.fromObject(data).toShowdown();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Koffing,
+  Pokemon,
+  PokemonTeam,
+  PokemonTeamSet,
+  ShowdownParser
+});