@datasworn-community/build-tools 0.2.0

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

@@ -0,0 +1,136 @@
+import {
+	type Static,
+	type TAnySchema,
+	type TBigInt,
+	Type
+} from '@sinclair/typebox'
+import * as Text from '../common/Text.js'
+import * as Utils from '../Utils.js'
+import { UnionEnumFromRecord } from '../utils/UnionEnumFromRecord.js'
+
+enum Outcome {
+	Miss = 'miss',
+	WeakHit = 'weak_hit',
+	StrongHit = 'strong_hit'
+}
+
+enum RollMethod {
+	Miss = 'miss',
+	WeakHit = 'weak_hit',
+	StrongHit = 'strong_hit',
+	PlayerChoice = 'player_choice',
+	Highest = 'highest',
+	Lowest = 'lowest',
+	All = 'all'
+}
+
+// ENUMS
+
+export const MoveRollType = UnionEnumFromRecord(
+	{
+		no_roll: 'A move that makes no action rolls or progress rolls.',
+		action_roll: 'A move that makes an action roll.',
+		progress_roll:
+			'A progress move that rolls on a standard progress track type (defined by this move).',
+		special_track:
+			'A progress move that rolls on one or more special tracks, like Bonds (classic Ironsworn), Failure (Delve), or Legacies (Starforged).'
+	},
+	{ $id: 'MoveRollType' }
+)
+
+export type MoveRollType = Static<typeof MoveRollType>
+export type TMoveRollType = typeof MoveRollType
+
+const MoveOutcomeType = UnionEnumFromRecord(
+	{
+		[Outcome.Miss]: "The score doesn't beat either challenge die.",
+		[Outcome.WeakHit]: 'The score is greater than one challenge die.',
+		[Outcome.StrongHit]: 'The score is greater than both challenge dice.'
+	},
+	{
+		$id: 'MoveOutcomeType'
+	}
+)
+type _MoveOutcomeType = Static<typeof MoveOutcomeType>
+
+const rollMethodForceOutcome = {
+	[RollMethod.Miss]: 'An automatic miss.',
+	[RollMethod.WeakHit]: 'An automatic weak hit.',
+	[RollMethod.StrongHit]: 'An automatic strong hit.'
+}
+
+const rollMethodOutcomeCommon = {
+	[RollMethod.PlayerChoice]: 'The player chooses which roll option to use.',
+	[RollMethod.Highest]: 'Use the roll option with the best/highest value.',
+	[RollMethod.Lowest]: 'Use the roll option with the worst/lowest value.',
+	[RollMethod.All]: 'Use _every_ roll option at once.'
+}
+
+export const ActionRollMethod = UnionEnumFromRecord(
+	{
+		...rollMethodForceOutcome,
+		...rollMethodOutcomeCommon
+	},
+	{ $id: 'ActionRollMethod' }
+)
+export type ActionRollMethod = Static<typeof ActionRollMethod>
+
+export const SpecialTrackRollMethod = UnionEnumFromRecord(
+	{
+		...rollMethodForceOutcome,
+		...rollMethodOutcomeCommon
+	},
+	{ $id: 'SpecialTrackRollMethod' }
+)
+
+export type SpecialTrackRollMethod = Static<typeof SpecialTrackRollMethod>
+
+export const ProgressRollMethod = UnionEnumFromRecord(
+	{
+		...rollMethodForceOutcome,
+		progress_roll:
+			'Make a progress roll on a progress track associated with this move.'
+	},
+	{ $id: 'ProgressRollMethod' }
+)
+export type ProgressRollMethod = Static<typeof ProgressRollMethod>
+
+export const MoveOutcome = Type.Object(
+	{
+		_id: Utils.Computed(Type.Ref('AnyMoveOutcomeId')),
+		text: Type.Ref(Text.MarkdownString, {
+			// pattern: /On a __(strong hit|weak hit|miss)__/.source,
+			// type: 'string'
+		}),
+		oracle_rolls: Type.Optional(Type.Array(Type.Ref('OracleRoll')))
+		// count_as: Type.Optional(Type.Ref(MoveOutcomeType))
+	},
+	{ $id: 'MoveOutcome' }
+)
+export type MoveOutcome = Static<typeof MoveOutcome>
+
+// export const MoveOutcomeMatchable = Assign(
+// [	MoveOutcome, Type.Object({ match: Type.Optional(Type.Ref(MoveOutcome)) })],
+// 	{ $id: 'MoveOutcomeMatchable' }
+// )
+// export type MoveOutcomeMatchable = Static<typeof MoveOutcomeMatchable>
+
+export const MoveOutcomes = Type.Object(
+	{
+		[Outcome.StrongHit]: Type.Ref('MoveOutcome'),
+		// [Outcome.StrongHit]: Type.Ref<typeof MoveOutcomeMatchable>('MoveOutcomeMatchable'),
+		[Outcome.WeakHit]: Type.Ref('MoveOutcome'),
+		[Outcome.Miss]: Type.Ref('MoveOutcome')
+		// [Outcome.Miss]: Type.Ref<typeof MoveOutcomeMatchable>('MoveOutcomeMatchable'),
+	},
+	{
+		$id: 'MoveOutcomes',
+		description: `A standalone localized description for each move outcome (miss, weak hit, or strong hit). This is for for e.g. VTT implementations, where it's often useful to display only the rules text relevant to a roll result.
+
+  This often requires light editorialization to create text that can stand alone without reference to the rest of the move. For example, 'as above' (in reference to another move outcome) shouldn't be used here; instead, the relevant text should be repeated.`
+	}
+)
+export type MoveOutcomes = Static<typeof MoveOutcomes>
+export type TMoveOutcomes = typeof MoveOutcomes
+
+export type SchemaOf<T> = Exclude<TAnySchema, TBigInt> & { static: T }

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

