@archivist-gg/dnd5e 0.3.0 → 0.3.4

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-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
-};

package/dist/chunk-TZK36BU7.js

@@ -1,38 +0,0 @@
-// src/pc/conditions.constants.ts
-var CONDITION_SLUGS = [
-  "blinded",
-  "charmed",
-  "deafened",
-  "frightened",
-  "grappled",
-  "incapacitated",
-  "invisible",
-  "paralyzed",
-  "petrified",
-  "poisoned",
-  "prone",
-  "restrained",
-  "stunned",
-  "unconscious"
-];
-var CONDITION_DISPLAY_NAMES = {
-  blinded: "Blinded",
-  charmed: "Charmed",
-  deafened: "Deafened",
-  frightened: "Frightened",
-  grappled: "Grappled",
-  incapacitated: "Incapacitated",
-  invisible: "Invisible",
-  paralyzed: "Paralyzed",
-  petrified: "Petrified",
-  poisoned: "Poisoned",
-  prone: "Prone",
-  restrained: "Restrained",
-  stunned: "Stunned",
-  unconscious: "Unconscious"
-};
-
-export {
-  CONDITION_SLUGS,
-  CONDITION_DISPLAY_NAMES
-};

package/dist/chunk-W7HWMMBF.js

@@ -1,46 +0,0 @@
-import {
-  poolGrantSchema,
-  selectionPoolSchema,
-  tabDeclSchema
-} from "./chunk-4TIJKN6O.js";
-import {
-  featureSchema
-} from "./chunk-CZPMTQOY.js";
-import {
-  resourceSchema
-} from "./chunk-PZOWBI3B.js";
-
-// src/subclass/subclass.schema.ts
-import { z } from "zod";
-var editionEnum = z.enum(["2014", "2024"]);
-var wikilinkRegex = /^\[\[[^[\]]+\]\]$/;
-var casterTypeEnum = z.enum(["full", "half", "third", "pact"]);
-var abilityEnum = z.enum(["str", "dex", "con", "int", "wis", "cha"]);
-var spellcastingSchema = z.object({
-  caster_type: casterTypeEnum,
-  ability: abilityEnum,
-  preparation: z.enum(["known", "prepared"]),
-  spell_list: z.string().min(1)
-});
-var subclassTableRowSchema = z.object({
-  columns: z.record(z.string(), z.union([z.string(), z.number()])).optional()
-});
-var subclassEntitySchema = z.object({
-  slug: z.string().min(1),
-  name: z.string().min(1),
-  parent_class: z.string().regex(wikilinkRegex, "parent_class must be a wikilink like [[rogue]]"),
-  edition: editionEnum,
-  source: z.string().min(1),
-  description: z.string(),
-  spellcasting: spellcastingSchema.nullable().optional(),
-  table: z.record(z.string(), subclassTableRowSchema).optional(),
-  features_by_level: z.record(z.string(), z.array(featureSchema)),
-  resources: z.array(resourceSchema),
-  selection_pools: z.array(selectionPoolSchema).optional(),
-  pool_grants: z.array(poolGrantSchema).optional(),
-  tabs: z.array(tabDeclSchema).optional()
-});
-
-export {
-  subclassEntitySchema
-};

package/dist/chunk-Y4I74YEG.js

@@ -1,33 +0,0 @@
-// src/spell/spell.schema.ts
-import { z } from "zod";
-var castingOptionSchema = z.object({
-  type: z.string(),
-  damage_roll: z.string().optional(),
-  target_count: z.number().optional(),
-  duration: z.string().optional(),
-  range: z.number().optional(),
-  concentration: z.boolean().optional(),
-  shape_size: z.number().optional(),
-  desc: z.string().optional()
-});
-var spellEntitySchema = z.object({
-  name: z.string().min(1),
-  level: z.number().int().min(0).optional(),
-  school: z.string().optional(),
-  casting_time: z.string().optional(),
-  range: z.string().optional(),
-  components: z.string().optional(),
-  duration: z.string().optional(),
-  concentration: z.boolean().optional(),
-  ritual: z.boolean().optional(),
-  classes: z.array(z.string()).optional(),
-  description: z.string().optional(),
-  at_higher_levels: z.array(z.string()).optional(),
-  damage: z.object({ types: z.array(z.string()) }).optional(),
-  saving_throw: z.object({ ability: z.string() }).optional(),
-  casting_options: z.array(castingOptionSchema).optional()
-}).strict();
-
-export {
-  spellEntitySchema
-};