@datasworn-community/build-tools 0.2.0

package/schema-source/schema/Utils.ts

@@ -0,0 +1,21 @@
+/**
+ * TypeBox schema functions representing utility types. Used internally to compose schemata, but not part of the final Datasworn schema output.
+ */
+
+export * from './utils/Computed.js'
+export * from './utils/DiscriminatedUnion.js'
+export * from './utils/ExtractLiteralFromEnum.js'
+export * from './utils/NonNullable.js'
+export * from './utils/Nullable.js'
+export * from './utils/ObjectLiteral.js'
+export * from './utils/OmitMeta.js'
+export * from './utils/OmitOptional.js'
+export * from './utils/PartialExcept.js'
+// depends on Nullable
+export * from './utils/SetNullable.js'
+// depends on Assign
+export * from './utils/SetOptional.js'
+export * from './utils/UnionEnum.js'
+// depends on UnionEnum
+export * from './utils/UnionEnumFromRecord.js'
+export * from './utils/UnionOneOf.js'

package/schema-source/schema/assets/Ability.ts

@@ -0,0 +1,79 @@
+import { type Static, Type } from '@sinclair/typebox'
+import Id from '../common/Id.js'
+import * as Text from '../common/Text.js'
+import * as Generic from '../Generic.js'
+import { EmbeddedMove } from '../moves/EmbeddedMove.js'
+import { MoveEnhancement } from '../moves/MoveEnhancement.js'
+import { EmbeddedOracleRollable } from '../oracles/EmbeddedOracleRollable.js'
+import { AssetEnhancement } from './Enhancement.js'
+import { AssetAbilityControlField, AssetAbilityOptionField } from './Fields.js'
+
+export const AssetAbility = Generic.IdNode(
+	Type.Object({
+		name: Type.Optional(
+			Type.Ref(Text.Label, {
+				description:
+					'A handful of asset abilities have a label/name, for instance classic Ironsworn companion assets. Most canonical assets omit this property.'
+			})
+		),
+		text: Type.Ref(Text.MarkdownString, {
+			description: 'The complete rules text of this asset ability.'
+		}),
+		enabled: Type.Boolean({
+			default: false,
+			description: 'Is this asset ability enabled?'
+		}),
+		moves: Type.Optional(
+			Generic.Dictionary(
+				Type.Ref(EmbeddedMove, { title: 'AssetAbilityMove' }),
+				{
+					title: 'AssetAbilityMoves',
+					description: 'Unique moves added by this asset ability.'
+				}
+			)
+		),
+		oracles: Type.Optional(
+			Generic.Dictionary(
+				Type.Ref(EmbeddedOracleRollable, {
+					title: 'AssetAbilityOracleRollable'
+				}),
+				{
+					title: 'AssetAbilityOracles'
+				}
+			)
+		),
+		options: Type.Optional(
+			Generic.Dictionary(Type.Ref(AssetAbilityOptionField), {
+				description:
+					'Fields that are expected to be set once and remain the same through the life of the asset.'
+			})
+		),
+		controls: Type.Optional(
+			Generic.Dictionary(Type.Ref(AssetAbilityControlField), {
+				description:
+					'Fields whose values are expected to change over the life of the asset.'
+			})
+		),
+		enhance_asset: Type.Optional(
+			Type.Ref(AssetEnhancement, {
+				description: 'Changes made to the asset, when this ability is enabled.'
+			})
+		),
+		enhance_moves: Type.Optional(
+			Type.Array(Type.Ref(MoveEnhancement), {
+				description:
+					'Describes changes made to various moves by this asset ability. Usually these require specific trigger conditions.'
+				// releaseStage: 'experimental'
+			})
+		),
+		tags: Type.Optional(Type.Ref('Tags'))
+	}),
+	Type.Ref(Id.AssetAbilityId),
+	{
+		$id: 'AssetAbility',
+		description:
+			'An asset ability: one of the purchasable features of an asset. Most assets have three.'
+	}
+)
+export type AssetAbility = Static<typeof AssetAbility>
+export type TAssetAbility = typeof AssetAbility

package/schema-source/schema/assets/Enhancement.ts

