@archivist-gg/dnd5e 0.1.0

package/dist/entities/base-item-resolver.d.ts

@@ -0,0 +1,21 @@
+import type { EntityRegistry, RegisteredEntity } from "@archivist-gg/core";
+/**
+ * Public: take a `base_item` string (vault-path wikilink, alias-form
+ * wikilink, bare-slug wikilink, or bare slug) and return the matching
+ * `RegisteredEntity` or null.
+ *
+ * - Empty / null / non-string input -> null
+ * - String that doesn't unwrap to a slug -> null
+ * - Slug not present in the registry -> null
+ *
+ * The lookup is type-agnostic: callers that need to narrow to a specific
+ * `entityType` (e.g. "weapon" only) should branch on the result's
+ * `entityType`. A type-narrowed convenience wrapper is also exported for the
+ * common weapon/armor cases.
+ */
+export declare function resolveBaseItem(baseItem: string | null | undefined, registry: EntityRegistry): RegisteredEntity | null;
+/**
+ * Convenience: resolve and require a specific entityType. Returns null if
+ * the entry resolves but is the wrong type.
+ */
+export declare function resolveBaseItemOfType(baseItem: string | null | undefined, entityType: string, registry: EntityRegistry): RegisteredEntity | null;

package/dist/entities/base-item-resolver.js

@@ -0,0 +1,9 @@
+import {
+  resolveBaseItem,
+  resolveBaseItemOfType
+} from "../chunk-DC74TZNA.js";
+import "../chunk-3TRGRSCH.js";
+export {
+  resolveBaseItem,
+  resolveBaseItemOfType
+};

package/dist/entities/slug.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Converts a display name to a URL/file-safe kebab-case slug.
+ * "Ancient Red Dragon" -> "ancient-red-dragon"
+ */
+export declare function slugify(name: string): string;

package/dist/entities/slug.js

@@ -0,0 +1,6 @@
+import {
+  slugify
+} from "../chunk-3TRGRSCH.js";
+export {
+  slugify
+};

package/dist/feat/feat.codec.d.ts

@@ -0,0 +1,9 @@
+import type { DocCodec } from "@archivist-gg/core";
+import type { FeatEntity } from "./feat.types.js";
+/**
+ * Normalizing codec (0c.1a). `parse` delegates to `parseFeat`, which seeds the
+ * `edition: "2014"` default and validates against `featEntitySchema`.
+ * `serialize` stays `yaml.dump` (the edit-save path uses obsidian's separate
+ * serializer; gate (d) verifies `yaml.dump` round-trips through `parseFeat`).
+ */
+export declare const featCodec: DocCodec<FeatEntity>;

package/dist/feat/feat.codec.js

@@ -0,0 +1,10 @@
+import {
+  featCodec
+} from "../chunk-FEOB24KP.js";
+import "../chunk-GIOH5JB5.js";
+import "../chunk-BAXWWGFJ.js";
+import "../chunk-CDW7R2QT.js";
+import "../chunk-NXR3BD2V.js";
+export {
+  featCodec
+};

package/dist/feat/feat.entity-type.d.ts

@@ -0,0 +1,2 @@
+import type { EntityType } from "@archivist-gg/core";
+export declare const featEntityType: EntityType;

package/dist/feat/feat.parser.d.ts

@@ -0,0 +1,3 @@
+import type { FeatEntity } from "./feat.types.js";
+import { ParseResult } from "@archivist-gg/core";
+export declare function parseFeat(source: string): ParseResult<FeatEntity>;

package/dist/feat/feat.parser.js

@@ -0,0 +1,9 @@
+import {
+  parseFeat
+} from "../chunk-GIOH5JB5.js";
+import "../chunk-BAXWWGFJ.js";
+import "../chunk-CDW7R2QT.js";
+import "../chunk-NXR3BD2V.js";
+export {
+  parseFeat
+};

package/dist/feat/feat.schema.d.ts

