@archivist-gg/dnd5e 0.3.17 → 0.3.24

package/dist/chunk-DEEHHLAP.js

@@ -1,271 +0,0 @@
-import {
-  abilityModifier
-} from "./chunk-PDJSUH24.js";
-
-// src/dnd/srd-tag-converter.ts
-var ABILITY_KEYS = ["str", "dex", "con", "int", "wis", "cha"];
-var STATIC_FALLBACK_CONTEXT = {
-  abilities: { str: 0, dex: 0, con: 0, int: 0, wis: 0, cha: 0 },
-  profBonus: 0,
-  actionName: "",
-  actionCategory: "trait"
-};
-var NATURAL_MELEE_NAMES = /\b(bite|claws?|slam|gore|tail|hooves|tusks?|talons?|fist|horns?)\b/i;
-var FINESSE_WEAPON_NAMES = /\b(shortsword|rapier|dagger|whip|scimitar)\b/i;
-var RANGED_WEAPON_NAMES = /\b(bow|crossbow|sling|dart|blowgun|javelin)\b/i;
-var SPELL_ATTACK_PHRASES = /\bspell\s+attack\b/i;
-function preferredAbilitiesForAttack(actionName, desc, spellAbility) {
-  const combined = `${actionName} ${desc}`;
-  if (SPELL_ATTACK_PHRASES.test(combined) && spellAbility) return [spellAbility];
-  if (RANGED_WEAPON_NAMES.test(actionName)) return ["dex"];
-  if (FINESSE_WEAPON_NAMES.test(actionName)) return ["str", "dex"];
-  if (NATURAL_MELEE_NAMES.test(actionName)) return ["str", "dex"];
-  return ["str", "dex"];
-}
-function identifyAbility(damageBonus, preferred, mods) {
-  if (damageBonus === null) return null;
-  const candidates = ABILITY_KEYS.filter((k) => mods[k] === damageBonus);
-  if (candidates.length === 0) return null;
-  if (candidates.length === 1) return candidates[0];
-  for (const p of preferred) {
-    if (candidates.includes(p)) return p;
-  }
-  return [...candidates].sort()[0];
-}
-function parseDamageBonusFromHitText(desc, attackPos) {
-  const window = desc.slice(attackPos, attackPos + 250);
-  const damageRe = /Hit:\s*(?:\d+\s*\()?\d+d\d+(?:\s*([+-])\s*(\d+))?\s*\)?\s*\w*\s+damage/i;
-  const m = window.match(damageRe);
-  if (!m) return null;
-  if (m[1] === void 0 || m[2] === void 0) return 0;
-  return m[1] === "-" ? -Number(m[2]) : Number(m[2]);
-}
-function parseDamageBonusFor2024(desc, attackPos) {
-  const window = desc.slice(attackPos, attackPos + 250);
-  const damageRe = /(?:\d+\s*\()?\d+d\d+(?:\s*([+-])\s*(\d+))?\s*\)?\s*\w*\s+damage/i;
-  const m = window.match(damageRe);
-  if (!m) return null;
-  if (m[1] === void 0 || m[2] === void 0) return 0;
-  return m[1] === "-" ? -Number(m[2]) : Number(m[2]);
-}
-function convertDescToTags(desc, ctx) {
-  try {
-    if (!ctx.abilities) return desc;
-    const mods = computeMods(ctx.abilities);
-    const dcTargets = computeDcTargets(mods, ctx.profBonus);
-    let result = desc;
-    result = result.replace(
-      /(Strength|Dexterity|Constitution|Intelligence|Wisdom|Charisma)\s+Saving\s+Throw:\s+DC\s+(\d+)/gi,
-      (_match, abilityWord, n) => {
-        const dc = Number(n);
-        const abil = abilityWordToKey(abilityWord);
-        if (abil && dcTargets[abil] === dc) {
-          return `${abilityWord} Saving Throw: \`dc:${abil.toUpperCase()}\``;
-        }
-        return `${abilityWord} Saving Throw: \`dc:${dc}\``;
-      }
-    );
-    result = result.replace(
-      /DC (\d+)\s+(Strength|Dexterity|Constitution|Intelligence|Wisdom|Charisma)/gi,
-      (_match, n, abilityWord) => {
-        const dc = Number(n);
-        const abil = abilityWordToKey(abilityWord);
-        if (abil && dcTargets[abil] === dc) {
-          return `\`dc:${abil.toUpperCase()}\` ${abilityWord}`;
-        }
-        return `\`dc:${dc}\` ${abilityWord}`;
-      }
-    );
-    result = result.replace(
-      /(Melee|Ranged|Spell)\s+Attack\s+Roll:\s+([+-])(\d+),/g,
-      (match, kind, sign, n, offset) => {
-        const attackBonus = sign === "-" ? -Number(n) : Number(n);
-        const before = desc.slice(Math.max(0, offset - 200), offset);
-        const actionMatch = before.match(/(?:^|\.\s+)([A-Z][\w\s,'-]{1,40})\./);
-        const actionName = actionMatch ? actionMatch[1] : ctx.actionName;
-        const damageBonus = parseDamageBonusFor2024(desc, offset + match.length);
-        const preferred = kind.toLowerCase() === "spell" && ctx.spellAbility ? [ctx.spellAbility] : preferredAbilitiesForAttack(actionName, desc, ctx.spellAbility);
-        const ability = identifyAbility(damageBonus, preferred, mods);
-        const literal = attackBonus >= 0 ? `+${attackBonus}` : `${attackBonus}`;
-        if (ability === null) {
-          return `${kind} Attack Roll: \`atk:${literal}\`,`;
-        }
-        if (attackBonus === mods[ability] + ctx.profBonus) {
-          return `${kind} Attack Roll: \`atk:${ability.toUpperCase()}+PB\`,`;
-        }
-        if (attackBonus === mods[ability]) {
-          return `${kind} Attack Roll: \`atk:${ability.toUpperCase()}\`,`;
-        }
-        return `${kind} Attack Roll: \`atk:${literal}\`,`;
-      }
-    );
-    result = result.replace(
-      /([+-])(\d+)\s+to\s+hit/g,
-      (_match, sign, n, attackPos) => {
-        const attackBonus = sign === "-" ? -Number(n) : Number(n);
-        const before = desc.slice(Math.max(0, attackPos - 200), attackPos);
-        const actionMatch = before.match(/(?:^|\.\s+)([A-Z][\w\s,'-]{1,40})\./);
-        const actionName = actionMatch ? actionMatch[1] : ctx.actionName;
-        const damageBonus = parseDamageBonusFromHitText(desc, attackPos);
-        const preferred = preferredAbilitiesForAttack(actionName, desc, ctx.spellAbility);
-        const ability = identifyAbility(damageBonus, preferred, mods);
-        if (ability === null) {
-          const literal2 = attackBonus >= 0 ? `+${attackBonus}` : `${attackBonus}`;
-          return `\`atk:${literal2}\``;
-        }
-        if (attackBonus === mods[ability] + ctx.profBonus) {
-          return `\`atk:${ability.toUpperCase()}+PB\``;
-        }
-        if (attackBonus === mods[ability]) {
-          return `\`atk:${ability.toUpperCase()}\``;
-        }
-        const literal = attackBonus >= 0 ? `+${attackBonus}` : `${attackBonus}`;
-        return `\`atk:${literal}\``;
-      }
-    );
-    result = result.replace(
-      /(?:(\d+)\s*\()?(\d+d\d+)(?:\s*([+-])\s*(\d+))?\s*\)?(?:\s+(\w+))?\s+damage/gi,
-      (_match, _average, dice, sign, bonusStr, typeWord) => {
-        var _a;
-        let inner = dice;
-        if (bonusStr != null) {
-          const bonus = sign === "-" ? -Number(bonusStr) : Number(bonusStr);
-          const matchingAbilities = ABILITY_KEYS.filter((k) => mods[k] === bonus);
-          if (matchingAbilities.length > 0) {
-            const preferred = preferredAbilitiesForAttack(ctx.actionName, "", ctx.spellAbility);
-            const pick = (_a = preferred.find((p) => matchingAbilities.includes(p))) != null ? _a : [...matchingAbilities].sort()[0];
-            inner = `${dice}+${pick.toUpperCase()}`;
-          } else {
-            inner = `${dice}${bonus >= 0 ? "+" : ""}${bonus}`;
-          }
-        }
-        const typeSuffix = typeWord ? ` ${typeWord} damage` : " damage";
-        return `\`dmg:${inner}\`${typeSuffix}`;
-      }
-    );
-    result = result.replace(
-      /Hit:\s*(\d+)\s+(\w+)?\s*damage/gi,
-      (_match, n, typeWord) => {
-        const tt = typeWord ? ` ${typeWord} damage` : " damage";
-        return `Hit: \`dmg:${n}\`${tt}`;
-      }
-    );
-    result = result.replace(
-      /(?<!`)DC (\d+)(?!\s*(?:Strength|Dexterity|Constitution|Intelligence|Wisdom|Charisma))/gi,
-      (_match, n) => {
-        const dc = Number(n);
-        const candidates = ABILITY_KEYS.filter((k) => dcTargets[k] === dc);
-        if (ctx.spellAbility && candidates.includes(ctx.spellAbility)) {
-          return `\`dc:${ctx.spellAbility.toUpperCase()}\``;
-        }
-        if (candidates.length === 1) {
-          return `\`dc:${candidates[0].toUpperCase()}\``;
-        }
-        if (candidates.length > 1) {
-          const abil = disambiguateAbility(candidates, ctx, desc);
-          return `\`dc:${abil.toUpperCase()}\``;
-        }
-        return `\`dc:${dc}\``;
-      }
-    );
-    result = result.replace(
-      /`[^`]*`|(?<!\w)(\d+d\d+(?:\s*[+-]\s*\d+)?)(?!\w)/g,
-      (match, dice) => {
-        if (dice) return `\`dice:${dice.replace(/\s+/g, "")}\``;
-        return match;
-      }
-    );
-    return result;
-  } catch (e) {
-    return desc;
-  }
-}
-function computeMods(abilities) {
-  return {
-    str: abilityModifier(abilities.str),
-    dex: abilityModifier(abilities.dex),
-    con: abilityModifier(abilities.con),
-    int: abilityModifier(abilities.int),
-    wis: abilityModifier(abilities.wis),
-    cha: abilityModifier(abilities.cha)
-  };
-}
-function computeDcTargets(mods, profBonus) {
-  return {
-    str: 8 + profBonus + mods.str,
-    dex: 8 + profBonus + mods.dex,
-    con: 8 + profBonus + mods.con,
-    int: 8 + profBonus + mods.int,
-    wis: 8 + profBonus + mods.wis,
-    cha: 8 + profBonus + mods.cha
-  };
-}
-function disambiguateAbility(candidates, ctx, desc) {
-  var _a, _b, _c, _d, _e, _f, _g, _h;
-  if (candidates.length === 1) return candidates[0];
-  const combined = `${desc} ${ctx.actionName}`.toLowerCase();
-  const prefers = (abil) => candidates.includes(abil) ? abil : void 0;
-  if (/melee\s+or\s+ranged\s+weapon\s+attack/.test(combined)) {
-    return (_b = (_a = prefers("str")) != null ? _a : prefers("dex")) != null ? _b : candidates[0];
-  }
-  if (/melee\s+weapon\s+attack/.test(combined)) {
-    return (_d = (_c = prefers("str")) != null ? _c : prefers("dex")) != null ? _d : candidates[0];
-  }
-  if (/ranged\s+weapon\s+attack/.test(combined)) {
-    return (_e = prefers("dex")) != null ? _e : candidates[0];
-  }
-  if (/spell\s+attack/.test(combined)) {
-    if (ctx.spellAbility && candidates.includes(ctx.spellAbility)) {
-      return ctx.spellAbility;
-    }
-    return (_f = prefers("wis")) != null ? _f : candidates[0];
-  }
-  const rangedWords = /\b(bow|crossbow|dart|sling)\b/;
-  const meleeWords = /\b(bite|claw|slam|tail|gore|horns?|fist|hoof|talons?)\b/;
-  if (rangedWords.test(ctx.actionName.toLowerCase())) {
-    return (_g = prefers("dex")) != null ? _g : candidates[0];
-  }
-  if (meleeWords.test(ctx.actionName.toLowerCase())) {
-    return (_h = prefers("str")) != null ? _h : candidates[0];
-  }
-  return [...candidates].sort()[0];
-}
-function abilityWordToKey(word) {
-  const lower = word.toLowerCase();
-  switch (lower) {
-    case "strength":
-      return "str";
-    case "dexterity":
-      return "dex";
-    case "constitution":
-      return "con";
-    case "intelligence":
-      return "int";
-    case "wisdom":
-      return "wis";
-    case "charisma":
-      return "cha";
-  }
-  return void 0;
-}
-function detectSpellcastingAbility(traits) {
-  if (!traits) return void 0;
-  for (const trait of traits) {
-    for (const entry of trait.entries) {
-      const match = entry.match(/spellcasting ability is (intelligence|wisdom|charisma)/i);
-      if (match) {
-        const name = match[1].toLowerCase();
-        if (name === "intelligence") return "int";
-        if (name === "wisdom") return "wis";
-        if (name === "charisma") return "cha";
-      }
-    }
-  }
-  return void 0;
-}
-
-export {
-  STATIC_FALLBACK_CONTEXT,
-  convertDescToTags,
-  detectSpellcastingAbility
-};

package/dist/chunk-DOXSFYLH.js

@@ -1,158 +0,0 @@
-import {
-  durationSchema
-} from "./chunk-WYGD2UGN.js";
-import {
-  actionCostEnum,
-  resetTriggerEnum,
-  resourceConsumptionSchema
-} from "./chunk-ZJXSXVFP.js";
-import {
-  choiceSchema
-} from "./chunk-5MXFW4O3.js";
-import {
-  featureEffectSchema
-} from "./chunk-2JSQE3DD.js";
-import {
-  additionalSpellsEntrySchema,
-  imageField,
-  progressionSchema
-} from "./chunk-UA5KS2PL.js";
-
-// src/optional-feature/optional-feature.schema.ts
-import { z } from "zod";
-var editionEnum = z.enum(["2014", "2024"]);
-var abilityEnum = z.enum(["str", "dex", "con", "int", "wis", "cha"]);
-var wikilinkRegex = /^\[\[[^[\]]+\]\]$/;
-var namedRefSchema = z.object({ name: z.string().min(1), source: z.string().min(1).optional(), visible_stats: z.boolean().optional() });
-var prerequisiteSchema = z.discriminatedUnion("kind", [
-  z.object({ kind: z.literal("level"), min: z.number().int().positive(), class: namedRefSchema.optional(), subclass: namedRefSchema.optional() }),
-  z.object({ kind: z.literal("spell-known"), spell: z.string().regex(wikilinkRegex) }),
-  z.object({ kind: z.literal("pact"), pact: z.enum(["tome", "blade", "chain", "talisman"]) }),
-  z.object({ kind: z.literal("class"), class: z.string().regex(wikilinkRegex) }),
-  z.object({ kind: z.literal("ability"), ability: abilityEnum, min: z.number().int().positive() }),
-  z.object({ kind: z.literal("other"), detail: z.string() }),
-  z.object({ kind: z.literal("optionalfeature"), optionalfeature: z.string().regex(wikilinkRegex) }),
-  z.object({ kind: z.literal("spell-choose"), choose: z.string().min(1), entry: z.string().optional(), entry_summary: z.string().optional() })
-]);
-var usesSchema = z.object({
-  max: z.union([z.number(), z.string()]),
-  recharge: resetTriggerEnum,
-  /** Partial recovery, for a pool a rest does NOT fully refill (a sanity track that regains 1 per long
-   *  rest). Same shape a feature's `resources[].recovery` uses, so `ResolvedResource.recovery` — which
-   *  has carried the field since R4-G4 — is populated identically from either side. Optional: all 35
-   *  shipped `uses` carriers omit it and parse unchanged. */
-  recovery: z.array(z.object({
-    id: z.string().min(1),
-    name: z.string().min(1),
-    amount: z.union([z.number(), z.string()]),
-    reset: resetTriggerEnum,
-    restores: z.enum(["uses", "spell-slots"]).optional()
-  })).optional()
-});
-var filterSpecSchema = z.object({
-  rarity: z.array(z.string().min(1)).min(1),
-  types: z.array(z.string().min(1)).optional(),
-  exclude_types: z.array(z.string().min(1)).optional(),
-  cursed: z.literal(false).optional()
-}).strict();
-var optionCreatesSchema = z.object({
-  item: z.string().regex(wikilinkRegex).optional(),
-  variant: z.object({ candidates: z.array(z.string().regex(wikilinkRegex)).min(1) }).strict().optional(),
-  filter: filterSpecSchema.optional()
-}).strict().refine((c) => [c.item, c.variant, c.filter].filter((a) => a !== void 0).length === 1, { message: "creates needs exactly one of item, variant, filter" });
-var optionRowSchema = z.object({
-  key: z.string().regex(/^[a-z0-9][a-z0-9._-]*$/, "an option key is lower-case, with no '#' and no whitespace"),
-  name: z.string().min(1),
-  min_level: z.number().int().min(1).max(20),
-  attunement: z.boolean().optional(),
-  creates: optionCreatesSchema
-}).strict();
-var infuseItemSchema = z.object({
-  bonuses: z.object({
-    ac: z.number().int().optional(),
-    weapon_attack: z.number().int().optional(),
-    weapon_damage: z.number().int().optional(),
-    spell_attack: z.number().int().optional(),
-    saving_throws: z.number().int().optional(),
-    speed: z.object({ walk: z.number().int().optional(), fly: z.number().int().optional(), swim: z.number().int().optional(), climb: z.number().int().optional() }).strict().optional()
-  }).strict().optional(),
-  resist: z.array(z.string().min(1)).optional(),
-  charges: z.object({ max: z.number().int().min(1), dice: z.string().optional(), recharge: z.string().optional(), recharge_amount: z.string().optional() }).strict().optional(),
-  action: actionCostEnum.optional(),
-  // ART-c1 (R-3 a): the Actions row's range, as data (B-8.4 draws "Self").
-  range: z.string().min(1).optional()
-}).strict();
-var infuseBlockSchema = z.object({
-  targets: z.array(z.object({
-    kind: z.enum(["armor", "shield", "weapon", "gear"]),
-    category: z.array(z.string().min(1)).min(1).optional(),
-    property: z.string().min(1).optional(),
-    name_any: z.array(z.string().min(1)).min(1).optional()
-  }).strict()).min(1),
-  targets_label: z.string().min(1).optional(),
-  new_object: z.string().min(1).optional(),
-  rarity: z.string().min(1).optional(),
-  attunement: z.object({ required: z.literal(true) }).strict().optional(),
-  // ART-c1 (R-3 b): the damage types the choice offers (v1 U-4 draws the TCE ten); absent keeps dnd5e's canonical list.
-  choice: z.object({ kind: z.literal("damage-type"), options: z.array(z.string().min(1)).min(1).optional() }).strict().optional(),
-  item: infuseItemSchema.optional(),
-  scales_at: z.array(z.object({ level: z.number().int().min(1).max(20), item: infuseItemSchema }).strict()).optional()
-}).strict().refine((b) => {
-  var _a;
-  return ((_a = b.scales_at) != null ? _a : []).every((r, i, a) => i === 0 || a[i - 1].level < r.level);
-}, { message: "scales_at levels ascend" });
-var optionalFeatureEntitySchema = z.object({
-  slug: z.string().min(1),
-  name: z.string().min(1),
-  edition: editionEnum,
-  source: z.string().min(1),
-  feature_type: z.string().min(1),
-  description: z.string(),
-  prerequisites: z.array(prerequisiteSchema),
-  available_to: z.array(z.string().regex(wikilinkRegex)),
-  effects: z.array(featureEffectSchema),
-  action_cost: actionCostEnum.nullable().optional(),
-  uses: usesSchema.nullable().optional(),
-  consumes: resourceConsumptionSchema.nullable().optional(),
-  duration: durationSchema.nullable().optional(),
-  passive: z.boolean().optional(),
-  // Phase 3 activatable buffs: an activatable boon folds its effects only while
-  // its slug is present in state.active_buffs (toggled in the PoolTab).
-  activatable: z.boolean().optional(),
-  rendering_hint: z.string().optional(),
-  // the ONE root with load-bearing VALUES (88 records, G4's)
-  /** WHERE this resource is drawn. `band` puts it in the header strip beside HP; anything else, and the
-   *  default, leaves it to the Resources tab. The tab ALWAYS lists every resource — it is the complete
-   *  inventory of what the character can spend, and a row missing from it would read as a bug — so this
-   *  key only ever ADDS a second, curated home. Opt-in on purpose: the band's whole value is being short,
-   *  which an opt-out flag would erode one new grant at a time. */
-  surface: z.enum(["band", "tab"]).optional(),
-  additional_spells: z.array(additionalSpellsEntrySchema).optional(),
-  // 54
-  is_class_feature_variant: z.boolean().optional(),
-  // 25
-  has_fluff_images: z.boolean().optional(),
-  // 2
-  feat_progression: z.array(progressionSchema).optional(),
-  // 1
-  optionalfeature_progression: z.array(progressionSchema).optional(),
-  // 1
-  image: imageField,
-  repeatable: z.literal(true).optional(),
-  item_choice: z.enum(["learn", "create"]).optional(),
-  options: z.array(optionRowSchema).optional(),
-  infuse: infuseBlockSchema.optional(),
-  // D2b-A (design §2.2 step 1): a pool member's own choices, the vocabulary features and feats use.
-  choices: z.array(choiceSchema).optional()
-}).superRefine((d, ctx) => {
-  var _a;
-  if (d.repeatable && (!d.options || !d.item_choice)) ctx.addIssue({ code: "custom", message: "a repeatable note needs options and item_choice" });
-  const keys = ((_a = d.options) != null ? _a : []).map((o) => o.key);
-  if (new Set(keys).size !== keys.length) ctx.addIssue({ code: "custom", message: "option keys are unique" });
-});
-
-export {
-  optionRowSchema,
-  infuseBlockSchema,
-  optionalFeatureEntitySchema
-};