@archivist-gg/dnd5e 0.3.1 → 0.3.5

package/dist/chunk-AIRFC5NQ.js

@@ -1,143 +0,0 @@
-import {
-  bareEntitySlug
-} from "./chunk-LV4SNWZQ.js";
-import {
-  ABILITY_KEYS
-} from "./chunk-WP2CX2JO.js";
-
-// src/pc/pc.feature-effects.ts
-function emptyFeatureEffectTotals() {
-  return {
-    initiative_bonus: 0,
-    hp_per_level_bonus: 0,
-    hp_per_level_terms: [],
-    speed_walk_bonus: 0,
-    speed_walk_set: 0,
-    senses: { darkvision: 0, blindsight: 0, tremorsense: 0, truesight: 0 },
-    ac_terms: [],
-    resistances: [],
-    condition_immunities: [],
-    proficiencies: { skills: [], tools: [], languages: [], saves: [], armor: [], weapons: [] },
-    weaponAbilities: [],
-    rollModifiers: [],
-    critRange: 20,
-    extraAttack: 0,
-    attackNotes: [],
-    damageBonuses: []
-  };
-}
-var ABILITY_NAME_TO_KEY = {
-  strength: "str",
-  dexterity: "dex",
-  constitution: "con",
-  intelligence: "int",
-  wisdom: "wis",
-  charisma: "cha"
-};
-function normalizeAbility(value) {
-  var _a;
-  const k = value.trim().toLowerCase();
-  if (ABILITY_KEYS.includes(k)) return k;
-  return (_a = ABILITY_NAME_TO_KEY[k]) != null ? _a : null;
-}
-function pushUnique(list, value) {
-  const key = value.trim().toLowerCase();
-  if (!key) return;
-  if (!list.some((v) => v.trim().toLowerCase() === key)) list.push(value.trim());
-}
-function computeFeatureEffects(features, opts) {
-  var _a, _b, _c;
-  const out = emptyFeatureEffectTotals();
-  for (const rf of features) {
-    if (rf.feature.activatable === true) {
-      const id = rf.feature.id;
-      if (!id || !((_a = opts == null ? void 0 : opts.activeBuffs) == null ? void 0 : _a.has(id))) continue;
-    }
-    for (const eff of (_b = rf.feature.effects) != null ? _b : []) {
-      applyEffect(out, eff, (_c = rf.feature.name) != null ? _c : "Feature");
-    }
-  }
-  return out;
-}
-function applyEffect(out, eff, label) {
-  var _a, _b;
-  switch (eff.kind) {
-    case "initiative-bonus":
-      out.initiative_bonus += eff.value;
-      break;
-    case "hp-per-level-bonus":
-      out.hp_per_level_bonus += eff.value;
-      out.hp_per_level_terms.push({ label, value: eff.value });
-      break;
-    case "speed-bonus":
-      if (eff.mode === "walk") {
-        if (eff.set) out.speed_walk_set = Math.max(out.speed_walk_set, eff.value);
-        else out.speed_walk_bonus += eff.value;
-      }
-      break;
-    case "sense":
-      out.senses[eff.type] = Math.max(out.senses[eff.type], eff.range);
-      break;
-    case "resistance":
-      pushUnique(out.resistances, eff.damage_type);
-      break;
-    case "immune-condition":
-      if (!eff.while) pushUnique(out.condition_immunities, eff.condition);
-      break;
-    case "proficiency": {
-      if (eff.proficiency_type === "skill") {
-        pushUnique(out.proficiencies.skills, eff.value.toLowerCase().replace(/\s+/g, "-"));
-      } else if (eff.proficiency_type === "tool") {
-        pushUnique(out.proficiencies.tools, eff.value);
-      } else if (eff.proficiency_type === "language") {
-        pushUnique(out.proficiencies.languages, eff.value);
-      } else if (eff.proficiency_type === "armor") {
-        pushUnique(out.proficiencies.armor, eff.value.toLowerCase());
-      } else if (eff.proficiency_type === "weapon") {
-        pushUnique(out.proficiencies.weapons, eff.value.toLowerCase());
-      } else {
-        const ab = normalizeAbility(eff.value);
-        if (ab && !out.proficiencies.saves.includes(ab)) out.proficiencies.saves.push(ab);
-      }
-      break;
-    }
-    case "ac-bonus":
-      out.ac_terms.push({ value: eff.value, requires_armor: eff.requires_armor === true, label });
-      break;
-    case "weapon-ability": {
-      if (eff.ability !== "spellcasting") {
-        const w = eff.weapons;
-        const weaponSlugs = !w || w === "chosen" ? void 0 : Array.isArray(w) ? w.map(bareEntitySlug) : [bareEntitySlug(w)];
-        out.weaponAbilities.push({ ability: eff.ability, weaponSlugs });
-      }
-      break;
-    }
-    case "roll-modifier":
-      out.rollModifiers.push({ mode: eff.mode, roll: eff.roll, scope: eff.scope, condition: eff.condition, label });
-      break;
-    case "crit-range":
-      if (((_a = eff.applies_to) != null ? _a : "weapon") !== "spell") out.critRange = Math.min(out.critRange, eff.min_roll);
-      break;
-    case "extra-attack":
-      out.extraAttack = Math.max(out.extraAttack, eff.count);
-      break;
-    case "reroll-damage":
-      out.attackNotes.push(`Reroll ${eff.max_reroll}s${eff.once_per_die ? " (once/die)" : ""}`);
-      break;
-    case "attack-rule":
-      if (eff.flag === "no-ranged-in-melee-disadvantage") out.attackNotes.push("No disadvantage firing in melee");
-      break;
-    case "damage-bonus":
-      if (((_b = eff.applies_to) != null ? _b : "weapon") !== "spell") {
-        out.damageBonuses.push({ amount: eff.amount, damage_type: eff.damage_type, source: label });
-      }
-      break;
-    default:
-      break;
-  }
-}
-
-export {
-  emptyFeatureEffectTotals,
-  computeFeatureEffects
-};

