@datasworn-community/build-tools 0.2.0

package/schema-source/schema/generic/SourcedNode.ts

@@ -0,0 +1,51 @@
+import {
+	type ObjectOptions,
+	type Static,
+	type TObject,
+	Type
+} from '@sinclair/typebox'
+import type { TAnyId } from '../common/Id.js'
+import { SourceInfo, Suggestions } from '../common/Metadata.js'
+import { Label } from '../common/Text.js'
+import { Tags } from '../rules/TagRule.js'
+import { FlatIntersect, type TAssign } from '../utils/FlatIntersect.js'
+import { IdNode, type TIdNode } from './IdNode.js'
+
+export const SourcedNodeBase = Type.Object({
+	name: Type.Ref(Label, {
+		description: 'The primary name/label for this node.'
+	}),
+	canonical_name: Type.Optional(
+		Type.Ref(Label, {
+			description:
+				"The name of this node as it appears on the page in the book, if it's different from `name`."
+		})
+	),
+	_source: Type.Ref(SourceInfo, {
+		description:
+			'Attribution for the original source (such as a book or website) of this node, including the author and licensing information.'
+	}),
+	suggestions: Type.Optional(Type.Ref(Suggestions)),
+	tags: Type.Optional(Type.Ref(Tags))
+})
+
+/** Interface shared by objects with source attribute. */
+
+export function SourcedNode<TBase extends TObject>(
+	base: TBase,
+	_id: TAnyId,
+	options: ObjectOptions = {}
+) {
+	const enhancedBase = FlatIntersect([SourcedNodeBase, base])
+
+	return IdNode(enhancedBase, _id, options)
+}
+
+export type TSourcedNode<TBase extends TObject> = TIdNode<
+	TAssign<typeof SourcedNodeBase, TBase>
+> & { static: SourcedNode<Static<TBase>> }
+
+export type SourcedNode<TBase extends object = object> = Static<
+	typeof SourcedNodeBase
+> &
+	IdNode<TBase>

package/schema-source/schema/index.ts

@@ -0,0 +1,23 @@
+/**
+ * TypeBox JSON schema, with annotations so they can be converted to JSON TypeDef.
+ */
+
+// depends on moves, oracles
+export * from './Assets.js'
+// no/few dependencies
+export * from './Atlas.js'
+export * from './common/index.js'
+export * from './Defs.js'
+// delve stuff
+export * from './DelveSites.js'
+// depends on oracles
+export * from './Entities.js'
+export * from './Generic.js'
+export * from './Moves.js'
+export * from './Npcs.js'
+export * from './Oracles.js'
+export * from './Rarities.js'
+export * from './Root.js'
+export * from './Rules.js'
+export * from './RulesPackages.js'
+export * from './Truths.js'

package/schema-source/schema/moves/ActionRoll.ts