@@ -0,0 +1,13 @@
+// parts
+
+// subtypes
+export * from './ActionRoll.js'
+export * from './common.js'
+export * from './EmbeddedMove.js'
+// primary type
+export * from './Move.js'
+// derived types
+export * from './MoveCategory.js'
+export * from './MoveEnhancement.js'
+export * from './ProgressRoll.js'
+export { TriggerBy } from './Trigger.js'

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

@@ -0,0 +1,132 @@
+import {
+	type ObjectOptions,
+	type Static,
+	type TBoolean,
+	type TLiteral,
+	type TNull,
+	type TRef,
+	type TRefUnsafe,
+	Type
+} from '@sinclair/typebox'
+import type { SetRequired } from 'type-fest'
+import Id from '../common/Id.js'
+import * as Text from '../common/Text.js'
+import * as Generic from '../Generic.js'
+import { EmbeddedOracleRollable } from '../oracles/EmbeddedOracleRollable.js'
+import { ExtractLiteralFromEnum } from '../utils/ExtractLiteralFromEnum.js'
+import { FlatIntersect } from '../utils/FlatIntersect.js'
+import {
+	type MoveOutcomes,
+	MoveRollType,
+	type TMoveOutcomes
+} from './common.js'
+import type { Trigger, TTrigger, TTriggerEnhancement } from './Trigger.js'
+
+/** The property key used to discriminate move subtypes */
+export const moveDiscriminator = 'roll_type'
+
+const MoveBase = Type.Object({
+	replaces: Type.Optional(
+		Type.Array(Type.Ref(Id.MoveIdWildcard), {
+			description:
+				'Indicates that this move replaces the identified moves. References to the replaced moves can be considered equivalent to this move.'
+		})
+	),
+	text: Type.Ref(Text.MarkdownString, {
+		description: 'The complete rules text of the move.'
+	}),
+	oracles: Type.Optional(
+		Generic.Dictionary(
+			Type.Ref(EmbeddedOracleRollable, { title: 'MoveOracleRollable' }),
+			{ title: 'MoveOracles' }
+		)
+	)
+})
+
+export function Move<
+	RollType extends MoveRollType,
+	Trigger extends TRefUnsafe<TTrigger> | TRef<string>,
+	Outcomes extends TRefUnsafe<TMoveOutcomes> | TRef<string> | TNull
+>(
+	rollType: RollType,
+	trigger: Trigger,
+	outcomes: Outcomes,
+	options: SetRequired<ObjectOptions, '$id'>
+) {
+	let allow_momentum_burn: TLiteral<boolean> | TBoolean
+
+	const description = 'Is burning momentum allowed for this move?'
+
+	switch (rollType) {
+		case 'action_roll':
+			allow_momentum_burn = Type.Boolean({
+				default: true,
+				description
+			})
+			break
+		default:
+			allow_momentum_burn = Type.Literal(false, { default: false, description })
+			break
+	}
+
+	const base = FlatIntersect([
+		MoveBase,
+		Type.Object({
+			trigger: {
+				title: 'Trigger',
+				description: 'Trigger conditions for this move.',
+				...trigger
+			} as Trigger,
+			allow_momentum_burn,
+			outcomes: { title: 'MoveOutcomes', ...outcomes } as Outcomes
+		})
+	])
+
+	return Generic.CollectableSubtypeNode(
+		base,
+		'move',
+		moveDiscriminator,
+		rollType,
+		options
+	)
+}
+export type TMove<
+	RollType extends MoveRollType,
+	MoveTrigger extends TRefUnsafe<TTrigger>,
+	Outcomes extends TRefUnsafe<TMoveOutcomes> | TNull
+> = ReturnType<typeof Move<RollType, MoveTrigger, Outcomes>>
+
+export type Move<
+	RollType extends MoveRollType,
+	MoveTrigger extends Trigger,
+	Outcomes extends MoveOutcomes | null
+> = Generic.Collectable<
+	Static<typeof MoveBase> & {
+		[moveDiscriminator]: RollType
+		trigger: MoveTrigger
+		outcomes: Outcomes
+		allow_momentum_burn: TLiteral<boolean> | TBoolean
+	}
+>
+
+export function MoveEnhancement<
+	RollType extends MoveRollType,
+	Trigger extends TRefUnsafe<TTriggerEnhancement>
+>(rollType: RollType, trigger: Trigger, options: ObjectOptions = {}) {
+	const base = Type.Object({
+		[moveDiscriminator]: ExtractLiteralFromEnum(MoveRollType, rollType, {
+			description: `A move must have this \`${moveDiscriminator}\` to receive this enhancement. This is in addition to any other restrictions made by other properties.`
+		}),
+		trigger: Type.Optional(trigger)
+	})
+
+	return Generic.EnhanceMany(base, Type.Ref('AnyMoveIdWildcard'), {
+		description:
+			'An object that describes changes to a move. These changes should be applied recursively, altering only the specified properties; enhanced arrays should be concatencated with the original array value.',
+		...options
+	})
+}
+export type MoveEnhancement<T extends MoveRollType, E> = Generic.EnhanceMany<{
+	[moveDiscriminator]: T
+	trigger?: E
+}>

