optolith-database-schema 0.17.2 → 0.18.2

package/lib/types/equipment/item/_Item.js

@@ -1 +1,144 @@
-export {};
+import { Array, Entity, Enum, EnumCase, Float, IncludeIdentifier, Integer, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
+import { NestedLocaleMap } from "../../Locale.js";
+import { Errata } from "../../source/_Erratum.js";
+import { src } from "../../source/_PublicationRef.js";
+import { SecondaryArmor } from "./Armor.js";
+import { ImprovisedWeapon } from "./Weapon.js";
+export const DefaultItem = (sourceUrl, singularName, pluralName) => Entity(sourceUrl, {
+    name: singularName,
+    namePlural: pluralName ?? `${singularName}s`,
+    type: () => Object({
+        cost: Required({
+            comment: "The cost in silverthalers.",
+            type: IncludeIdentifier(Cost),
+        }),
+        weight: Required({
+            comment: "The weight in kg.",
+            type: IncludeIdentifier(Weight),
+        }),
+        complexity: Optional({
+            comment: "The complexity of crafting the item.",
+            type: IncludeIdentifier(Complexity),
+        }),
+        structure_points: Required({
+            comment: "The structure points of the item. Use an array if the item consists of multiple components that have individual structure points.",
+            type: IncludeIdentifier(StructurePoints),
+        }),
+        combat_use: Optional({
+            comment: "The item can also be used either as an improvised weapon or as an armor, although this is not the primary use case of the item.",
+            type: IncludeIdentifier(CombatUse),
+        }),
+        src,
+        translations: DefaultItemTranslations(singularName),
+    }),
+    displayName: {},
+});
+export const DefaultItemTranslations = (singularName) => NestedLocaleMap(Required, `${singularName}Translation`, Object({
+    name: Required({
+        comment: "The item’s name.",
+        type: String({ minLength: 1 }),
+    }),
+    secondary_name: Optional({
+        comment: "An auxiliary name or label of the item, if available.",
+        type: String({ minLength: 1 }),
+    }),
+    note: Optional({
+        comment: "Note text.",
+        type: String({ minLength: 1, isMarkdown: true }),
+    }),
+    rules: Optional({
+        comment: "Special rules text.",
+        type: String({ minLength: 1, isMarkdown: true }),
+    }),
+    errata: Optional({
+        type: IncludeIdentifier(Errata),
+    }),
+}));
+export const CombatUse = Enum(import.meta.url, {
+    name: "CombatUse",
+    comment: "The item can also be used either as an improvised weapon or as an armor, although this is not the primary use case of the item.",
+    values: () => ({
+        Weapon: EnumCase({ type: IncludeIdentifier(ImprovisedWeapon) }),
+        Armor: EnumCase({ type: IncludeIdentifier(SecondaryArmor) }),
+    }),
+});
+export const StructurePoints = TypeAlias(import.meta.url, {
+    name: "StructurePoints",
+    comment: "The structure points of the item. Use an array if the item consists of multiple components that have individual structure points.",
+    type: () => Array(IncludeIdentifier(StructurePointsComponent), { minItems: 1 }),
+});
+const StructurePointsComponent = TypeAlias(import.meta.url, {
+    name: "StructurePointsComponent",
+    type: () => Object({
+        points: Required({
+            comment: "The structure points.",
+            type: Integer({ minimum: 1 }),
+        }),
+    }),
+});
+export const Cost = Enum(import.meta.url, {
+    name: "Cost",
+    comment: "The cost in silverthalers.",
+    values: () => ({
+        Free: EnumCase({ type: null }),
+        Various: EnumCase({ type: null }),
+        Invaluable: EnumCase({ type: null }),
+        Fixed: EnumCase({ type: IncludeIdentifier(FixedCost) }),
+        Range: EnumCase({ type: IncludeIdentifier(CostRange) }),
+    }),
+});
+const wrap_in_text = Required({
+    comment: "The cost get wrapped by this text using a placeholder in the text.",
+    type: String({ minLength: 1, pattern: /\{0\}/ }),
+});
+export const FixedCost = TypeAlias(import.meta.url, {
+    name: "FixedCost",
+    type: () => Object({
+        value: Required({
+            comment: "The cost in silverthalers.",
+            type: Float({ minimum: { value: 0, isExclusive: true } }),
+        }),
+        translations: NestedLocaleMap(Optional, "FixedCostTranslation", Object({
+            wrap_in_text,
+        })),
+    }),
+});
+const CostRange = TypeAlias(import.meta.url, {
+    name: "CostRange",
+    type: () => Object({
+        from: Required({
+            comment: "The lower bound of the cost in silverthalers.",
+            type: Float({ minimum: { value: 0, isExclusive: true } }),
+        }),
+        to: Required({
+            comment: "The upper bound of the cost in silverthalers.",
+            type: Float({ minimum: { value: 0, isExclusive: true } }),
+        }),
+        translations: NestedLocaleMap(Optional, "CostRangeTranslation", Object({
+            wrap_in_text,
+        })),
+    }),
+});
+export const Weight = TypeAlias(import.meta.url, {
+    name: "Weight",
+    comment: "The weight in kg.",
+    type: () => Float({ minimum: { value: 0, isExclusive: true } }),
+});
+export const Complexity = Enum(import.meta.url, {
+    name: "Complexity",
+    comment: "The complexity of crafting the item.",
+    values: () => ({
+        Primitive: EnumCase({ type: null }),
+        Simple: EnumCase({ type: null }),
+        Complex: EnumCase({ type: IncludeIdentifier(ComplexComplexity) }),
+    }),
+});
+const ComplexComplexity = TypeAlias(import.meta.url, {
+    name: "ComplexComplexity",
+    type: () => Object({
+        ap_value: Required({
+            comment: "The AP value for the trade secret.",
+            type: Integer({ minimum: 1 }),
+        }),
+    }),
+});

package/lib/types/equipment/item/_MeleeWeapon.d.ts

@@ -1,108 +1,40 @@
 /**
  * Auxiliary types for melee weapons.
  */
-import { Dice } from "../../_Dice.js";
-import { ReachIdentifier } from "../../_Identifier.js";
-import { CloseCombatTechniqueReference } from "../../_SimpleReferences.js";
-import { Length, PrimaryAttributeDamageThreshold } from "./_Weapon.js";
-/**
- * The AT modifier.
- * @integer
- */
-export type AttackModifier = number;
-/**
- * The PA modifier.
- * @integer
- */
-export type ParryModifier = number;
-/**
- * The reach of the weapon.
- */
-export type Reach = ReachIdentifier;
-/**
- * The damage of a weapon consists of a random part using dice and an optional
- * flat part.
- */
-export type MeleeDamage = {
-    /**
-     * How many dice of which type are rolled to get the damage.
-     */
-    dice: Dice;
-    /**
-     * Flat damage, if any. It gets added to the result of the dice rolls.
-     * @integer
-     * @default 0
-     */
-    flat?: number;
-};
-/**
- * The shield size and potential size-depending values.
- */
-export type ShieldSize = {
-    tag: "Small";
-    small: {};
-} | {
-    tag: "Medium";
-    medium: {};
-} | {
-    tag: "Large";
-    large?: LargeShieldSize;
-};
-export type LargeShieldSize = {
-    /**
-     * The attack penalty from the shield.
-     * @integer
-     * @default 1
-     */
-    attack_penalty: number;
-};
-/**
- * @title Melee Weapon
- */
-export type MeleeWeapon = {
-    /**
-     * The combat techniques and dependent values.
-     */
-    combat_technique: CloseCombatTechniqueReference;
-    /**
-     * The damage of a weapon consists of a random part using dice and an optional
-     * flat part.
-     */
-    damage: MeleeDamage;
-    /**
-     * The primary attribute damage and threshold value.
-     */
-    damage_threshold?: PrimaryAttributeDamageThreshold;
-    /**
-     * The AT modifier.
-     */
-    at: AttackModifier;
-    /**
-     * The PA modifier.
-     */
-    pa?: ParryModifier;
-    /**
-     * The reach of the weapon.
-     */
-    reach?: Reach;
-    /**
-     * The length of the weapon in cm/halffingers.
-     */
-    length?: Length;
-    /**
-     * The shield size and potential size-depending values.
-     */
-    size?: ShieldSize;
-    /**
-     * Is the weapon a parrying weapon?
-     */
-    is_parrying_weapon: boolean;
-    /**
-     * Is the weapon a two-handed weapon?
-     */
-    is_two_handed_weapon: boolean;
-    /**
-     * Is the weapon an improvised weapon?
-     */
-    is_improvised_weapon: boolean;
-};
+import { Boolean, Enum, EnumCase, IncludeIdentifier, Integer, Object, TypeAlias } from "tsondb/schema/def";
+export declare const AttackModifier: TypeAlias<"AttackModifier", Integer, []>;
+export declare const ParryModifier: TypeAlias<"ParryModifier", Integer, []>;
+export declare const MeleeWeapon: TypeAlias<"MeleeWeapon", Object<{
+    damage: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"MeleeDamage", Object<{
+        dice: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Dice", Object<{
+            number: import("tsondb/schema/def").MemberDecl<Integer, true>;
+            sides: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"DieType", Integer, []>>, true>;
+        }>, []>>, true>;
+        flat: import("tsondb/schema/def").MemberDecl<Integer, false>;
+    }>, []>>, true>;
+    damage_threshold: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"PrimaryAttributeDamageThreshold", {
+        Default: EnumCase<IncludeIdentifier<[], TypeAlias<"DefaultPrimaryAttributeDamageThreshold", Object<{
+            threshold: import("tsondb/schema/def").MemberDecl<Integer, true>;
+        }>, []>>>;
+        List: EnumCase<IncludeIdentifier<[], TypeAlias<"PrimaryAttributeDamageThresholdList", Object<{
+            list: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"SinglePrimaryAttributeDamageThreshold", Object<{
+                attribute: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+                threshold: import("tsondb/schema/def").MemberDecl<Integer, true>;
+            }>, []>>>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+    attackModifier: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"AttackModifier", Integer, []>>, false>;
+    parryModifier: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"ParryModifier", Integer, []>>, false>;
+    reach: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, false>;
+    length: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Length", Integer, []>>, false>;
+    size: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"ShieldSize", {
+        Small: EnumCase<null>;
+        Medium: EnumCase<null>;
+        Large: EnumCase<IncludeIdentifier<[], TypeAlias<"LargeShieldSize", Object<{
+            attack_penalty: import("tsondb/schema/def").MemberDecl<Integer, false>;
+        }>, []>>>;
+    }, []>>, false>;
+    is_parrying_weapon: import("tsondb/schema/def").MemberDecl<Boolean, true>;
+    is_two_handed_weapon: import("tsondb/schema/def").MemberDecl<Boolean, true>;
+    is_improvised_weapon: import("tsondb/schema/def").MemberDecl<Boolean, true>;
+}>, []>;

package/lib/types/equipment/item/_MeleeWeapon.js

@@ -1,4 +1,95 @@
 /**
  * Auxiliary types for melee weapons.
  */
-export {};
+import { Boolean, Enum, EnumCase, IncludeIdentifier, Integer, Object, Optional, Required, TypeAlias, } from "tsondb/schema/def";
+import { Dice } from "../../_Dice.js";
+import { ReachIdentifier } from "../../_Identifier.js";
+import { Length, PrimaryAttributeDamageThreshold } from "./_Weapon.js";
+export const AttackModifier = TypeAlias(import.meta.url, {
+    name: "AttackModifier",
+    comment: "The AT modifier.",
+    type: () => Integer(),
+});
+export const ParryModifier = TypeAlias(import.meta.url, {
+    name: "ParryModifier",
+    comment: "The PA modifier.",
+    type: () => Integer(),
+});
+const MeleeDamage = TypeAlias(import.meta.url, {
+    name: "MeleeDamage",
+    comment: "The damage of a weapon consists of a random part using dice and an optional flat part.",
+    type: () => Object({
+        dice: Required({
+            comment: "How many dice of which type are rolled to get the damage.",
+            type: IncludeIdentifier(Dice),
+        }),
+        flat: Optional({
+            comment: "Flat damage, if any. It gets added to the result of the dice rolls.",
+            type: Integer(),
+        }),
+    }),
+});
+const ShieldSize = Enum(import.meta.url, {
+    name: "ShieldSize",
+    comment: "The shield size and potential size-depending values.",
+    values: () => ({
+        Small: EnumCase({ type: null }),
+        Medium: EnumCase({ type: null }),
+        Large: EnumCase({ type: IncludeIdentifier(LargeShieldSize) }),
+    }),
+});
+const LargeShieldSize = TypeAlias(import.meta.url, {
+    name: "LargeShieldSize",
+    comment: "The damage of a weapon consists of a random part using dice and an optional flat part.",
+    type: () => Object({
+        attack_penalty: Optional({
+            comment: "The attack penalty from the shield, if any.",
+            type: Integer(),
+        }),
+    }),
+});
+export const MeleeWeapon = TypeAlias(import.meta.url, {
+    name: "MeleeWeapon",
+    type: () => Object({
+        damage: Required({
+            comment: "The damage of a weapon consists of a random part using dice and an optional flat part.",
+            type: IncludeIdentifier(MeleeDamage),
+        }),
+        damage_threshold: Optional({
+            comment: "The primary attribute damage and threshold value.",
+            type: IncludeIdentifier(PrimaryAttributeDamageThreshold),
+        }),
+        attackModifier: Optional({
+            comment: "The AT modifier.",
+            type: IncludeIdentifier(AttackModifier),
+        }),
+        parryModifier: Optional({
+            comment: "The PA modifier.",
+            type: IncludeIdentifier(ParryModifier),
+        }),
+        reach: Optional({
+            comment: "The reach of the weapon.",
+            type: ReachIdentifier(),
+        }),
+        length: Optional({
+            comment: "The length of the weapon in cm/halffingers.",
+            type: IncludeIdentifier(Length),
+        }),
+        size: Optional({
+            comment: "The shield size and potential size-depending values.",
+            type: IncludeIdentifier(ShieldSize),
+        }),
+        is_parrying_weapon: Required({
+            comment: "Is the weapon a parrying weapon?",
+            type: Boolean(),
+        }),
+        is_two_handed_weapon: Required({
+            comment: "Is the weapon a two-handed weapon?",
+            type: Boolean(),
+        }),
+        is_improvised_weapon: Required({
+            comment: "Is the weapon an improvised weapon?",
+            type: Boolean(),
+        }),
+    }),
+});

package/lib/types/equipment/item/_RangedWeapon.d.ts

@@ -1,109 +1,28 @@
 /**
  * Auxiliary types for ranged weapons.
  */
-import { Dice } from "../../_Dice.js";
-import { AmmunitionIdentifier } from "../../_Identifier.js";
-import { RangedCombatTechniqueReference } from "../../_SimpleReferences.js";
-import { Length } from "./_Weapon.js";
-/**
- * The damage of a ranged weapon. It consists of a random part using dice and an
- * optional flat part ny default. Some ranged weapons may work different so that
- * damage is either not applicable at all or it is outlined as *Special* and
- * further defined in a description.
- */
-export type RangedDamage = {
-    tag: "Default";
-    default: DefaultRangedDamage;
-} | {
-    tag: "NotApplicable";
-    not_applicable: {};
-} | {
-    tag: "Special";
-    special: {};
-};
-/**
- * The damage of a weapon consists of a random part using dice and an optional
- * flat part.
- */
-export type DefaultRangedDamage = {
-    /**
-     * How many dice of which type are rolled to get the damage.
-     */
-    dice: Dice;
-    /**
-     * Flat damage, if any. It gets added to the result of the dice rolls.
-     * @integer
-     * @default 0
-     */
-    flat?: number;
-};
-/**
- * @title Ranged Weapon
- */
-export type RangedWeapon = {
-    /**
-     * The combat techniques and dependent values.
-     */
-    combat_technique: RangedCombatTechniqueReference;
-    /**
-     * The damage of a weapon consists of a random part using dice and an optional
-     * flat part.
-     */
-    damage: RangedDamage;
-    /**
-     * One or multiple reload times.
-     * @minItems 1
-     * @uniqueItems
-     */
-    reload_time: ReloadTime[];
-    /**
-     * The range brackets for the weapon: close, medium, far. Distances in m.
-     */
-    range: Range;
-    /**
-     * The needed ammunition.
-     */
-    ammunition?: AmmunitionReference;
-    /**
-     * The length of the weapon in cm/halffingers.
-     */
-    length: Length;
-    /**
-     * Is the weapon an improvised weapon?
-     */
-    is_improvised_weapon: boolean;
-};
-export type AmmunitionReference = {
-    /**
-     * The item's identifier.
-     */
-    id: AmmunitionIdentifier;
-};
-export type Range = {
-    /**
-     * The close range bracket for the weapon. Distance in m.
-     * @integer
-     * @minimum 1
-     */
-    close: number;
-    /**
-     * The medium range bracket for the weapon. Distance in m.
-     * @integer
-     * @minimum 1
-     */
-    medium: number;
-    /**
-     * The far range bracket for the weapon. Distance in m.
-     * @integer
-     * @minimum 1
-     */
-    far: number;
-};
-export type ReloadTime = {
-    /**
-     * A reload time value in actions.
-     * @integer
-     * @minimum 1
-     */
-    value: number;
-};
+import { Array, Boolean, Enum, EnumCase, IncludeIdentifier, Integer, Object, TypeAlias } from "tsondb/schema/def";
+export declare const RangedWeapon: TypeAlias<"RangedWeapon", Object<{
+    damage: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"RangedDamage", {
+        Default: EnumCase<IncludeIdentifier<[], TypeAlias<"DefaultRangedDamage", Object<{
+            dice: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Dice", Object<{
+                number: import("tsondb/schema/def").MemberDecl<Integer, true>;
+                sides: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"DieType", Integer, []>>, true>;
+            }>, []>>, true>;
+            flat: import("tsondb/schema/def").MemberDecl<Integer, false>;
+        }>, []>>>;
+        NotApplicable: EnumCase<null>;
+        Special: EnumCase<null>;
+    }, []>>, true>;
+    reload_time: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"ReloadTime", Object<{
+        value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+    }>, []>>>, true>;
+    range: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RangeBrackets", Object<{
+        close: import("tsondb/schema/def").MemberDecl<Integer, true>;
+        medium: import("tsondb/schema/def").MemberDecl<Integer, true>;
+        far: import("tsondb/schema/def").MemberDecl<Integer, true>;
+    }>, []>>, true>;
+    ammunition: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, false>;
+    length: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Length", Integer, []>>, false>;
+    is_improvised_weapon: import("tsondb/schema/def").MemberDecl<Boolean, true>;
+}>, []>;