@@ -0,0 +1,152 @@
+import { type Static, Type } from '@sinclair/typebox'
+import { RollableValue } from '../common/RollableValues.js'
+import {
+	ActionRollMethod,
+	MoveOutcomes,
+	type MoveOutcomes as MoveOutcomesType
+} from './common.js'
+import {
+	Trigger,
+	TriggerCondition,
+	TriggerConditionEnhancement,
+	TriggerEnhancement
+} from './Trigger.js'
+import { Move, MoveEnhancement } from './utils.js'
+
+export const TriggerActionRollCondition = TriggerCondition(
+	Type.Ref(ActionRollMethod),
+	Type.Array(Type.Ref(RollableValue)),
+	{ $id: 'TriggerActionRollCondition', title: 'TriggerActionRollCondition' }
+)
+export type TriggerActionRollCondition = Static<
+	typeof TriggerActionRollCondition
+>
+
+export const TriggerActionRoll = Trigger(
+	Type.Array(Type.Ref(TriggerActionRollCondition)),
+	{
+		$id: 'TriggerActionRoll',
+		title: 'TriggerActionRoll',
+		description:
+			'Describes trigger conditions for a move that makes an action roll.'
+	}
+)
+export type TriggerActionRoll = Static<typeof TriggerActionRoll>
+
+export const MoveActionRoll = Move(
+	'action_roll',
+	Type.Ref(TriggerActionRoll),
+	Type.Ref(MoveOutcomes),
+	{
+		title: 'Move (action roll)',
+		description: 'A move that makes an action roll.',
+		$id: 'MoveActionRoll'
+	}
+)
+
+export type MoveActionRoll = Move<
+	'action_roll',
+	TriggerActionRoll,
+	MoveOutcomesType
+>
+
+export const TriggerActionRollConditionEnhancement =
+	TriggerConditionEnhancement(TriggerActionRollCondition, {
+		$id: 'TriggerActionRollConditionEnhancement',
+		title: 'TriggerActionRollConditionEnhancement'
+	})
+
+export type TriggerActionRollConditionEnhancement = Static<
+	typeof TriggerActionRollConditionEnhancement
+>
+
+export const TriggerActionRollEnhancement = TriggerEnhancement(
+	Type.Array(Type.Ref(TriggerActionRollConditionEnhancement)),
+	{
+		$id: 'TriggerActionRollEnhancement',
+		title: 'TriggerActionRollEnhancement'
+	}
+)
+export type TriggerActionRollEnhancement = Static<
+	typeof TriggerActionRollEnhancement
+>
+
+// TRIGGER: NO ROLL
+
+export const TriggerNoRollCondition = TriggerCondition(
+	Type.Null({ default: null }),
+	Type.Null({ default: null }),
+	{ $id: 'TriggerNoRollCondition', title: 'TriggerNoRollCondition' }
+)
+
+export type TriggerNoRollCondition = Static<typeof TriggerNoRollCondition>
+
+export const TriggerNoRoll = Trigger(
+	Type.Array(Type.Ref(TriggerNoRollCondition), {
+		default: []
+	}),
+	{
+		$id: 'TriggerNoRoll',
+		title: 'TriggerNoRoll',
+		description: 'Describes trigger conditions for a move that makes no rolls.'
+	}
+)
+
+export type TriggerNoRoll = Static<typeof TriggerNoRoll>
+
+export const MoveNoRoll = Move(
+	'no_roll',
+	Type.Ref(TriggerNoRoll),
+	Type.Null({ default: null }),
+	{
+		$id: 'MoveNoRoll',
+		description: 'A move that makes no progress rolls or action rolls.'
+	}
+)
+
+export type MoveNoRoll = Static<typeof MoveNoRoll>
+
+// No-roll triggers need a separate enhancement condition type to exclude _id
+export const TriggerNoRollConditionEnhancement = TriggerConditionEnhancement(
+	TriggerNoRollCondition,
+	{
+		$id: 'TriggerNoRollConditionEnhancement',
+		title: 'TriggerNoRollConditionEnhancement'
+	}
+)
+export type TriggerNoRollConditionEnhancement = Static<
+	typeof TriggerNoRollConditionEnhancement
+>
+
+export const TriggerNoRollEnhancement = TriggerEnhancement(
+	Type.Array(Type.Ref(TriggerNoRollConditionEnhancement)),
+	{
+		$id: 'TriggerNoRollEnhancement',
+		title: 'TriggerNoRollEnhancement'
+	}
+)
+export type TriggerNoRollEnhancement = Static<typeof TriggerNoRollEnhancement>
+
+export const MoveNoRollEnhancement = MoveEnhancement(
+	'no_roll',
+	Type.Ref(TriggerNoRollEnhancement),
+	{
+		$id: 'MoveNoRollEnhancement'
+	}
+)
+export type MoveNoRollEnhancement = MoveEnhancement<
+	'no_roll',
+	TriggerNoRollEnhancement
+>
+
+export const MoveActionRollEnhancement = MoveEnhancement(
+	'action_roll',
+	Type.Ref(TriggerActionRollEnhancement),
+	{
+		$id: 'MoveActionRollEnhancement'
+	}
+)
+export type MoveActionRollEnhancement = MoveEnhancement<
+	'action_roll',
+	TriggerActionRollEnhancement
+>

package/schema-source/schema/moves/EmbeddedMove.ts