package/dist/chunk-CZPMTQOY.js

@@ -1,68 +0,0 @@
-import {
-  durationSchema
-} from "./chunk-WYGD2UGN.js";
-import {
-  resourceConsumptionSchema,
-  resourceSchema
-} from "./chunk-PZOWBI3B.js";
-import {
-  choiceSchema
-} from "./chunk-NXSWH3AE.js";
-import {
-  featureEffectSchema
-} from "./chunk-NXR3BD2V.js";
-
-// src/schemas/feature-schema.ts
-import { z as z2 } from "zod";
-
-// src/schemas/attack-schema.ts
-import { z } from "zod";
-var abilityEnum = z.enum(["str", "dex", "con", "int", "wis", "cha"]);
-var attackSchema = z.object({
-  name: z.string().min(1),
-  type: z.enum(["melee", "ranged", "spell"]),
-  ability: z.union([abilityEnum, z.array(abilityEnum).nonempty()]).optional(),
-  damage: z.string().optional(),
-  damage_type: z.string().optional(),
-  action: z.enum(["action", "bonus-action", "reaction"]).optional(),
-  properties: z.array(z.string()).optional(),
-  range: z.object({
-    normal: z.number().int().nonnegative().optional(),
-    long: z.number().int().nonnegative().optional(),
-    reach: z.number().int().nonnegative().optional()
-  }).optional(),
-  condition: z.string().optional()
-});
-
-// src/schemas/feature-schema.ts
-var featureSchema = z2.lazy(
-  () => z2.object({
-    id: z2.string().min(1).optional(),
-    name: z2.string().min(1),
-    description: z2.string().optional(),
-    entries: z2.array(z2.string()).optional(),
-    choices: z2.array(choiceSchema).optional(),
-    grants_resource: z2.string().optional(),
-    consumes: resourceConsumptionSchema.optional(),
-    attacks: z2.array(attackSchema).optional(),
-    action: z2.enum(["action", "bonus-action", "reaction", "free", "special"]).optional(),
-    trigger: z2.string().optional(),
-    dc_formula: z2.string().optional(),
-    effects: z2.array(featureEffectSchema).optional(),
-    sub_features: z2.array(featureSchema).optional(),
-    resources: z2.array(resourceSchema).optional(),
-    // Phase 3 activatable buffs: a feature flagged `activatable` folds its effects
-    // only while its id is present in state.active_buffs. `passive` renders a tag;
-    // `duration` is a static label (no live countdown this phase).
-    activatable: z2.boolean().optional(),
-    passive: z2.boolean().optional(),
-    duration: durationSchema.optional()
-  }).refine(
-    (f) => f.description !== void 0 || f.entries !== void 0 && f.entries.length > 0,
-    { message: "feature requires either description or non-empty entries" }
-  )
-);
-
-export {
-  featureSchema
-};

package/dist/chunk-N2JE7BWL.js