package/lib/types/equipment/item/_RangedWeapon.js

@@ -1,4 +1,88 @@
 /**
  * Auxiliary types for ranged weapons.
  */
-export {};
+import { Array, Boolean, Enum, EnumCase, IncludeIdentifier, Integer, Object, Optional, Required, TypeAlias, } from "tsondb/schema/def";
+import { Dice } from "../../_Dice.js";
+import { AmmunitionIdentifier } from "../../_Identifier.js";
+import { Length } from "./_Weapon.js";
+const RangedDamage = Enum(import.meta.url, {
+    name: "RangedDamage",
+    comment: "The damage of a ranged weapon. It consists of a random part using dice and an optional flat part ny default. Some ranged weapons may work different so that damage is either not applicable at all or it is outlined as *Special* and further defined in a description.",
+    values: () => ({
+        Default: EnumCase({ type: IncludeIdentifier(DefaultRangedDamage) }),
+        NotApplicable: EnumCase({ type: null }),
+        Special: EnumCase({ type: null }),
+    }),
+});
+const DefaultRangedDamage = TypeAlias(import.meta.url, {
+    name: "DefaultRangedDamage",
+    comment: "The damage of a weapon consists of a random part using dice and an optional flat part.",
+    type: () => Object({
+        dice: Required({
+            comment: "How many dice of which type are rolled to get the damage.",
+            type: IncludeIdentifier(Dice),
+        }),
+        flat: Optional({
+            comment: "Flat damage, if any. It gets added to the result of the dice rolls.",
+            type: Integer(),
+        }),
+    }),
+});
+export const RangedWeapon = TypeAlias(import.meta.url, {
+    name: "RangedWeapon",
+    type: () => Object({
+        damage: Required({
+            comment: "The damage of a weapon consists of a random part using dice and an optional flat part.",
+            type: IncludeIdentifier(RangedDamage),
+        }),
+        reload_time: Required({
+            comment: "One or multiple reload times.",
+            type: Array(IncludeIdentifier(ReloadTime), {
+                minItems: 1,
+                uniqueItems: true,
+            }),
+        }),
+        range: Required({
+            comment: "The range brackets for the weapon: close, medium, far. Distances in m.",
+            type: IncludeIdentifier(RangeBrackets),
+        }),
+        ammunition: Optional({
+            comment: "The needed ammunition.",
+            type: AmmunitionIdentifier(),
+        }),
+        length: Optional({
+            comment: "The length of the weapon in cm/halffingers.",
+            type: IncludeIdentifier(Length),
+        }),
+        is_improvised_weapon: Required({
+            comment: "Is the weapon an improvised weapon?",
+            type: Boolean(),
+        }),
+    }),
+});
+const RangeBrackets = TypeAlias(import.meta.url, {
+    name: "RangeBrackets",
+    type: () => Object({
+        close: Required({
+            comment: "The close range bracket for the weapon. Distance in m.",
+            type: Integer({ minimum: 1 }),
+        }),
+        medium: Required({
+            comment: "The medium range bracket for the weapon. Distance in m.",
+            type: Integer({ minimum: 1 }),
+        }),
+        far: Required({
+            comment: "The far range bracket for the weapon. Distance in m.",
+            type: Integer({ minimum: 1 }),
+        }),
+    }),
+});
+const ReloadTime = TypeAlias(import.meta.url, {
+    name: "ReloadTime",
+    type: () => Object({
+        value: Required({
+            comment: "A reload time value in actions.",
+            type: Integer({ minimum: 1 }),
+        }),
+    }),
+});