@@ -0,0 +1,24 @@
+import type { Static } from '@sinclair/typebox'
+import { mapValues } from 'lodash-es'
+import { Mapping } from '../Symbols.js'
+import { DiscriminatedUnion } from '../Utils.js'
+import { EmbeddedPrimaryNode } from '../utils/EmbeddedNode.js'
+import { pascalCase } from '../utils/string.js'
+import { Move } from './Move.js'
+
+const moveMapping = mapValues(Move[Mapping], (schema, k) =>
+	EmbeddedPrimaryNode(schema, [], { $id: `Embedded${pascalCase(k)}Move` })
+)
+
+export const {
+	action_roll: EmbeddedActionRollMove,
+	no_roll: EmbeddedNoRollMove,
+	progress_roll: EmbeddedProgressRollMove,
+	special_track: EmbeddedSpecialTrackMove
+} = moveMapping
+
+export const EmbeddedMove = DiscriminatedUnion(moveMapping, 'roll_type', {
+	$id: 'EmbeddedMove'
+})
+
+export type EmbeddedMove = Static<typeof EmbeddedMove>

package/schema-source/schema/moves/Move.ts

@@ -0,0 +1,26 @@
+import * as Utils from '../Utils.js'
+import { MoveActionRoll, MoveNoRoll } from './ActionRoll.js'
+import { MoveProgressRoll, MoveSpecialTrack } from './ProgressRoll.js'
+import { moveDiscriminator } from './utils.js'
+
+// discriminated union of all moves
+
+export const Move = Utils.DiscriminatedUnion(
+	{
+		action_roll: MoveActionRoll,
+		no_roll: MoveNoRoll,
+		progress_roll: MoveProgressRoll,
+		special_track: MoveSpecialTrack
+	},
+	moveDiscriminator,
+	{
+		$id: 'Move',
+		title: 'Move'
+	}
+)
+
+export type Move =
+	| MoveActionRoll
+	| MoveNoRoll
+	| MoveProgressRoll
+	| MoveSpecialTrack

package/schema-source/schema/moves/MoveCategory.ts

@@ -0,0 +1,6 @@
+import { type Static, Type } from '@sinclair/typebox'
+import { CollectionNode } from '../generic/CollectionNode.js'
+
+export const MoveCategory = CollectionNode(Type.Object({}), 'move_category')
+export type MoveCategory = Static<typeof MoveCategory>
+export type TMoveCategory = typeof MoveCategory

package/schema-source/schema/moves/MoveEnhancement.ts

@@ -0,0 +1,29 @@
+import * as Utils from '../Utils.js'
+import {
+	MoveActionRollEnhancement,
+	MoveNoRollEnhancement
+} from './ActionRoll.js'
+import {
+	MoveProgressRollEnhancement,
+	MoveSpecialTrackEnhancement
+} from './ProgressRoll.js'
+import { moveDiscriminator } from './utils.js'
+
+export const MoveEnhancement = Utils.DiscriminatedUnion(
+	{
+		action_roll: MoveActionRollEnhancement,
+		no_roll: MoveNoRollEnhancement,
+		progress_roll: MoveProgressRollEnhancement,
+		special_track: MoveSpecialTrackEnhancement
+	},
+	moveDiscriminator,
+	{
+		$id: 'MoveEnhancement'
+	}
+)
+export type TMoveEnhancement = typeof MoveEnhancement
+export type MoveEnhancement =
+	| MoveNoRollEnhancement
+	| MoveActionRollEnhancement
+	| MoveProgressRollEnhancement
+	| MoveSpecialTrackEnhancement

package/schema-source/schema/moves/ProgressRoll.ts