@@ -0,0 +1,194 @@
+import { z } from "zod";
+export declare const featEntitySchema: z.ZodObject<{
+    slug: z.ZodString;
+    name: z.ZodString;
+    edition: z.ZodEnum<{
+        2014: "2014";
+        2024: "2024";
+    }>;
+    source: z.ZodString;
+    category: z.ZodEnum<{
+        origin: "origin";
+        general: "general";
+        "fighting-style": "fighting-style";
+        "epic-boon": "epic-boon";
+    }>;
+    description: z.ZodString;
+    prerequisites: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"ability">;
+        ability: z.ZodEnum<{
+            str: "str";
+            dex: "dex";
+            con: "con";
+            int: "int";
+            wis: "wis";
+            cha: "cha";
+        }>;
+        min: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"level">;
+        min: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"spellcaster">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"proficiency">;
+        proficiency_type: z.ZodEnum<{
+            weapon: "weapon";
+            skill: "skill";
+            tool: "tool";
+            "saving-throw": "saving-throw";
+            armor: "armor";
+        }>;
+        value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"race">;
+        slug: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"class">;
+        slug: z.ZodString;
+    }, z.core.$strip>], "kind">>;
+    benefits: z.ZodArray<z.ZodString>;
+    effects: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"initiative-bonus">;
+        value: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"immune-condition">;
+        condition: z.ZodString;
+        while: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"resistance">;
+        damage_type: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"hp-per-level-bonus">;
+        value: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"speed-bonus">;
+        mode: z.ZodEnum<{
+            walk: "walk";
+            fly: "fly";
+            swim: "swim";
+            climb: "climb";
+            burrow: "burrow";
+        }>;
+        value: z.ZodNumber;
+        set: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"sense">;
+        type: z.ZodEnum<{
+            darkvision: "darkvision";
+            blindsight: "blindsight";
+            tremorsense: "tremorsense";
+            truesight: "truesight";
+        }>;
+        range: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"apply-condition">;
+        condition: z.ZodString;
+        duration: z.ZodOptional<z.ZodString>;
+        ends_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        save_repeat: z.ZodOptional<z.ZodObject<{
+            ability: z.ZodString;
+            timing: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"damage-bonus">;
+        damage_type: z.ZodString;
+        amount: z.ZodString;
+        applies_to: z.ZodOptional<z.ZodEnum<{
+            weapon: "weapon";
+            spell: "spell";
+            all: "all";
+        }>>;
+        condition: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"proficiency">;
+        proficiency_type: z.ZodEnum<{
+            weapon: "weapon";
+            skill: "skill";
+            tool: "tool";
+            language: "language";
+            "saving-throw": "saving-throw";
+            armor: "armor";
+        }>;
+        value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"ac-bonus">;
+        value: z.ZodNumber;
+        requires_armor: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"unarmored-ac">;
+        abilities: z.ZodArray<z.ZodEnum<{
+            str: "str";
+            dex: "dex";
+            con: "con";
+            int: "int";
+            wis: "wis";
+            cha: "cha";
+        }>>;
+        base: z.ZodOptional<z.ZodNumber>;
+        allow_shield: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"weapon-ability">;
+        ability: z.ZodUnion<readonly [z.ZodEnum<{
+            str: "str";
+            dex: "dex";
+            con: "con";
+            int: "int";
+            wis: "wis";
+            cha: "cha";
+        }>, z.ZodLiteral<"spellcasting">]>;
+        weapons: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"chosen">, z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"roll-modifier">;
+        mode: z.ZodEnum<{
+            advantage: "advantage";
+            disadvantage: "disadvantage";
+        }>;
+        roll: z.ZodEnum<{
+            "saving-throw": "saving-throw";
+            "ability-check": "ability-check";
+            attack: "attack";
+        }>;
+        scope: z.ZodOptional<z.ZodString>;
+        condition: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"extra-attack">;
+        count: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"crit-range">;
+        min_roll: z.ZodNumber;
+        applies_to: z.ZodOptional<z.ZodEnum<{
+            weapon: "weapon";
+            spell: "spell";
+            all: "all";
+        }>>;
+        condition: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"reroll-damage">;
+        max_reroll: z.ZodNumber;
+        applies_to: z.ZodOptional<z.ZodEnum<{
+            weapon: "weapon";
+            spell: "spell";
+            all: "all";
+        }>>;
+        once_per_die: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"attack-rule">;
+        flag: z.ZodEnum<{
+            "no-ranged-in-melee-disadvantage": "no-ranged-in-melee-disadvantage";
+        }>;
+    }, z.core.$strip>], "kind">>;
+    grants_asi: z.ZodNullable<z.ZodObject<{
+        amount: z.ZodNumber;
+        pool: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            str: "str";
+            dex: "dex";
+            con: "con";
+            int: "int";
+            wis: "wis";
+            cha: "cha";
+        }>>>;
+    }, z.core.$strip>>;
+    repeatable: z.ZodBoolean;
+    choices: z.ZodArray<z.ZodType<import("../index.js").Choice, unknown, z.core.$ZodTypeInternals<import("../index.js").Choice, unknown>>>;
+}, z.core.$strip>;

package/dist/feat/feat.schema.js

@@ -0,0 +1,8 @@
+import {
+  featEntitySchema
+} from "../chunk-BAXWWGFJ.js";
+import "../chunk-CDW7R2QT.js";
+import "../chunk-NXR3BD2V.js";
+export {
+  featEntitySchema
+};

package/dist/feat/feat.types.d.ts

@@ -0,0 +1,42 @@
+import type { Choice, Ability, FeatCategory, FeatureEffect } from "@archivist-gg/dnd5e";
+import type { Edition } from "@archivist-gg/dnd5e/types/edition";
+import type { Resource } from "@archivist-gg/dnd5e/types/resource";
+export type FeatPrerequisite = {
+    kind: "ability";
+    ability: Ability;
+    min: number;
+} | {
+    kind: "level";
+    min: number;
+} | {
+    kind: "spellcaster";
+} | {
+    kind: "proficiency";
+    proficiency_type: "armor" | "weapon" | "tool" | "skill" | "saving-throw";
+    value: string;
+} | {
+    kind: "race";
+    slug: string;
+} | {
+    kind: "class";
+    slug: string;
+};
+export interface FeatGrantsAsi {
+    amount: number;
+    pool?: Ability[];
+}
+export interface FeatEntity {
+    slug: string;
+    name: string;
+    edition: Edition;
+    source: string;
+    category: FeatCategory;
+    description: string;
+    prerequisites: FeatPrerequisite[];
+    benefits: string[];
+    effects: FeatureEffect[];
+    grants_asi: FeatGrantsAsi | null;
+    repeatable: boolean;
+    choices: Choice[];
+    resources?: Resource[];
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./types/index.js";
+export * from "./monster/monster.types.js";
+export { parseMonster } from "./monster/monster.parser.js";
+export { enrichMonster } from "./monster/monster.enrichment.js";
+export { monsterCodec } from "./monster/monster.codec.js";
+export type { MonsterRaw } from "./monster/monster.codec.js";
+export { resolveMonster } from "./monster/monster.resolve.js";
+export { monsterEntityType } from "./monster/monster.entity-type.js";
+export { monsterGeneratable } from "./monster/monster.generatable.js";
+export { dnd5ePack } from "./pack.js";
+export * from "./inline-tag-parser.js";
+export * from "./srd-store.js";