package/schema-source/schema/object_type/ObjectType.ts

@@ -0,0 +1,23 @@
+import * as Utils from '../Utils.js'
+
+export const ObjectType = Utils.UnionEnumFromRecord({
+	// RulesPackages
+	ruleset: '',
+	rules_expansion: '',
+	// Collections
+	oracle_collection: '',
+	asset_collection: '',
+	move_category: '',
+	npc_collection: '',
+	atlas: '',
+
+	// collectables
+	oracle_rollable: '',
+	// ...subtypes
+	move: ''
+	// ...subtypes
+
+	// delve_site_theme
+	// delve_site_domain
+	// rarity
+})

package/schema-source/schema/oracles/EmbeddedOracleRollable.ts

@@ -0,0 +1,28 @@
+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 { OracleRollable } from './OracleRollable.js'
+
+const oracleRollableMapping = mapValues(OracleRollable[Mapping], (schema, k) =>
+	EmbeddedPrimaryNode(schema, [], { $id: `EmbeddedOracle${pascalCase(k)}` })
+)
+
+export const {
+	column_text: EmbeddedOracleColumnText,
+	column_text2: EmbeddedOracleColumnText2,
+	column_text3: EmbeddedOracleColumnText3,
+	table_text: EmbeddedOracleTableText,
+	table_text2: EmbeddedOracleTableText2,
+	table_text3: EmbeddedOracleTableText3
+} = oracleRollableMapping
+
+export const EmbeddedOracleRollable = DiscriminatedUnion(
+	oracleRollableMapping,
+	'oracle_type',
+	{ $id: 'EmbeddedOracleRollable' }
+)
+
+export type EmbeddedOracleRollable = Static<typeof EmbeddedOracleRollable>