@@ -0,0 +1,184 @@
+import { type Static, Type } from '@sinclair/typebox'
+import * as Progress from '../common/Progress.js'
+import { Assign } from '../utils/FlatIntersect.js'
+import {
+	Trigger,
+	TriggerCondition,
+	TriggerConditionEnhancement,
+	TriggerEnhancement
+} from './Trigger.js'
+import { Move, MoveEnhancement } from './utils.js'
+
+export const ProgressRollOption = Type.Object(
+	{
+		using: Type.Literal('progress_track')
+	},
+	{ $id: 'ProgressRollOption' }
+)
+export type ProgressRollOption = Static<typeof ProgressRollOption>
+
+export const TriggerProgressRollCondition = TriggerCondition(
+	Type.Ref('ProgressRollMethod', {
+		default: 'progress_roll'
+	}),
+	Type.Array(Type.Ref('ProgressRollOption')),
+	{
+		$id: 'TriggerProgressRollCondition',
+		title: 'TriggerProgressRollCondition'
+	}
+)
+
+export type TriggerProgressRollCondition = Static<
+	typeof TriggerProgressRollCondition
+>
+
+export const TriggerProgressRoll = Trigger(
+	Type.Array(Type.Ref(TriggerProgressRollCondition)),
+	{
+		$id: 'TriggerProgressRoll',
+		title: 'TriggerProgressRoll'
+	}
+)
+
+export type TriggerProgressRoll = Static<typeof TriggerProgressRoll>
+
+export const MoveProgressRoll = Assign(
+	Move(
+		'progress_roll',
+		Type.Ref('TriggerProgressRoll'),
+		Type.Ref('MoveOutcomes'),
+		{ $id: 'MoveProgressRollBase' }
+	),
+	Type.Object({
+		// is_progress_move: Type.Literal(true, { default: true }),
+		tracks: Type.Ref(Progress.ProgressTrackTypeInfo, {
+			description:
+				'Describes the common features of progress tracks associated with this move.'
+		})
+	}),
+	{
+		title: 'Progress Move',
+		description:
+			'A progress move that rolls on a standard progress track type (whose features are defined by this move object). For progress rolls that use special tracks, see MoveSpecialTrack.',
+		$id: 'MoveProgressRoll'
+	}
+)
+
+export type MoveProgressRoll = Static<typeof MoveProgressRoll>
+
+// AUGMENTS
+
+export const TriggerProgressRollConditionEnhancement =
+	TriggerConditionEnhancement(TriggerProgressRollCondition, {
+		$id: 'TriggerProgressRollConditionEnhancement',
+		title: 'TriggerProgressRollConditionEnhancement'
+	})
+export type TriggerProgressRollConditionEnhancement = Static<
+	typeof TriggerProgressRollConditionEnhancement
+>
+
+export const TriggerProgressRollEnhancement = TriggerEnhancement(
+	Type.Array(Type.Ref('TriggerProgressRollConditionEnhancement')),
+	{
+		$id: 'TriggerProgressRollEnhancement',
+		title: 'TriggerProgressRollEnhancement'
+	}
+)
+export type TriggerProgressRollEnhancement = Static<
+	typeof TriggerProgressRollEnhancement
+>
+
+export const MoveProgressRollEnhancement = MoveEnhancement(
+	'progress_roll',
+	Type.Ref(TriggerProgressRollEnhancement),
+	{
+		$id: 'MoveProgressRollEnhancement'
+	}
+)
+export type MoveProgressRollEnhancement = Static<
+	typeof MoveProgressRollEnhancement
+>
+
+// SPECIAL TRACK
+
+export const TriggerSpecialTrackConditionOption = Type.Object(
+	{
+		using: Type.Ref('SpecialTrackType')
+	},
+	{
+		$id: 'TriggerSpecialTrackConditionOption',
+		title: 'TriggerSpecialTrackConditionOption'
+	}
+)
+export type TriggerSpecialTrackConditionOption = Static<
+	typeof TriggerSpecialTrackConditionOption
+>
+
+export const TriggerSpecialTrackCondition = TriggerCondition(
+	Type.Ref('SpecialTrackRollMethod'),
+	Type.Array(Type.Ref('TriggerSpecialTrackConditionOption')),
+	{
+		$id: 'TriggerSpecialTrackCondition',
+		title: 'TriggerSpecialTrackCondition'
+	}
+)
+export type TriggerSpecialTrackCondition = Static<
+	typeof TriggerSpecialTrackCondition
+>
+
+export const TriggerSpecialTrack = Trigger(
+	Type.Array(Type.Ref(TriggerSpecialTrackCondition)),
+	{
+		$id: 'TriggerSpecialTrack',
+		title: 'TriggerSpecialTrack'
+	}
+)
+
+export type TriggerSpecialTrack = Static<typeof TriggerSpecialTrack>
+
+export const MoveSpecialTrack = Move(
+	'special_track',
+	// is_progress_move: Type.Literal(true, { default: true }),
+	Type.Ref('TriggerSpecialTrack'),
+	Type.Ref('MoveOutcomes'),
+
+	{
+		title: 'Progress Move (special track roll)',
+		$id: 'MoveSpecialTrack',
+		description:
+			'A progress move that rolls on a special track, such as Legacies (Starforged) or Bonds (classic Ironsworn). For progress moves that use standard progress tracks, see MoveProgressRoll instead.'
+	}
+)
+
+export type MoveSpecialTrack = Static<typeof MoveSpecialTrack>
+
+export const TriggerSpecialTrackConditionEnhancement =
+	TriggerConditionEnhancement(TriggerSpecialTrackCondition, {
+		$id: 'TriggerSpecialTrackConditionEnhancement',
+		title: 'TriggerSpecialTrackConditionEnhancement',
+		description:
+			'A progress move that rolls on one or more special tracks, like Bonds (classic Ironsworn), Failure (Delve), or Legacy (Starforged).'
+	})
+export type TriggerSpecialTrackConditionEnhancement = Static<
+	typeof TriggerSpecialTrackConditionEnhancement
+>
+
+export const TriggerSpecialTrackEnhancement = TriggerEnhancement(
+	Type.Array(Type.Ref('TriggerSpecialTrackConditionEnhancement')),
+	{
+		$id: 'TriggerSpecialTrackEnhancement',
+		title: 'TriggerSpecialTrackEnhancement'
+	}
+)
+export type TriggerSpecialTrackEnhancement = TriggerEnhancement<any>
+
+export const MoveSpecialTrackEnhancement = MoveEnhancement(
+	'special_track',
+	Type.Ref(TriggerSpecialTrackEnhancement),
+	{
+		$id: 'MoveSpecialTrackEnhancement'
+	}
+)
+export type MoveSpecialTrackEnhancement = Static<
+	typeof MoveSpecialTrackEnhancement
+>