@@ -0,0 +1,62 @@
+import { type Static, Type } from '@sinclair/typebox'
+import * as Fields from '../common/Fields.js'
+import Id from '../common/Id.js'
+import { DiscriminatedUnion } from '../utils/DiscriminatedUnion.js'
+import { Nullable } from '../utils/Nullable.js'
+import { NoDefaults } from '../utils/typebox.js'
+import { AssetPropertiesEnhanceable } from './common.js'
+import { AssetConditionMeter } from './Fields.js'
+
+export const AssetAttachment = Type.Object(
+	{
+		assets: Type.Array(Type.Ref(Id.AssetIdWildcard), {
+			description:
+				'Asset IDs (which may be wildcards) that may be attached to this asset'
+		}),
+		max: Nullable(Type.Integer({ minimum: 1 }), {
+			default: null,
+			description:
+				"Null if there's no upper limit to the number of attached assets."
+		})
+	},
+	{
+		$id: 'AssetAttachment',
+		description:
+			"Describes which assets can be attached to this asset. Example: Starforged's Module assets, which can be equipped by Command Vehicle assets. See p. 55 of Starforged for more info."
+	}
+)
+export type TAssetAttachment = typeof AssetAttachment
+export type AssetAttachment = Static<TAssetAttachment>
+
+export const AssetConditionMeterEnhancement = NoDefaults(
+	// for the moment, it's only practical to enhance condition meters
+
+	Type.Pick(AssetConditionMeter, ['field_type', 'max']),
+	{
+		$id: 'AssetConditionMeterEnhancement'
+	}
+)
+export type AssetConditionMeterEnhancement = Static<
+	typeof AssetConditionMeterEnhancement
+>
+
+export const AssetControlFieldEnhancement = DiscriminatedUnion(
+	{
+		condition_meter: AssetConditionMeterEnhancement
+	},
+	Fields.DISCRIMINATOR,
+	{ $id: 'AssetControlFieldEnhancement' }
+)
+
+export const AssetEnhancement = NoDefaults(
+	Type.Partial(
+		AssetPropertiesEnhanceable(Type.Ref(AssetControlFieldEnhancement))
+	),
+	{
+		description:
+			'Describes enhancements made to this asset in a partial asset object. The changes should be applied recursively; only the values that are specified should be changed.',
+		$id: 'AssetEnhancement'
+	}
+)
+export type TAssetEnhancement = typeof AssetEnhancement
+export type AssetEnhancement = Static<typeof AssetEnhancement>

package/schema-source/schema/assets/Fields.ts