@@ -1,81 +0,0 @@
-import {
-  spellEntitySchema
-} from "./chunk-Y4I74YEG.js";
-
-// src/spell/spell.parser.ts
-import { parseYaml, toStringSafe } from "@archivist-gg/core";
-var KNOWN_KEYS = /* @__PURE__ */ new Set([
-  "name",
-  "level",
-  "school",
-  "casting_time",
-  "range",
-  "components",
-  "duration",
-  "concentration",
-  "ritual",
-  "classes",
-  "description",
-  "at_higher_levels",
-  "damage",
-  "saving_throw",
-  "casting_options",
-  // Body-only metadata that's emitted to YAML but ignored at runtime — accept silently.
-  "slug",
-  "edition",
-  "source"
-]);
-function parseSpell(source) {
-  const result = parseYaml(source, ["name"]);
-  if (!result.success) return result;
-  const meta = {};
-  if (typeof result.data.source === "string") meta.source = result.data.source;
-  if (typeof result.data.edition === "string") meta.edition = result.data.edition;
-  const filtered = {};
-  for (const [k, v] of Object.entries(result.data)) {
-    if (k === "slug" || k === "edition" || k === "source") continue;
-    if (!KNOWN_KEYS.has(k)) {
-      return { success: false, error: `Unknown spell field: ${k}` };
-    }
-    filtered[k] = v;
-  }
-  const parsed = spellEntitySchema.safeParse(filtered);
-  if (!parsed.success) {
-    return { success: false, error: `spell schema validation failed: ${parsed.error.message}` };
-  }
-  const raw = parsed.data;
-  const spell = { name: raw.name };
-  if (raw.level != null) spell.level = raw.level;
-  if (raw.school != null) spell.school = toStringSafe(raw.school);
-  if (raw.casting_time != null) spell.casting_time = toStringSafe(raw.casting_time);
-  if (raw.range != null) spell.range = toStringSafe(raw.range);
-  if (raw.components != null) spell.components = toStringSafe(raw.components);
-  if (raw.duration != null) spell.duration = toStringSafe(raw.duration);
-  if (raw.concentration != null) spell.concentration = Boolean(raw.concentration);
-  if (raw.ritual != null) spell.ritual = Boolean(raw.ritual);
-  if (raw.classes) spell.classes = raw.classes.map(String);
-  if (raw.description) spell.description = raw.description;
-  if (raw.at_higher_levels) spell.at_higher_levels = raw.at_higher_levels.map(String);
-  if (raw.damage) spell.damage = { types: raw.damage.types.map(String) };
-  if (raw.saving_throw) spell.saving_throw = { ability: raw.saving_throw.ability };
-  if (raw.casting_options) {
-    spell.casting_options = raw.casting_options.map((opt) => {
-      const co = { type: opt.type };
-      if (opt.damage_roll !== void 0) co.damage_roll = opt.damage_roll;
-      if (opt.target_count !== void 0) co.target_count = opt.target_count;
-      if (opt.duration !== void 0) co.duration = opt.duration;
-      if (opt.range !== void 0) co.range = opt.range;
-      if (opt.concentration !== void 0) co.concentration = opt.concentration;
-      if (opt.shape_size !== void 0) co.shape_size = opt.shape_size;
-      if (opt.desc !== void 0) co.desc = opt.desc;
-      return co;
-    });
-  }
-  if (meta.source) spell.source = meta.source;
-  if (meta.edition) spell.edition = meta.edition;
-  return { success: true, data: spell };
-}
-
-export {
-  parseSpell
-};

package/dist/chunk-NXR3BD2V.js

