pfr-player-data 1.0.1 → 1.1.0

package/README.md

@@ -1,64 +1,141 @@
 # pfr-player-data
 
-Fetch NFL player data from [Pro Football Reference](https://www.pro-football-reference.com/) as structured JSON. This package scrapes a player’s PFR page and returns all available stats and info in a single JSON object.
+Fetch NFL player data from [Pro Football Reference](https://www.pro-football-reference.com/) as JSON. ESM-only.
 
-## Installation
+## Install
 
 ```bash
 npm install pfr-player-data
 ```
 
-## Usage
+## Methods
 
-```javascript
-const { getPlayerData } = require('pfr-player-data');
+- **`getPlayerData(input: string): Promise<Object>`** — Full parsed page (bio, raw careerStats tables, awardsAndHonors, gameLogs, url).
+- **`getSummaryPlayerData(input: string): Promise<Object>`** — Normalized career summary (name, position, careerStats by season + summary totals).
+- **`searchPlayers(name: string): Promise<Array<{ id, name, position, yearsActive, teams }>>`** — Search by player name; returns matches. Use `id` with `getPlayerData(id)` or `getSummaryPlayerData(id)`.
 
-// By player URL (e.g. https://www.pro-football-reference.com/players/B/BradTo00.htm)
-const data = await getPlayerData('https://www.pro-football-reference.com/players/B/BradTo00.htm');
+**Input** (getPlayerData / getSummaryPlayerData): player id or full URL.
 
-// Or by player identifier (e.g. PFR URL slug: BradTo00)
-const data = await getPlayerData('BradTo00');
-```
+- Player id (PFR slug): `'BradTo00'`, `'PeteAd01'`, `'McNaDo00'`
+- Full URL: `'https://www.pro-football-reference.com/players/B/BradTo00.htm'`
 
 ## API
 
-### `getPlayerData(input: string): Promise<Object>`
+### `getPlayerData(input)` → `Promise<Object>`
 
-- **`input`** — Either a full Pro Football Reference player URL or the player’s PFR identifier (e.g. `BradTo00`).
-- **Returns** — A Promise that resolves to a JSON object with all available player data from the page.
+Fetches the player page and returns the full parsed payload: `bio`, `summary`, `careerStats` (raw table arrays keyed by table id, e.g. `rushing_and_receiving`, `passing`), `awardsAndHonors`, `gameLogs`, `url`.
 
-## Example output
+### `getSummaryPlayerData(input)` → `Promise<Object>`
 
-The returned object includes (when present on the page):
+Uses `getPlayerData` and normalizes to a career summary: `name`, `position`, `careerStats` (structured by season type and category). Best for apps that need totals and a stable shape.
 
-- **Bio** — Name, position, team(s), birth date, college, draft info, etc.
-- **Career stats** — Passing, rushing, receiving, defense, kicking, etc., by season and/or career totals.
-- **Game logs** — Per-game stats when available.
-- **Awards & honors** — Pro Bowls, All-Pro, other recognitions.
-- **Other tables** — Any additional tables on the player’s page (e.g. splits, advanced metrics).
+### `searchPlayers(name)` → `Promise<Array<{ id, name, position, yearsActive, teams }>>`
+
+Searches PFR by name (e.g. `'adrian peterson'`). Each result has `id` (PFR slug, e.g. `PeteAd01`), `name`, `position`, `yearsActive` (e.g. `'2007-2021'`), and `teams` (array of team names). Use `id` to call `getPlayerData` or `getSummaryPlayerData`.
+
+## Usage
 
-Structure is normalized to a consistent JSON shape so you can use it in apps, scripts, or other services without parsing HTML.
+```js
+import { getPlayerData, getSummaryPlayerData, searchPlayers } from 'pfr-player-data';
 
-## Example
+// Search by name, then fetch with chosen id
+const results = await searchPlayers('adrian peterson');
+// [{ id: 'PeteAd00', name: 'Adrian Peterson', position: 'RB', yearsActive: '2002-2009', teams: ['Bears'] }, ...]
+const summary = await getSummaryPlayerData(results[1].id);  // e.g. PeteAd01
 
-```javascript
-const { getPlayerData } = require('pfr-player-data');
+// Or call directly with id / URL
+const full = await getPlayerData('BradTo00');
+const s = await getSummaryPlayerData('McNaDo00');
+```
 
-async function main() {
-  const player = await getPlayerData('BradTo00');
-  console.log(player.bio?.name);      // e.g. "Tom Brady"
-  console.log(player.careerStats);    // season-by-season and career totals
-  console.log(player.gameLogs);      // array of game log entries
+## Summary response shape
+
+`getSummaryPlayerData` returns:
+
+```ts
+{
+  name: string;
+  position: string;
+  careerStats: {
+    regularSeason: {
+      passing: { passCmp?, passAtt?, passYds?, passTd?, passInt?, passCmpPct?, passYdsPerAtt?, passYdsPerCmp?, passYdsPerG?, comebacks?, gwd?, games?, gamesStarted?, av?, awards?, ... };
+      rushingReceiving: { games?, gamesStarted?, rushAtt?, rushYds?, rushTd?, rec?, recYds?, recTd?, touches?, ydsFromScrimmage?, rushReceiveTd?, fumbles?, av?, awards?, ... };
+      teams: string[];
+    };
+    postSeason: {
+      passing: { ... };      // same keys as regularSeason.passing
+      rushingReceiving: { ... };
+      teams: string[];
+    };
+    allSeason: {
+      passing: { ... };     // cumulative (reg + post)
+      rushingReceiving: { ... };
+      teams: string[];
+    };
+    summary: {
+      tdsAll: number;      // tdsRush + tdsRec + tdsPass
+      tdsRush: number;
+      tdsRec: number;
+      tdsPass: number;
+      ydsAll: number;      // ydsRush + ydsRec + ydsPass
+      ydsRush: number;
+      ydsRec: number;
+      ydsPass: number;
+    };
+  };
 }
+```
+
+- **Passing** is populated from the PFR passing table (QBs); **rushingReceiving** from the rushing & receiving table. Missing categories are `{}`.
+- **summary** values are derived from **allSeason** (regular + postseason combined).
 
-main().catch(console.error);
+## Example output
+
+```json
+{
+  "name": "Adrian Peterson",
+  "position": "RB",
+  "careerStats": {
+    "regularSeason": {
+      "passing": {},
+      "rushingReceiving": {
+        "games": 184,
+        "gamesStarted": 167,
+        "rushAtt": 3230,
+        "rushYds": 14918,
+        "rushTd": 120,
+        "rec": 305,
+        "recYds": 2474,
+        "recTd": 6,
+        "touches": 3535,
+        "ydsFromScrimmage": 17392,
+        "rushReceiveTd": 126,
+        "fumbles": 49,
+        "av": 129
+      },
+      "teams": ["ARI", "DET", "MIN", "NOR", "SEA", "TEN", "WAS"]
+    },
+    "postSeason": { "passing": {}, "rushingReceiving": { ... }, "teams": [] },
+    "allSeason": { "passing": {}, "rushingReceiving": { ... }, "teams": [] },
+    "summary": {
+      "tdsAll": 131,
+      "tdsRush": 125,
+      "tdsRec": 6,
+      "tdsPass": 0,
+      "ydsAll": 17858,
+      "ydsRush": 15330,
+      "ydsRec": 2528,
+      "ydsPass": 0
+    }
+  }
+}
 ```
 
 ## Notes
 
-- **Pro Football Reference**: This package is not affiliated with Sports Reference LLC or Pro Football Reference. Data is scraped from their public site.
-- **Rate limiting**: Be respectful with request frequency (e.g. add delays or caching) to avoid overloading their servers.
-- **Terms of use**: Check [Pro Football Reference’s terms of use](https://www.sports-reference.com/termsofuse.html) before heavy or commercial use.
+- **ESM only.** Use `import`; no CommonJS support.
+- Not affiliated with Sports Reference LLC. Data is scraped from public pages.
+- Use reasonable request frequency and caching; respect [PFR terms of use](https://www.sports-reference.com/termsofuse.html).
 
 ## License
 

package/dist/index.js

@@ -0,0 +1,518 @@
+// src/parsePlayerPage.js
+import * as cheerio from "cheerio";
+var PFR_BASE = "https://www.pro-football-reference.com";
+function text($el) {
+  if (!$el || !$el.length) return "";
+  return $el.text().trim().replace(/\s+/g, " ");
+}
+function parseBio($) {
+  const bio = {};
+  const meta = $("#meta");
+  if (!meta.length) return bio;
+  const nameEl = $('h1[itemprop="name"]').first();
+  if (nameEl.length) bio.name = text(nameEl);
+  if (!bio.name) bio.name = text($("h1").first());
+  meta.find("p").each((_, p) => {
+    const $p = $(p);
+    const content = $p.html() || "";
+    const strongRegex = /<strong[^>]*>([^<]*)<\/strong>\s*:?\s*([^<]*)/gi;
+    let match;
+    while ((match = strongRegex.exec(content)) !== null) {
+      const key = match[1].replace(/\s*:\s*$/, "").trim().replace(/\s+/g, " ");
+      let val = match[2].trim();
+      const $links = $p.find("a");
+      $links.each((_2, a) => {
+        const $a = $(a);
+        const href = $a.attr("href") || "";
+        const linkText = text($a);
+        if (linkText && val.includes(linkText)) val = val.replace(linkText, linkText);
+      });
+      if (key && val) {
+        const camel = key.replace(/\s+(\w)/g, (_2, c) => c.toUpperCase()).replace(/\W/g, "");
+        if (camel) bio[camel] = val;
+      }
+    }
+  });
+  const firstP = $("#meta p").first();
+  if (firstP.length) {
+    const html = firstP.html() || "";
+    const fullNameMatch = html.match(/<strong[^>]*>([^<]+)<\/strong>/);
+    if (fullNameMatch) bio.fullName = fullNameMatch[1].trim();
+  }
+  return bio;
+}
+function parseSummary($) {
+  const summary = {};
+  $(".stats_pullout div").each((_, div) => {
+    const $div = $(div);
+    const divs = $div.find("div");
+    if (divs.length >= 2) {
+      const stat = text(divs.first());
+      const value = text(divs.last());
+      if (stat && value) summary[stat] = value;
+    }
+  });
+  return Object.keys(summary).length ? summary : null;
+}
+function buildTableHeaders($, tableEl) {
+  const $table = $(tableEl);
+  const $theadRows = $table.find("thead tr");
+  const headers = [];
+  const $headerRow = $theadRows.length ? $($theadRows[$theadRows.length - 1]) : $();
+  const seen = {};
+  $headerRow.find("th").each((_, th) => {
+    const $th = $(th);
+    const dataStat = $th.attr("data-stat");
+    let colName = dataStat || text($th).toLowerCase().replace(/\s+/g, "_").replace(/[^a-z0-9_]/g, "") || `col_${headers.length}`;
+    if (colName && seen[colName] !== void 0) {
+      seen[colName] = (seen[colName] || 0) + 1;
+      colName = `${colName}_${seen[colName]}`;
+    } else if (colName) {
+      seen[colName] = 0;
+    }
+    headers.push(colName);
+  });
+  return headers;
+}
+function parseTbodyRows($, tableEl, tbodyEl, headers) {
+  const rows = [];
+  $(tbodyEl).find("tr").each((_, tr) => {
+    const $tr = $(tr);
+    if ($tr.hasClass("thead")) return;
+    const row = {};
+    const cells = $tr.find("td, th");
+    cells.each((i, cell) => {
+      const $cell = $(cell);
+      const key = $cell.attr("data-stat") || headers[i] || `col_${i}`;
+      const link = $cell.find("a").first();
+      let val = link.length ? text(link) : text($cell);
+      if (val === "" && $cell.attr("data-stat")) val = null;
+      if (key && val !== void 0) row[key] = val;
+    });
+    if (Object.keys(row).length) rows.push(row);
+  });
+  return rows;
+}
+function parseTfootRows($, tableEl, headers) {
+  const rows = [];
+  $(tableEl).find("tfoot tr").each((_, tr) => {
+    const $tr = $(tr);
+    if ($tr.hasClass("spacer")) return;
+    const row = {};
+    const cells = $tr.find("td, th");
+    let headerIdx = 0;
+    cells.each((_2, cell) => {
+      const $cell = $(cell);
+      const colspan = Math.min(parseInt($cell.attr("colspan"), 10) || 1, headers.length - headerIdx);
+      const dataStat = $cell.attr("data-stat");
+      const link = $cell.find("a").first();
+      let val = link.length ? text(link) : text($cell);
+      if (val === "" && dataStat) val = null;
+      const key = dataStat || headers[headerIdx] || `col_${headerIdx}`;
+      if (key && val !== void 0) row[key] = val;
+      headerIdx += colspan;
+    });
+    if (Object.keys(row).length) rows.push(row);
+  });
+  return rows;
+}
+function parseTable($, tableEl) {
+  const $table = $(tableEl);
+  const headers = buildTableHeaders($, tableEl);
+  if (!headers.length) return [];
+  const rows = [];
+  $table.find("tbody").each((_, tbodyEl) => {
+    rows.push(...parseTbodyRows($, tableEl, tbodyEl, headers));
+  });
+  rows.push(...parseTfootRows($, tableEl, headers));
+  return rows;
+}
+function parseAllTables($) {
+  const tables = {};
+  $("table.stats_table").each((_, tableEl) => {
+    const $table = $(tableEl);
+    let id = $table.attr("id") || $table.closest("[id]").attr("id") || $table.closest("div[class]").attr("class")?.split(" ")[0] || `table_${Object.keys(tables).length}`;
+    id = id.replace(/^all_/, "");
+    const rows = parseTable($, tableEl);
+    if (rows.length) {
+      if (tables[id]) id = `${id}_playoffs`;
+      tables[id] = rows;
+    }
+  });
+  return tables;
+}
+function parseAwardsAndHonors($) {
+  const awards = [];
+  $("#meta ul li").each((_, li) => {
+    const t = text($(li));
+    if (t && !t.startsWith("Become a") && t.length < 200) awards.push(t);
+  });
+  return awards;
+}
+function parsePlayerPage(html) {
+  const $ = cheerio.load(html);
+  const bio = parseBio($);
+  const summary = parseSummary($);
+  const careerStats = parseAllTables($);
+  const awardsAndHonors = parseAwardsAndHonors($);
+  const result = {
+    bio: Object.keys(bio).length ? bio : null,
+    summary: summary || null,
+    careerStats: Object.keys(careerStats).length ? careerStats : null,
+    awardsAndHonors: awardsAndHonors.length ? awardsAndHonors : null,
+    gameLogs: null,
+    // game logs live on separate gamelog pages
+    otherTables: null
+  };
+  const mainIds = ["passing", "rushing_receiving", "defense", "punting", "scoring", "snap_counts"];
+  const other = {};
+  for (const [id, rows] of Object.entries(careerStats || {})) {
+    if (!mainIds.includes(id)) other[id] = rows;
+  }
+  if (Object.keys(other).length) result.otherTables = other;
+  return result;
+}
+
+// src/parseSearchPage.js
+import * as cheerio2 from "cheerio";
+
+// src/summaryUtils.js
+function snakeToCamel(s) {
+  if (typeof s !== "string") return s;
+  return s.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+function toNumber(val) {
+  if (val === null || val === void 0 || val === "") return void 0;
+  if (typeof val === "number" && !Number.isNaN(val)) return val;
+  const s = String(val).trim();
+  if (s === "") return void 0;
+  const n = Number(s.replace(/,/g, ""));
+  return Number.isNaN(n) ? val : n;
+}
+var RUSH_REC_STAT_MAP = {
+  games: "games",
+  games_started: "gamesStarted",
+  g: "games",
+  gs: "gamesStarted",
+  att: "rushAtt",
+  rush_att: "rushAtt",
+  yds: "rushYds",
+  rush_yds: "rushYds",
+  yds_1: "recYds",
+  yds_2: "recYds",
+  rec_yds: "recYds",
+  td: "rushTd",
+  rush_td: "rushTd",
+  td_1: "recTd",
+  td_2: "recTd",
+  rec_td: "recTd",
+  "1d": "rushFirstDown",
+  rush_first_down: "rushFirstDown",
+  "1d_1": "recFirstDown",
+  "1d_2": "recFirstDown",
+  rec_first_down: "recFirstDown",
+  rush_yds_per_att: "rushYdsPerAtt",
+  y_a: "rushYdsPerAtt",
+  rush_yds_per_g: "rushYdsPerG",
+  y_g: "rushYdsPerG",
+  rush_att_per_g: "rushAttPerG",
+  a_g: "rushAttPerG",
+  targets: "targets",
+  tgt: "targets",
+  rec: "rec",
+  rec_yds_per_rec: "recYdsPerRec",
+  y_r: "recYdsPerRec",
+  rec_per_g: "recPerG",
+  rec_yds_per_g: "recYdsPerG",
+  touches: "touches",
+  touch: "touches",
+  yds_per_touch: "ydsPerTouch",
+  y_tch: "ydsPerTouch",
+  ytch: "ydsPerTouch",
+  yds_from_scrimmage: "ydsFromScrimmage",
+  yds_scrimmage: "ydsFromScrimmage",
+  yscm: "ydsFromScrimmage",
+  rush_receive_td: "rushReceiveTd",
+  ctch: "recCatchPct",
+  succ_pct: "succPct",
+  lng: "lng",
+  fumbles: "fumbles",
+  fmb: "fumbles",
+  awards: "awards",
+  team: "team",
+  tm: "team",
+  team_name_abbr: "team",
+  av: "av"
+};
+var PASS_STAT_MAP = {
+  games: "games",
+  games_started: "gamesStarted",
+  pass_cmp: "passCmp",
+  pass_att: "passAtt",
+  pass_cmp_pct: "passCmpPct",
+  pass_yds: "passYds",
+  pass_td: "passTd",
+  pass_int: "passInt",
+  pass_yds_per_att: "passYdsPerAtt",
+  pass_yds_per_cmp: "passYdsPerCmp",
+  pass_yds_per_g: "passYdsPerG",
+  comebacks: "comebacks",
+  gwd: "gwd",
+  pass_first_down: "passFirstDown",
+  pass_sacked: "passSacked",
+  pass_sacked_yds: "passSackedYds",
+  pass_rating: "passRating",
+  qb_rec: "qbRec",
+  av: "av",
+  awards: "awards",
+  team_name_abbr: "team"
+};
+function buildPassingStatsFromRow(row) {
+  const out = {};
+  for (const [pfrKey, camelKey] of Object.entries(PASS_STAT_MAP)) {
+    if (camelKey === "team") continue;
+    const raw = row[pfrKey] ?? row[snakeToCamel(pfrKey)];
+    if (raw === void 0) continue;
+    if (camelKey === "awards") {
+      out.awards = parseAwards(raw);
+      continue;
+    }
+    if (camelKey === "qbRec") {
+      out[camelKey] = raw;
+      continue;
+    }
+    const num = toNumber(raw);
+    out[camelKey] = num !== void 0 ? num : raw;
+  }
+  return out;
+}
+function isCareerRow(row) {
+  const v = row.year_id ?? row.season ?? "";
+  const s = String(v).trim();
+  if (/^\d+\s*yrs?$/i.test(s)) return true;
+  if (/^career$/i.test(s)) return true;
+  if (/^\d+\s*game\s+avg$/i.test(s)) return false;
+  return false;
+}
+function parseAwards(awards) {
+  if (awards == null || awards === "") return [];
+  const s = String(awards).trim();
+  if (!s) return [];
+  return s.split(/[,;]/).map((a) => a.trim()).filter(Boolean);
+}
+function buildCareerStatsFromRow(row) {
+  const out = {};
+  for (const [pfrKey, camelKey] of Object.entries(RUSH_REC_STAT_MAP)) {
+    if (camelKey === "team") continue;
+    const raw = row[pfrKey] ?? row[snakeToCamel(pfrKey)];
+    if (raw === void 0) continue;
+    if (camelKey === "awards") {
+      out.awards = parseAwards(raw);
+      continue;
+    }
+    const num = toNumber(raw);
+    out[camelKey] = num !== void 0 ? num : raw;
+  }
+  return out;
+}
+function collectTeams(rows) {
+  const teams = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    const t = row.team ?? row.tm ?? row.team_name_abbr ?? "";
+    const s = String(t).trim();
+    if (/^[A-Z]{2,3}$/.test(s)) teams.add(s);
+    const match = s.match(/^([A-Z]{2,3})\s*\(/);
+    if (match) teams.add(match[1]);
+  }
+  return [...teams].sort();
+}
+function isAvgRow(row) {
+  const keys = ["year_id", "season", "team", "tm", "pos"];
+  for (const k of keys) {
+    const v = row[k];
+    if (v == null) continue;
+    if (/\d+\s*game\s+avg/i.test(String(v))) return true;
+  }
+  return false;
+}
+function findCareerRow(rows) {
+  for (let i = rows.length - 1; i >= 0; i--) {
+    if (isCareerRow(rows[i])) return rows[i];
+  }
+  const last = rows.length > 0 ? rows[rows.length - 1] : null;
+  return last && !isAvgRow(last) ? last : null;
+}
+function buildCareerSummary(allPassing, allRushRec) {
+  const tdsRush = allRushRec.rushTd ?? 0;
+  const tdsRec = allRushRec.recTd ?? 0;
+  const tdsPass = allPassing.passTd ?? 0;
+  const ydsRush = allRushRec.rushYds ?? 0;
+  const ydsRec = allRushRec.recYds ?? 0;
+  const ydsPass = allPassing.passYds ?? 0;
+  return {
+    tdsAll: tdsRush + tdsRec + tdsPass,
+    tdsRush,
+    tdsRec,
+    tdsPass,
+    ydsAll: ydsRush + ydsRec + ydsPass,
+    ydsRush,
+    ydsRec,
+    ydsPass
+  };
+}
+function buildSummaryFromFullData(fullData) {
+  const name = fullData.bio?.name ?? "";
+  const position = (fullData.bio?.Position ?? fullData.bio?.position ?? "").trim();
+  let teams = [];
+  let regularPassing = {};
+  let regularRushRec = {};
+  let postPassing = {};
+  let postRushRec = {};
+  const tables = fullData.careerStats ?? {};
+  const rushRec = tables.rushing_and_receiving ?? tables.rushing_receiving ?? Object.entries(tables).find(([k]) => k === "rushing_and_receiving" || k.includes("rushing") && !k.includes("_post") && !k.includes("playoff"))?.[1];
+  const rushRecPlayoffs = tables.rushing_and_receiving_post ?? tables.rushing_receiving_playoffs ?? tables.rushing_and_receiving_playoffs ?? Object.entries(tables).find(([k]) => k.includes("rushing") && (k.includes("_post") || k.includes("playoff")))?.[1];
+  if (Array.isArray(rushRec)) {
+    teams = collectTeams(rushRec);
+    const careerRow = findCareerRow(rushRec);
+    if (careerRow) regularRushRec = buildCareerStatsFromRow(careerRow);
+  }
+  if (Array.isArray(rushRecPlayoffs)) {
+    const careerRow = findCareerRow(rushRecPlayoffs);
+    if (careerRow) postRushRec = buildCareerStatsFromRow(careerRow);
+    teams = [.../* @__PURE__ */ new Set([...teams, ...collectTeams(rushRecPlayoffs || [])])].sort();
+  }
+  const passing = tables.passing ?? Object.entries(tables).find(([k]) => k === "passing" && !k.includes("_post"))?.[1];
+  const passingPost = tables.passing_post ?? Object.entries(tables).find(([k]) => k === "passing_post")?.[1];
+  if (Array.isArray(passing)) {
+    if (teams.length === 0) teams = collectTeams(passing);
+    const careerRow = findCareerRow(passing);
+    if (careerRow) regularPassing = buildPassingStatsFromRow(careerRow);
+  }
+  if (Array.isArray(passingPost)) {
+    const careerRow = findCareerRow(passingPost);
+    if (careerRow) postPassing = buildPassingStatsFromRow(careerRow);
+    teams = [.../* @__PURE__ */ new Set([...teams, ...collectTeams(passingPost || [])])].sort();
+  }
+  const cumulativeRushRec = /* @__PURE__ */ new Set([
+    "games",
+    "gamesStarted",
+    "rushAtt",
+    "rushYds",
+    "rushTd",
+    "rushFirstDown",
+    "targets",
+    "rec",
+    "recYds",
+    "recTd",
+    "recFirstDown",
+    "touches",
+    "ydsFromScrimmage",
+    "rushReceiveTd",
+    "fumbles",
+    "av"
+  ]);
+  const cumulativePass = /* @__PURE__ */ new Set([
+    "games",
+    "gamesStarted",
+    "passCmp",
+    "passAtt",
+    "passYds",
+    "passTd",
+    "passInt",
+    "passFirstDown",
+    "comebacks",
+    "gwd",
+    "passSacked",
+    "passSackedYds",
+    "av"
+  ]);
+  const allRushRec = {};
+  const allPassing = {};
+  for (const k of cumulativeRushRec) {
+    const r = regularRushRec[k], p = postRushRec[k];
+    if (typeof r === "number" || typeof p === "number") {
+      allRushRec[k] = (typeof r === "number" ? r : 0) + (typeof p === "number" ? p : 0);
+    } else if (r !== void 0) allRushRec[k] = r;
+    else if (p !== void 0) allRushRec[k] = p;
+  }
+  for (const k of cumulativePass) {
+    const r = regularPassing[k], p = postPassing[k];
+    if (typeof r === "number" || typeof p === "number") {
+      allPassing[k] = (typeof r === "number" ? r : 0) + (typeof p === "number" ? p : 0);
+    } else if (r !== void 0) allPassing[k] = r;
+    else if (p !== void 0) allPassing[k] = p;
+  }
+  const awardsRushRec = [.../* @__PURE__ */ new Set([...regularRushRec.awards || [], ...postRushRec.awards || []])];
+  const awardsPass = [.../* @__PURE__ */ new Set([...regularPassing.awards || [], ...postPassing.awards || []])];
+  if (awardsRushRec.length) allRushRec.awards = awardsRushRec;
+  if (awardsPass.length) allPassing.awards = awardsPass;
+  const postTeamsUnique = [.../* @__PURE__ */ new Set([
+    ...collectTeams(rushRecPlayoffs || []),
+    ...collectTeams(passingPost || [])
+  ])].sort();
+  const regularSeason = {
+    passing: Object.keys(regularPassing).length ? regularPassing : {},
+    rushingReceiving: Object.keys(regularRushRec).length ? regularRushRec : {},
+    teams: [...teams]
+  };
+  const postSeason = {
+    passing: Object.keys(postPassing).length ? postPassing : {},
+    rushingReceiving: Object.keys(postRushRec).length ? postRushRec : {},
+    teams: postTeamsUnique
+  };
+  const allSeason = {
+    passing: Object.keys(allPassing).length ? allPassing : {},
+    rushingReceiving: Object.keys(allRushRec).length ? allRushRec : {},
+    teams: [...teams]
+  };
+  const summary = buildCareerSummary(allPassing, allRushRec);
+  return {
+    name,
+    position,
+    careerStats: {
+      regularSeason,
+      postSeason,
+      allSeason,
+      summary
+    }
+  };
+}
+
+// src/getPlayerData.js
+var PFR_SEARCH = `${PFR_BASE}/search/search.fcgi`;
+var PLAYER_URL_REGEX = /^https?:\/\/www\.pro-football-reference\.com\/players\/[A-Z]\/[\w.-]+\.htm$/i;
+function resolvePlayerUrl(input) {
+  const trimmed = (input || "").trim();
+  if (PLAYER_URL_REGEX.test(trimmed)) return trimmed;
+  const match = trimmed.match(/\/players\/([A-Z])\/([\w.-]+)\.htm/i);
+  if (match) {
+    const [, letter2, id2] = match;
+    return `${PFR_BASE}/players/${letter2}/${id2}.htm`;
+  }
+  const id = trimmed.replace(/\.htm$/i, "");
+  if (!id) throw new Error("Invalid input: provide a PFR player URL or player id (e.g. BradTo00).");
+  const letter = id.charAt(0).toUpperCase();
+  return `${PFR_BASE}/players/${letter}/${id}.htm`;
+}
+async function getPlayerData(input) {
+  const url = resolvePlayerUrl(input);
+  const res = await fetch(url, {
+    headers: {
+      "User-Agent": "Mozilla/5.0 (compatible; pfr-player-data/1.0)",
+      "Accept": "text/html,application/xhtml+xml"
+    }
+  });
+  if (!res.ok) throw new Error(`Failed to fetch player page: ${res.status} ${res.statusText}`);
+  const html = await res.text();
+  const data = parsePlayerPage(html);
+  data.url = url;
+  return data;
+}
+async function getSummaryPlayerData(input) {
+  const fullData = await getPlayerData(input);
+  return buildSummaryFromFullData(fullData);
+}
+export {
+  getPlayerData,
+  getSummaryPlayerData
+};

package/package.json

@@ -1,21 +1,40 @@
 {
   "name": "pfr-player-data",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Fetch NFL player data from Pro Football Reference as JSON. Scrapes a player's PFR page and returns all available stats and info.",
   "type": "module",
-  "main": "index.js",
-  "module": "index.js",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
   "exports": {
-    ".": "./index.js"
+    ".": "./dist/index.js"
   },
   "files": [
-  "dist",
-  "index.js"
-],
+    "dist",
+    "README.md"
+  ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "npx esbuild src/index.js --bundle --format=esm --outfile=dist/index.js --external:cheerio",
+    "prepublishOnly": "npm run build",
+    "release:patch": "npm version patch && npm publish",
+    "release:minor": "npm version minor && npm publish",
+    "release:major": "npm version major && npm publish"
   },
-  "keywords": ["nfl", "pro-football-reference", "pfr", "scraper", "player-stats", "football", "sports-reference"],
+  "keywords": [
+    "nfl",
+    "pro-football-reference",
+    "pfr",
+    "scraper",
+    "player-stats",
+    "football",
+    "sports-reference"
+  ],
   "author": "",
-  "license": "ISC"
+  "license": "ISC",
+  "dependencies": {
+    "cheerio": "^1.0.0"
+  },
+  "devDependencies": {
+    "esbuild": "^0.24.0"
+  }
 }

package/index.js

@@ -1,3 +0,0 @@
-export function hello() {
-  return "hello world";
-}