package/schema-source/schema/moves/Trigger.ts

@@ -0,0 +1,193 @@
+import {
+	type ObjectOptions,
+	type Static,
+	type TArray,
+	type TNull,
+	type TObject,
+	type TSchema,
+	Type,
+	TypeGuard
+} from '@sinclair/typebox'
+import * as Text from '../common/Text.js'
+import * as Utils from '../Utils.js'
+import { Assign } from '../utils/FlatIntersect.js'
+import {
+	setDescriptions,
+	type TFuzzyNull,
+	type TFuzzyObject,
+	type TFuzzyRef
+} from '../utils/typebox.js'
+
+export const TriggerBy = Type.Object(
+	{
+		player: Type.Boolean({
+			default: true,
+			description: 'Can this trigger be activated by the player who owns this?'
+		}),
+		ally: Type.Boolean({
+			default: false,
+			description:
+				"Can this trigger be activated by one of the player's allies?"
+		})
+	},
+	{
+		$id: 'TriggerBy',
+		title: 'TriggerBy',
+		description:
+			"Information on who can activate this trigger condition. Usually this is just the player, but some asset abilities can trigger from an ally's move."
+	}
+)
+export type TriggerBy = Static<typeof TriggerBy>
+
+const TriggerConditionBase = Type.Object({
+	_id: Utils.Computed(Type.Ref('AnyMoveConditionId')),
+	text: Type.Optional(
+		Type.Ref(Text.MarkdownString, {
+			description:
+				'A markdown string of any trigger text specific to this trigger condition.'
+		})
+	),
+	by: Type.Optional(Type.Ref(TriggerBy))
+})
+
+export function TriggerCondition<
+	Method extends TFuzzyNull<Utils.TUnionEnum<string[]>>,
+	RollOptions extends TFuzzyNull<TArray<TFuzzyObject<{ using: TSchema }>>>
+>(method: Method, rollOptions: RollOptions, options: ObjectOptions = {}) {
+	const roll_options: RollOptions = {
+		description:
+			'The options available when rolling with this trigger condition.',
+		...rollOptions
+	}
+	return Assign(
+		TriggerConditionBase,
+		Type.Object({
+			method,
+			roll_options
+		}),
+		options
+	)
+}
+export type TTriggerCondition<
+	Method extends TFuzzyNull<Utils.TUnionEnum<string[]>> = TFuzzyNull<
+		Utils.TUnionEnum<string[]>
+	>,
+	RollOptions extends TFuzzyNull<
+		TArray<TFuzzyObject<{ using: TSchema }>>
+	> = TFuzzyNull<TArray<TFuzzyObject<{ using: TSchema }>>>
+> = ReturnType<typeof TriggerCondition<Method, RollOptions>>
+
+export type TriggerCondition<
+	Method extends string | null = string | null,
+	RollOptions extends Array<{ using: any }> | null = Array<{
+		using: any
+	}> | null
+> = { roll_options: RollOptions; method: Method }
+
+export function TriggerConditionEnhancement<T extends TTriggerCondition>(
+	triggerCondition: T,
+	options: ObjectOptions
+) {
+	const RollOptions = Type.Index(triggerCondition, ['roll_options'])
+	type RollOptions = typeof RollOptions
+
+	const Method = Type.Index(triggerCondition, ['method'])
+
+	type TNullableRollOptions = Omit<
+		T['properties'],
+		'roll_options' | 'method' | '_id'
+	> & {
+		roll_options: RollOptions extends TNull | Utils.TNullable
+			? RollOptions
+			: Utils.TNullable<RollOptions>
+		method: typeof Method extends TNull | Utils.TNullable
+			? typeof Method
+			: Utils.TNullable<typeof Method>
+	}
+
+	const rollOptionsAreNullable =
+		TypeGuard.IsNull(Method) ?? Utils.TNullable(Method)
+
+	const roll_options = rollOptionsAreNullable
+		? RollOptions
+		: Utils.Nullable(RollOptions, { default: null })
+
+	const methodIsNullable = TypeGuard.IsNull(Method) ?? Utils.TNullable(Method)
+
+	const method = methodIsNullable
+		? Method
+		: Utils.Nullable(Method, {
+				description:
+					'A `null` value means this condition provides no roll mechanic of its own; it must be used with another trigger condition that provides a non-null `method`.',
+				default: null
+			})
+
+	// Exclude _id from enhancement conditions as they're nested within asset abilities
+	// and not directly assignable IDs in the current ID system
+	const { _id, ...baseProps } = triggerCondition.properties
+	const nuProps = {
+		...baseProps,
+		roll_options,
+		method
+	} as TNullableRollOptions
+
+	// Cast to Record<string, TSchema> to avoid deep type instantiation
+	return Type.Object(nuProps as Record<string, TSchema>, options)
+}
+
+const TriggerMixin = Type.Object({
+	text: Type.Ref(Text.MarkdownString, {
+		description:
+			'A markdown string containing the primary trigger text for this move.\n\nSecondary trigger text (for specific stats or uses of an asset ability) may be described in individual trigger conditions.',
+		type: 'string'
+		// pattern: /.*\.{3}/.source
+	})
+})
+
+export function Trigger<
+	T extends TFuzzyNull<TArray<TFuzzyRef<TTriggerCondition>>>
+>(conditions: T, options: ObjectOptions = {}) {
+	return Assign(
+		TriggerMixin,
+		setDescriptions(Type.Object({ conditions }), {
+			conditions: 'Specific conditions that qualify for this trigger.'
+		}),
+		options
+	) as TTrigger<T>
+}
+export type TTrigger<
+	T extends TFuzzyNull<TArray<TFuzzyRef<TTriggerCondition>>> = TFuzzyNull<
+		TArray<TFuzzyRef<TTriggerCondition>>
+	>
+> = TObject<(typeof TriggerMixin)['properties'] & { conditions: T }>
+
+export type Trigger<
+	T extends TriggerCondition[] | null = TriggerCondition[] | null
+> = Static<typeof TriggerMixin> & { conditions: T }
+
+export function TriggerEnhancement<
+	T extends TFuzzyNull<TArray<TFuzzyRef<TTriggerCondition>>>
+>(conditions: T, options: ObjectOptions) {
+	return Type.Object(
+		{
+			conditions: {
+				description: 'Trigger conditions added to the enhanced move.',
+				...conditions
+			} as T
+		},
+		{
+			description:
+				"Describes changes/additions made to the enhanced move's trigger conditions.",
+			...options
+		}
+	)
+}
+
+export type TTriggerEnhancement<
+	T extends TFuzzyNull<TArray<TFuzzyRef<TTriggerCondition>>> = TFuzzyNull<
+		TArray<TFuzzyRef<TTriggerCondition>>
+	>
+> = ReturnType<typeof TriggerEnhancement<T>>
+export type TriggerEnhancement<
+	T extends TriggerCondition[] | null = TriggerCondition[] | null
+> = { conditions: T }