@@ -1,90 +0,0 @@
-// src/schemas/feature-effect-schema.ts
-import { z } from "zod";
-var featureEffectSchema = z.discriminatedUnion("kind", [
-  z.object({ kind: z.literal("initiative-bonus"), value: z.number().int() }),
-  z.object({ kind: z.literal("immune-condition"), condition: z.string().min(1), while: z.string().optional() }),
-  z.object({ kind: z.literal("resistance"), damage_type: z.string().min(1) }),
-  z.object({ kind: z.literal("hp-per-level-bonus"), value: z.number().int() }),
-  z.object({
-    kind: z.literal("speed-bonus"),
-    mode: z.enum(["walk", "fly", "swim", "climb", "burrow"]),
-    value: z.number().int(),
-    // when true, value is an absolute floor (Math.max), not additive; currently
-    // only surfaced for mode:"walk" — other modes have no derived speed yet.
-    set: z.boolean().optional()
-  }),
-  z.object({
-    kind: z.literal("sense"),
-    type: z.enum(["darkvision", "blindsight", "tremorsense", "truesight"]),
-    range: z.number().int().nonnegative()
-  }),
-  z.object({
-    kind: z.literal("apply-condition"),
-    condition: z.string().min(1),
-    duration: z.string().optional(),
-    ends_on: z.array(z.string()).optional(),
-    save_repeat: z.object({
-      ability: z.string().min(1),
-      timing: z.string().min(1)
-    }).optional()
-  }),
-  z.object({
-    kind: z.literal("damage-bonus"),
-    // intentionally an open string, NOT a damage-type enum: must accept the
-    // literal "chosen" (player-selected damage type at action time) alongside
-    // canonical damage types. Do not tighten to an enum.
-    damage_type: z.string().min(1),
-    amount: z.string().min(1),
-    applies_to: z.enum(["weapon", "spell", "all"]).optional(),
-    condition: z.string().optional()
-  }),
-  z.object({
-    kind: z.literal("proficiency"),
-    proficiency_type: z.enum(["skill", "tool", "language", "saving-throw", "armor", "weapon"]),
-    value: z.string().min(1)
-  }),
-  z.object({
-    kind: z.literal("ac-bonus"),
-    value: z.number().int(),
-    requires_armor: z.boolean().optional()
-  }),
-  z.object({
-    kind: z.literal("unarmored-ac"),
-    abilities: z.array(z.enum(["str", "dex", "con", "int", "wis", "cha"])),
-    base: z.number().int().optional(),
-    allow_shield: z.boolean().optional()
-  }),
-  z.object({
-    kind: z.literal("weapon-ability"),
-    ability: z.union([z.enum(["str", "dex", "con", "int", "wis", "cha"]), z.literal("spellcasting")]),
-    weapons: z.union([z.literal("chosen"), z.string(), z.array(z.string())]).optional()
-  }),
-  z.object({
-    kind: z.literal("roll-modifier"),
-    mode: z.enum(["advantage", "disadvantage"]),
-    roll: z.enum(["ability-check", "saving-throw", "attack"]),
-    scope: z.string().optional(),
-    condition: z.string().optional()
-  }),
-  z.object({ kind: z.literal("extra-attack"), count: z.number().int().positive() }),
-  z.object({
-    kind: z.literal("crit-range"),
-    min_roll: z.number().int().min(2).max(20),
-    applies_to: z.enum(["weapon", "spell", "all"]).optional(),
-    condition: z.string().optional()
-  }),
-  z.object({
-    kind: z.literal("reroll-damage"),
-    max_reroll: z.number().int().positive(),
-    applies_to: z.enum(["weapon", "spell", "all"]).optional(),
-    once_per_die: z.boolean().optional()
-  }),
-  z.object({
-    kind: z.literal("attack-rule"),
-    flag: z.enum(["no-ranged-in-melee-disadvantage"])
-  })
-]);
-
-export {
-  featureEffectSchema
-};

package/dist/chunk-O5EYMKFH.js

@@ -1,6 +0,0 @@
-// src/pc/pc.proficiency-normalize.ts
-var normKey = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim().split(/\s+/).filter(Boolean).map((w) => w.endsWith("s") ? w.slice(0, -1) : w).sort().join(" ");
-
-export {
-  normKey
-};

package/dist/chunk-Q5K6LWBZ.js

@@ -1,45 +0,0 @@
-import {
-  choiceSchema
-} from "./chunk-NXSWH3AE.js";
-import {
-  featureEffectSchema
-} from "./chunk-NXR3BD2V.js";
-
-// src/feat/feat.schema.ts
-import { z } from "zod";
-var abilityEnum = z.enum(["str", "dex", "con", "int", "wis", "cha"]);
-var editionEnum = z.enum(["2014", "2024"]);
-var categoryEnum = z.enum(["origin", "general", "fighting-style", "epic-boon"]);
-var prerequisiteSchema = z.discriminatedUnion("kind", [
-  z.object({ kind: z.literal("ability"), ability: abilityEnum, min: z.number().int().positive() }),
-  z.object({ kind: z.literal("level"), min: z.number().int().positive() }),
-  z.object({ kind: z.literal("spellcaster") }),
-  z.object({
-    kind: z.literal("proficiency"),
-    proficiency_type: z.enum(["armor", "weapon", "tool", "skill", "saving-throw"]),
-    value: z.string().min(1)
-  }),
-  z.object({ kind: z.literal("race"), slug: z.string().min(1) }),
-  z.object({ kind: z.literal("class"), slug: z.string().min(1) })
-]);
-var featEntitySchema = z.object({
-  slug: z.string().min(1),
-  name: z.string().min(1),
-  edition: editionEnum,
-  source: z.string().min(1),
-  category: categoryEnum,
-  description: z.string(),
-  prerequisites: z.array(prerequisiteSchema),
-  benefits: z.array(z.string()),
-  effects: z.array(featureEffectSchema),
-  grants_asi: z.object({
-    amount: z.number().int().positive(),
-    pool: z.array(abilityEnum).optional()
-  }).nullable(),
-  repeatable: z.boolean(),
-  choices: z.array(choiceSchema)
-});
-
-export {
-  featEntitySchema
-};