package/schema-source/schema/oracles/OracleCollection.ts

@@ -0,0 +1,140 @@
+import { type Static, Type } from '@sinclair/typebox'
+import * as Generic from '../Generic.js'
+import * as Utils from '../Utils.js'
+import {
+	OracleColumnText,
+	OracleColumnText2,
+	OracleColumnText3
+} from './OracleRollable.js'
+import {
+	SharedRollsLabels,
+	SharedText2Labels,
+	SharedText3Labels,
+	SharedTextLabels
+} from './Table.js'
+
+const OracleCollectionType = Utils.UnionEnumFromRecord(
+	{
+		tables: 'A grouping of separate tables.',
+		table_shared_rolls:
+			'A table with one shared roll column, and multiple unique text columns.',
+		table_shared_text:
+			'A table with multiple unique roll columns, and one shared text column.',
+		table_shared_text2:
+			'A table with multiple unique roll columns, and 2 shared text columns.',
+		table_shared_text3:
+			'A table with multiple unique roll columns, and 3 shared text columns.'
+	},
+	{
+		$id: 'OracleCollectionType'
+	}
+)
+type OracleCollectionType = Static<typeof OracleCollectionType>
+
+const subtypeKey = 'oracle_type' as const
+
+export const OracleTablesCollection = Generic.CollectionSubtypeNode(
+	Type.Object({}),
+	'oracle_collection',
+	subtypeKey,
+	'tables' satisfies OracleCollectionType,
+	Generic.Dictionary(Type.Ref('OracleRollableTable')),
+	Generic.Dictionary(Type.Ref('OracleCollection')),
+	{
+		$id: 'OracleTablesCollection',
+		description:
+			'An OracleCollection that represents a category or grouping of tables, which may themselves be `OracleTablesCollection`s.'
+	}
+)
+
+export type TOracleTablesCollection = typeof OracleTablesCollection
+export type OracleTablesCollection = Static<TOracleTablesCollection>
+
+export const OracleTableSharedRolls = Generic.CollectionSubtypeNode(
+	Type.Object({
+		column_labels: SharedRollsLabels
+	}),
+	'oracle_collection',
+	subtypeKey,
+	'table_shared_rolls' satisfies OracleCollectionType,
+	Generic.Dictionary(Type.Ref(OracleColumnText)),
+	undefined,
+	{
+		$id: 'OracleTableSharedRolls',
+		description:
+			'An OracleCollection representing a single table with one roll column and multiple text columns.'
+	}
+)
+
+export type TOracleTableSharedRolls = typeof OracleTableSharedRolls
+export type OracleTableSharedRolls = Static<TOracleTableSharedRolls>
+
+export const OracleTableSharedText = Generic.CollectionSubtypeNode(
+	Type.Object({
+		column_labels: SharedTextLabels
+	}),
+	'oracle_collection',
+	subtypeKey,
+	'table_shared_text' satisfies OracleCollectionType,
+	Generic.Dictionary(Type.Ref(OracleColumnText)),
+	undefined,
+	{
+		$id: 'OracleTableSharedText',
+		description:
+			'An OracleCollection representing a single table with multiple roll columns and one text column.'
+	}
+)
+
+export type TOracleTableSharedText = typeof OracleTableSharedText
+export type OracleTableSharedText = Static<TOracleTableSharedText>
+
+export const OracleTableSharedText2 = Generic.CollectionSubtypeNode(
+	Type.Object({
+		column_labels: SharedText2Labels
+	}),
+	'oracle_collection',
+	subtypeKey,
+	'table_shared_text2' satisfies OracleCollectionType,
+	Generic.Dictionary(Type.Ref(OracleColumnText2)),
+	undefined,
+	{
+		$id: 'OracleTableSharedText2',
+		description:
+			'An OracleCollection representing a single table with multiple roll columns, and 2 shared text columns.'
+	}
+)
+export type TOracleTableSharedText2 = typeof OracleTableSharedText2
+export type OracleTableSharedText2 = Static<TOracleTableSharedText2>
+
+export const OracleTableSharedText3 = Generic.CollectionSubtypeNode(
+	Type.Object({
+		column_labels: SharedText3Labels
+	}),
+	'oracle_collection',
+	subtypeKey,
+	'table_shared_text3' satisfies OracleCollectionType,
+	Generic.Dictionary(Type.Ref(OracleColumnText3)),
+	undefined,
+	{
+		$id: 'OracleTableSharedText3',
+		description:
+			'An OracleCollection representing a single table with multiple roll columns, and 3 shared text columns.'
+	}
+)
+export type TOracleTableSharedText3 = typeof OracleTableSharedText3
+export type OracleTableSharedText3 = Static<TOracleTableSharedText3>
+
+export const OracleCollection = Utils.DiscriminatedUnion(
+	{
+		tables: OracleTablesCollection,
+		table_shared_rolls: OracleTableSharedRolls,
+		table_shared_text: OracleTableSharedText,
+		table_shared_text2: OracleTableSharedText2,
+		table_shared_text3: OracleTableSharedText3
+	},
+	subtypeKey,
+	{ $id: 'OracleCollection' }
+)
+
+export type TOracleCollection = typeof OracleCollection
+export type OracleCollection = Static<TOracleCollection>

