koffing 0.4.0 → 1.0.0

package/dist/index.mjs

@@ -0,0 +1,400 @@
+// 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();
+  }
+};
+export {
+  Koffing,
+  Pokemon,
+  PokemonTeam,
+  PokemonTeamSet,
+  ShowdownParser
+};

package/package.json

@@ -1,41 +1,36 @@
 {
   "name": "koffing",
-  "version": "0.4.0",
-  "license": "MIT",
-  "description": "Pokemon Showdown Team parser that converts your strategies to machine-readable JSON code.",
-  "author": "Javi Aguilar (@itjsavi)",
-  "keywords": [
-    "pokemon",
-    "smogon",
-    "showdown",
-    "pokemon-showdown"
-  ],
+  "version": "1.0.0",
   "repository": {
-    "type": "git",
-    "url": "git+https://github.com/capsulemonsters/koffing.git"
-  },
-  "bugs": {
-    "url": "https://github.com/capsulemonsters/koffing/issues"
+    "url": "https://github.com/itsjavi/koffing",
+    "type": "git"
   },
-  "homepage": "https://github.com/capsulemonsters/koffing#readme",
-  "main": "dist/koffing.js",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "module": "./dist/index.mjs",
+  "license": "MIT",
+  "files": [
+    "./dist/*",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
-    "start": "npx webpack-dev-server --config ./webpack.config-docs.js --mode development",
-    "build-dist": "npx webpack --mode production",
-    "build-docs": "npx webpack --config ./webpack.config-docs.js --mode production",
-    "build-all": "npm run build-dist && npm run build-docs",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "dev": "tsup src/index.ts --format=esm,cjs --watch --dts --external react",
+    "lint": "TIMING=1 eslint \"**/*.ts*\"",
+    "lint:ci": "yarn run lint",
+    "build": "tsup src/index.ts --format=esm,cjs --dts --external react",
+    "build:ci": "yarn run build",
+    "test": "jest --verbose --coverage --coverageDirectory=.coverage",
+    "test:ci": "jest --runInBand --ci --coverage --coverageDirectory=.coverage"
   },
   "devDependencies": {
-    "babel-cli": "^6.26.0",
-    "babel-loader": "^7.1.4",
-    "babel-preset-env": "^1.6.1",
-    "babel-preset-react": "^6.24.1",
-    "material-ui": "^1.0.0-beta.38",
-    "react": "^16.2.0",
-    "react-dom": "^16.2.0",
-    "webpack": "^4.2.0",
-    "webpack-cli": "^2.0.13",
-    "webpack-dev-server": "^3.1.1"
+    "@packages/preset-eslint": "workspace:^",
+    "@packages/preset-prettier": "workspace:^",
+    "@packages/preset-ts": "workspace:^",
+    "@types/jest": "^29.2.3",
+    "jest": "^29.3.1",
+    "ts-jest": "^29.0.3",
+    "tsup": "^6.5.0",
+    "typescript": "^4.9.4"
   }
 }