@@ -0,0 +1,285 @@
+import { type Static, Type } from '@sinclair/typebox'
+import type { Simplify } from 'type-fest'
+import * as Fields from '../common/Fields.js'
+import * as Generic from '../Generic.js'
+import { DiscriminatedUnion } from '../Utils.js'
+import { Assign } from '../utils/FlatIntersect.js'
+
+const AssetBooleanFieldMixin = Type.Object({
+	is_impact: Type.Boolean({
+		default: false,
+		description:
+			'Does this field count as an impact (Starforged) or debility (Ironsworn classic) when its value is set to `true`?'
+	}),
+	disables_asset: Type.Boolean({
+		default: false,
+		description:
+			'Does this field disable the asset when its value is set to `true`?'
+	})
+})
+
+// function AssetCheckboxField(
+// 	// _id:Id.TAnyId,
+// 	options: ObjectOptions = {}
+// ) {
+// 	const base = Fields.CheckboxField
+// 	// id
+// 	// ()
+// 	const { $comment, description } = base
+// 	return Assign(
+// 		[
+// 			Fields.CheckboxField,
+// 			// id
+// 			// (),
+// 			AssetBooleanFieldMixin
+// 		],
+// 		{
+// 			description,
+// 			$comment,
+// 			...options
+// 		}
+// 	)
+// }
+// function AssetCardFlipField(
+// 	// _id:Id.TAnyId,
+// 	options: ObjectOptions = {}
+// ) {
+// 	const base = Fields
+// 		.CardFlipField
+// 		// id
+// 		()
+// 	const { $comment, description } = base
+// 	return Assign([base, AssetBooleanFieldMixin], {
+// 		description,
+// 		$comment,
+// 		title: 'AssetCardFlipField',
+// 		...options
+// 	})
+// }
+export const AssetCheckboxField = Assign(
+	Fields.CheckboxField,
+	AssetBooleanFieldMixin,
+	{ $id: 'AssetCheckboxField' }
+)
+export const AssetCardFlipField = Assign(
+	Fields.CardFlipField,
+	AssetBooleanFieldMixin,
+	{ $id: 'AssetCardFlipField' }
+)
+
+export const AssetConditionMeterControlField = DiscriminatedUnion(
+	{ checkbox: AssetCheckboxField, card_flip: AssetCardFlipField },
+	// .map(
+	// 	(fn) => fn()
+	// Type.Ref(Id.AssetConditionMeterControlFieldId
+	//   )
+	// )
+	Fields.DISCRIMINATOR,
+	{
+		$id: 'AssetConditionMeterControlField',
+		description:
+			'A checkbox control field, rendered as part of an asset condition meter.'
+	}
+)
+export type AssetConditionMeterControlField = Static<
+	typeof AssetConditionMeterControlField
+>
+const AssetConditionMeterMixin = Type.Object({
+	moves: Type.Optional(
+		Type.Object(
+			{
+				suffer: Type.Optional(
+					Type.Array(
+						Type.Ref('AnyMoveIdWildcard', {
+							examples: [
+								'move:classic/suffer/companion_endure_harm',
+								'move:starforged/suffer/companion_takes_a_hit',
+								'move:starforged/suffer/withstand_damage'
+							]
+						}),
+						{
+							description:
+								'The ID(s) of suffer moves associated with the condition meter. If the suffer move makes an action roll, this condition meter value should be made available as a roll option.'
+						}
+					)
+				),
+				recover: Type.Optional(
+					Type.Array(
+						Type.Ref('AnyMoveIdWildcard', {
+							examples: [
+								'move:classic/adventure/heal',
+								'move:classic/adventure/make_camp',
+								'move:classic/relationship/sojourn',
+								'move:starforged/recover/heal',
+								'move:starforged/recover/repair'
+							]
+						}),
+						{
+							description:
+								'The ID(s) of recovery moves associated with this meter.'
+						}
+					)
+				)
+			},
+			{
+				description:
+					'Provides hints for moves that interact with this condition meter, such as suffer and recovery moves.',
+				releaseStage: 'experimental'
+			}
+		)
+	),
+	controls: Generic.Dictionary(Type.Ref(AssetConditionMeterControlField), {
+		description: 'Checkbox controls rendered as part of the condition meter.'
+	})
+})
+
+export const AssetConditionMeter = Assign(
+	Fields.ConditionMeterField,
+	// Type.Ref(Id.AssetControlFieldId)
+	// ()
+	AssetConditionMeterMixin,
+	{
+		$id: 'AssetConditionMeter',
+		description:
+			'Some assets provide a special condition meter of their own. The most common example is the health meters on companion assets. Asset condition meters may also include their own controls, such as the checkboxes that Starforged companion assets use to indicate they are "out of action".'
+	}
+)
+
+export type AssetConditionMeter = Simplify<Static<typeof AssetConditionMeter>>
+
+// const AssetOptionFields = [
+// 	Fields.SelectValueField,
+// 	Fields.SelectEnhancementField,
+// 	Fields.TextField
+// ].map((fn) => fn(Type.Ref(Id.AssetOptionFieldId)))
+
+// export const AssetSelectValueOptionField = Fields.SelectValueField(
+// 	// Type.Ref(Id.AssetOptionFieldId),
+// 	{ $id: 'AssetSelectValueOptionField' }
+// )
+// export const AssetSelectEnhancementOptionField = Fields.SelectEnhancementField(
+// 	// Type.Ref(Id.AssetOptionFieldId),
+// 	{ $id: 'AssetSelectEnhancementOptionField' }
+// )
+// export const AssetTextOptionField = Fields.TextField(
+// 	// Type.Ref(Id.AssetOptionFieldId),
+// 	{
+// 		$id: 'AssetTextOptionField'
+// 	}
+// )
+
+export const AssetOptionField = DiscriminatedUnion(
+	{
+		select_value: Fields.SelectValueField,
+		select_enhancement: Fields.SelectEnhancementField,
+		text: Fields.TextField
+	},
+	Fields.DISCRIMINATOR,
+	{
+		$id: 'AssetOptionField',
+		description:
+			'Options are asset input fields which are set once, usually when the character takes the asset. The most common example is the "name" field on companion assets. A more complex example is the choice of a god\'s stat for the Devotant asset.'
+	}
+)
+export type AssetOptionField = Static<typeof AssetOptionField>
+export type TAssetOptionField = typeof AssetOptionField
+
+// const AssetControlFields = [
+// 	AssetConditionMeter,
+// 	...[
+// 		Fields.SelectEnhancementField,
+// 		AssetCheckboxField,
+// 		AssetCardFlipField
+// 	].map((fn) => fn(Type.Ref(Id.AssetControlFieldId)))
+// ]
+
+// export const AssetSelectEnhancementControlField = Fields.SelectEnhancementField(
+// 	// Type.Ref(Id.AssetControlFieldId),
+// 	{ $id: 'AssetSelectEnhancementControlField' }
+// )
+// export const AssetCheckboxControlField = AssetCheckboxField(
+// 	// Type.Ref(Id.AssetControlFieldId),
+// 	{ $id: 'AssetCheckboxControlField' }
+// )
+// export const AssetCardFlipControlField = AssetCardFlipField(
+// 	// Type.Ref(Id.AssetControlFieldId),
+// 	{ $id: 'AssetCardFlipControlField' }
+// )
+
+export const AssetControlField = DiscriminatedUnion(
+	{
+		condition_meter: AssetConditionMeter,
+		select_enhancement: Fields.SelectEnhancementField,
+		checkbox: AssetCheckboxField,
+		card_flip: AssetCardFlipField
+	},
+	Fields.DISCRIMINATOR,
+	{
+		$id: 'AssetControlField'
+	}
+)
+
+export type TAssetControlField = typeof AssetControlField
+export type AssetControlField = Static<typeof AssetControlField>
+
+// const AbilityControlFields = [
+// 	Fields.ClockField,
+// 	Fields.CounterField,
+// 	AssetCheckboxField
+// ].map((fn) => fn(Type.Ref(Id.AssetAbilityControlFieldId)))
+
+// export const AssetAbilityClock = Fields.ClockField(
+// 	// Type.Ref(Id.AssetAbilityControlFieldId),
+// 	{ $id: 'AssetAbilityClock' }
+// )
+
+// export const AssetAbilityCounter = Fields.CounterField(
+// 	// Type.Ref(Id.AssetAbilityControlFieldId),
+// 	{ $id: 'AssetAbilityCounter' }
+// )
+
+// export const AssetAbilityCheckbox = AssetCheckboxField(
+// 	// Type.Ref(Id.AssetAbilityControlFieldId),
+// 	{ $id: 'AssetAbilityCheckbox' }
+// )
+
+export const AssetAbilityControlField = DiscriminatedUnion(
+	{
+		clock: Fields.ClockField,
+		counter: Fields.CounterField,
+		checkbox: AssetCheckboxField,
+		text: Fields.TextField
+	},
+	Fields.DISCRIMINATOR,
+	{ $id: 'AssetAbilityControlField' }
+)
+
+export type AssetAbilityControlField = Static<typeof AssetAbilityControlField>
+
+// const AbilityOptionFields = [Fields.TextField]
+// 	.map
+// 	// (fn) => fn()
+// 	// Type.Ref(Id.AssetAbilityOptionFieldId)
+// 	()
+
+export const AssetAbilityOptionField = DiscriminatedUnion(
+	{
+		text: Fields.TextField
+	},
+	Fields.DISCRIMINATOR,
+	{ $id: 'AssetAbilityOptionField' }
+)
+
+export type AssetAbilityOptionField = Static<typeof AssetAbilityOptionField>
+
+export {
+	ClockField,
+	ConditionMeterField,
+	CounterField,
+	SelectEnhancementField,
+	SelectEnhancementFieldChoice,
+	SelectEnhancementFieldChoiceGroup,
+	SelectValueField,
+	SelectValueFieldChoice,
+	TextField
+} from '../common/Fields.js'

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

@@ -0,0 +1,29 @@
+import { type TSchema, Type } from '@sinclair/typebox'
+import * as Metadata from '../common/Metadata.js'
+
+import * as Generic from '../generic/Dictionary.js'
+
+export function AssetPropertiesEnhanceable<Control extends TSchema>(
+	controlSchema: Control
+) {
+	return Type.Object({
+		controls: Type.Optional(
+			Generic.Dictionary(controlSchema, {
+				description:
+					'Controls are condition meters, clocks, counters, and other asset input fields whose values are expected to change throughout the life of the asset.'
+			})
+		),
+		suggestions: Type.Optional(Type.Ref(Metadata.Suggestions)),
+		count_as_impact: Type.Boolean({
+			default: false,
+			description:
+				'If `true`, this asset counts as an impact (Starforged) or a debility (classic Ironsworn).'
+		}),
+		attachments: Type.Optional(Type.Ref('AssetAttachment')),
+		shared: Type.Boolean({
+			default: false,
+			description:
+				"Most assets only benefit to their owner, but certain assets (like Starforged's module and command vehicle assets) are shared amongst the player's allies, too."
+		})
+	})
+}