package/schema-source/schema/oracles/OracleRollable.ts

@@ -0,0 +1,207 @@
+import {
+	type ObjectOptions,
+	type Static,
+	type TObject,
+	type TRefUnsafe,
+	type TSchema,
+	Type
+} from '@sinclair/typebox'
+import type { SetRequired } from 'type-fest'
+import * as Rolls from '../common/Rolls.js'
+import { CollectableSubtypeNode } from '../generic/CollectableNode.js'
+import * as Utils from '../Utils.js'
+import { FlatIntersect } from '../utils/FlatIntersect.js'
+import {
+	Text2ColumnLabels,
+	Text3ColumnLabels,
+	TextColumnLabels
+} from './Table.js'
+import {
+	OracleRollableRowText,
+	OracleRollableRowText2,
+	OracleRollableRowText3
+} from './TableRow.js'
+
+// metadata necessary to generate a roll result from an OracleRollable
+const RollableMeta = Type.Object({
+	recommended_rolls: Type.Optional(
+		Type.Object({
+			min: Type.Integer({ default: 1 }),
+			max: Type.Integer({ default: 1 })
+		})
+	),
+	dice: Type.Ref(Rolls.DiceExpression, {
+		default: '1d100',
+		description: 'The roll used to select a result on this oracle.'
+	}),
+	match: Type.Optional(
+		Type.Ref(Rolls.OracleMatchBehavior, {
+			description:
+				'Most oracle tables are insensitive to matches, but a few define special match behavior.'
+		})
+	)
+})
+
+const subtypeKey = 'oracle_type' as const
+
+function OracleRollableBase<TBase extends TObject, _TSubtype extends string>(
+	base: TBase,
+	row: TRefUnsafe<TObject>,
+	options: ObjectOptions = {}
+) {
+	const enhancedBase = FlatIntersect(
+		[
+			RollableMeta,
+			Type.Object({
+				rows: Type.Array(row, {
+					description:
+						'An array of objects, each representing a single row of the table.',
+					rollable: true
+				})
+			}),
+			base
+		],
+		options
+	)
+
+	return enhancedBase
+}
+function RollableTable<TRow extends TObject, TSubtype extends string>(
+	subtype: TSubtype,
+	row: TRefUnsafe<TRow>,
+	column_labels: TSchema,
+	options: SetRequired<ObjectOptions, '$id'>
+) {
+	return CollectableSubtypeNode(
+		OracleRollableBase(Type.Object({ column_labels }), row),
+		'oracle_rollable',
+		subtypeKey,
+		subtype,
+		options
+	)
+}
+
+function RollableColumn<TRow extends TObject, TSubtype extends string>(
+	subtype: TSubtype,
+	row: TRefUnsafe<TRow>,
+	options: SetRequired<ObjectOptions, '$id'>
+) {
+	return Type.Omit(
+		CollectableSubtypeNode(
+			OracleRollableBase(Type.Object({}), row),
+			'oracle_rollable',
+			subtypeKey,
+			subtype,
+			options
+		),
+		['_source'],
+		options
+	)
+}
+
+export const OracleTableText = RollableTable(
+	'table_text',
+	Type.Ref(OracleRollableRowText),
+	TextColumnLabels,
+	{
+		$id: 'OracleTableText',
+		description:
+			'Represents a basic rollable oracle table with one roll column and one text result column.'
+	}
+)
+export type TOracleTableText = typeof OracleTableText
+export type OracleTableText = Static<typeof OracleTableText>
+
+export const OracleTableText2 = RollableTable(
+	'table_text2',
+	Type.Ref(OracleRollableRowText2),
+	Text2ColumnLabels,
+	{
+		$id: 'OracleTableText2',
+		description:
+			'A rollable oracle table with one roll column and two text columns.'
+	}
+)
+export type TOracleTableText2 = typeof OracleTableText2
+export type OracleTableText2 = Static<typeof OracleTableText2>
+
+export const OracleTableText3 = RollableTable(
+	'table_text3',
+	Type.Ref(OracleRollableRowText3),
+	Text3ColumnLabels,
+	{
+		$id: 'OracleTableText3',
+		description:
+			'A rollable oracle table with one roll column and 3 text columns.'
+	}
+)
+export type TOracleTableText3 = typeof OracleTableText3
+export type OracleTableText3 = Static<typeof OracleTableText2>
+
+export const OracleColumnText = RollableColumn(
+	'column_text',
+	Type.Ref(OracleRollableRowText),
+	{
+		$id: 'OracleColumnText',
+		description: 'Represents a single column in an OracleCollection.'
+	}
+)
+export type TOracleColumnText = typeof OracleColumnText
+export type OracleColumnText = Static<typeof OracleColumnText>
+
+export const OracleColumnText2 = RollableColumn(
+	'column_text2',
+	Type.Ref(OracleRollableRowText2),
+	{
+		$id: 'OracleColumnText2'
+	}
+)
+
+export type TOracleColumnText2 = typeof OracleColumnText2
+export type OracleColumnText2 = Static<typeof OracleColumnText2>
+
+export const OracleColumnText3 = RollableColumn(
+	'column_text3',
+	Type.Ref(OracleRollableRowText3),
+	{
+		$id: 'OracleColumnText3'
+	}
+)
+
+export type TOracleColumnText3 = typeof OracleColumnText3
+export type OracleColumnText3 = Static<typeof OracleColumnText2>
+
+export const OracleRollable = Utils.DiscriminatedUnion(
+	{
+		table_text: OracleTableText,
+		table_text2: OracleTableText2,
+		table_text3: OracleTableText3,
+		column_text: OracleColumnText,
+		column_text2: OracleColumnText2,
+		column_text3: OracleColumnText3
+	},
+	'oracle_type',
+	{
+		$id: 'OracleRollable',
+		description:
+			'A collection of table rows from which random results may be rolled. This may represent a standalone table, or a column in a larger table.'
+	}
+)
+
+export type OracleRollable = Static<typeof OracleRollable>
+export type TOracleRollable = typeof OracleRollable
+
+export const OracleRollableTable = Utils.DiscriminatedUnion(
+	{
+		table_text: OracleTableText,
+		table_text2: OracleTableText2,
+		table_text3: OracleTableText3
+	},
+	'oracle_type',
+	{
+		$id: 'OracleRollableTable'
+	}
+)
+
+export type OracleRollableTable = Static<typeof OracleRollableTable>
+export type TOracleRollableTable = typeof OracleRollableTable