@datasworn-community/build-tools 0.2.0

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

@@ -0,0 +1,94 @@
+import {
+	type ObjectOptions,
+	type Static,
+	type TObject,
+	type TRefUnsafe,
+	type TString,
+	Type
+} from '@sinclair/typebox'
+import { omit } from 'lodash-es'
+import { Label, MarkdownString } from '../common/Text.js'
+import { FlatIntersect } from '../utils/FlatIntersect.js'
+import type { OracleRollableRowText3 } from './TableRow.js'
+
+// metadata relevant to presenting a table
+export const TableMeta = Type.Object({
+	recommended_rolls: Type.Optional(
+		Type.Object({
+			min: Type.Integer({ default: 1 }),
+			max: Type.Integer({ default: 1 })
+		})
+	),
+
+	summary: Type.Optional(
+		Type.Ref(MarkdownString, {
+			description:
+				'A brief summary of the oracle table\'s intended usage, no more than a few sentences in length. This is intended for use in application tooltips and similar sorts of hints. Longer text should use the "description" key instead.'
+		})
+	),
+	description: Type.Optional(
+		Type.Ref(MarkdownString, {
+			description:
+				"A longer description of the oracle table's intended usage, which might include multiple paragraphs. If it's only a couple sentences, use the `summary` key instead."
+		})
+	)
+})
+
+export function TableMixin<_OracleRow extends TObject>(
+	column_labels: ReturnType<typeof ColumnLabels>
+) {
+	return FlatIntersect([
+		TableMeta,
+		Type.Object({
+			column_labels
+		})
+	])
+}
+function ColumnLabels<
+	TextKeys extends [...(keyof Static<typeof OracleRollableRowText3>)[]]
+>(textKeys: TextKeys, options: ObjectOptions = {}) {
+	const props = {
+		roll: Type.Ref(Label)
+	} as Record<'roll' | TextKeys[number], TRefUnsafe<TString>>
+	for (const k of textKeys) props[k as keyof typeof props] = Type.Ref(Label)
+
+	return Type.Object(props, options)
+}
+
+export const TextColumnLabels = ColumnLabels(['text'], {
+	title: 'TextColumnLabels',
+	default: { roll: 'Roll', text: 'Result' }
+})
+export const Text2ColumnLabels = ColumnLabels(['text', 'text2'], {
+	title: 'Text2ColumnLabels',
+	default: {
+		roll: 'Roll',
+		text: 'Result',
+		text2: 'Details'
+	}
+})
+
+export const Text3ColumnLabels = ColumnLabels(['text', 'text2', 'text3'], {
+	title: 'Text3ColumnLabels'
+})
+
+export const SharedRollsLabels = Type.Omit(TextColumnLabels, ['text'], {
+	default: omit(TextColumnLabels.default, ['text']),
+	description:
+		'Provides column labels for this table. The `roll` key refers to the roll column showing the dice range (`min` and `max` on each table row). For all other column labels, see the `name` property of each child `OracleColumn`.',
+	title: 'SharedRollsLabels'
+})
+export const SharedTextLabels = Type.Omit(TextColumnLabels, ['roll'], {
+	default: omit(TextColumnLabels.default, ['roll']),
+	title: 'SharedTextLabels'
+})
+
+export const SharedText2Labels = Type.Omit(Text2ColumnLabels, ['roll'], {
+	default: omit(Text2ColumnLabels.default, ['roll']),
+	title: 'SharedText2Labels'
+})
+
+export const SharedText3Labels = Type.Omit(Text3ColumnLabels, ['roll'], {
+	default: omit(Text3ColumnLabels.default, ['roll']),
+	title: 'SharedText3Labels'
+})

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

@@ -0,0 +1,141 @@
+import {
+	CloneType,
+	type Static,
+	type TObject,
+	type TRefUnsafe,
+	type TSchema,
+	Type
+} from '@sinclair/typebox'
+import Id from '../common/Id.js'
+import * as Metadata from '../common/Metadata.js'
+import { DiceRange, StaticDiceRange } from '../common/Range.js'
+import * as Rolls from '../common/Rolls.js'
+import * as Text from '../common/Text.js'
+import { JsonTypeDef } from '../Symbols.js'
+import * as Utils from '../Utils.js'
+import { Assign } from '../utils/FlatIntersect.js'
+import type { ObjectProperties } from '../utils/ObjectProperties.js'
+import { type PickByType, setDescriptions } from '../utils/typebox.js'
+
+const TableRowBase = Type.Object({
+	text: Type.Ref(Text.MarkdownString, {
+		description: 'The primary text content of this row.'
+	}),
+	icon: Type.Optional(Type.Ref(Metadata.SvgImageUrl)),
+	oracle_rolls: Type.Optional(
+		Type.Array(Type.Ref(Rolls.OracleRoll), {
+			description: 'Further oracle rolls prompted by this table row.'
+		})
+	),
+	suggestions: Type.Optional(Type.Ref(Metadata.Suggestions)),
+	embed_table: Type.Optional(
+		Type.Ref(Id.OracleRollableId, {
+			releaseStage: 'experimental',
+			description:
+				'Hints that the identified table should be rendered inside this table row.'
+		})
+	),
+	template: Type.Optional(
+		Type.Ref(Rolls.OracleRollTemplate, { releaseStage: 'experimental' })
+	),
+	_i18n: Type.Optional(
+		Type.Ref(Text.I18nHints, {
+			releaseStage: 'experimental'
+		})
+	)
+})
+
+export const TableRowMixin = Assign(
+	TableRowBase,
+	Type.Object({
+		roll: Type.Ref(DiceRange),
+		tags: Type.Optional(Type.Ref('Tags')),
+		_id: Utils.Computed(Type.Ref('AnyOracleRollableRowId'))
+	})
+)
+
+export const TableRowNullableMixin = setDescriptions(
+	Utils.SetNullable(TableRowMixin, ['roll'], { defaultToNull: true }),
+	{
+		roll: '`null` represents an unrollable row, included only for rendering purposes.'
+	}
+)
+
+export type TTableRow<Roll extends TSchema = TSchema> = TObject<
+	ObjectProperties<typeof TableRowBase> & { roll: Roll }
+>
+
+type _TableRow<
+	Roll = { min: number; max: number } | null,
+	Props extends { roll: Roll } = { roll: Roll }
+> = Props & Static<typeof TableRowBase>
+
+export function StaticRowPartial(min: number, max: number) {
+	return Type.Object(
+		{ roll: StaticDiceRange(min, max) },
+		{ additionalProperties: true }
+	)
+}
+
+export const OracleRollableRowText = CloneType(TableRowNullableMixin, {
+	$id: 'OracleRollableRowText',
+	description: 'Represents a row in an oracle table, with a single text cell.'
+})
+
+export type OracleRollableRowText = Static<typeof OracleRollableRowText>
+
+export const OracleRollableRowText2 = Assign(
+	TableRowNullableMixin,
+	Type.Object({
+		text2: Utils.Nullable(Type.Ref(Text.MarkdownString), {
+			description:
+				'The secondary text for this row. Use `null` to represent a cell with a blank or empty vlue.'
+		})
+	}),
+	{
+		$id: 'OracleRollableRowText2',
+		description:
+			'Represents a row in an oracle table that provides a secondary text field.'
+	}
+)
+export type OracleRollableRowText2 = Static<typeof OracleRollableRowText2>
+
+export const OracleRollableRowText3 = Assign(
+	TableRowNullableMixin,
+	Type.Object({
+		text2: Utils.Nullable(Type.Ref(Text.MarkdownString), {
+			description:
+				'The secondary text for this row. Use `null` to represent a cell with a blank or empty value.'
+		}),
+		text3: Utils.Nullable(Type.Ref(Text.MarkdownString), {
+			description:
+				'The tertiary text for this row. Use `null` to represent a cell with a blank or empty vlue.'
+		})
+	}),
+	{
+		$id: 'OracleRollableRowText3',
+		description: 'Represents a row in an oracle table with 3 text cells.'
+	}
+)
+export type OracleRollableRowText3 = Static<typeof OracleRollableRowText3>
+
+type _StringDefaultsFor<T extends TObject> = {
+	[K in
+		| keyof PickByType<
+				T['properties'],
+				| TRefUnsafe<typeof Text.Label>
+				| Utils.TNullable<TRefUnsafe<typeof Text.Label>>
+		  >
+		| 'roll']: string | null
+}
+
+export const OracleRollableRow = Type.Union(
+	[
+		Type.Ref(OracleRollableRowText),
+		Type.Ref(OracleRollableRowText2),
+		Type.Ref(OracleRollableRowText3)
+	],
+	{ $id: 'OracleRollableRow', [JsonTypeDef]: { skip: true } }
+)
+
+export type OracleRollableRow = Static<typeof OracleRollableRow>

package/schema-source/schema/root/NiceSchema.ts

@@ -0,0 +1,15 @@
+import { type TSchema, TypeGuard } from '@sinclair/typebox'
+
+/** Mutates schema. */
+export function NiceSchema(schema: TSchema) {
+	if (TypeGuard.IsObject(schema)) schema.additionalProperties ||= false
+
+	// if (!schema.title && !('$ref' in schema)) {
+	// 	console.log(schema)
+	// 	throw new Error(
+	// 		"Couldn't infer a title for this schema, please set it manually."
+	// 	)
+	// }
+
+	return schema
+}

package/schema-source/schema/root/Root.ts

@@ -0,0 +1,41 @@
+import { CloneType, type SchemaOptions, type TSchema } from '@sinclair/typebox'
+import { mapValues } from 'lodash-es'
+import { DefsKey } from '../../scripts/const.js'
+import type { Defs } from '../Defs.js'
+import { SourceData } from './SourceData.js'
+
+export interface RootOptions extends SchemaOptions {
+	$id: `${'https' | 'http'}://${string}`
+	[DefsKey]: Defs
+	$schema: string
+	title: string
+}
+
+export type TRoot<T extends TSchema = TSchema> = T & RootOptions
+
+export function RootObject<T extends TSchema, Options extends RootOptions>(
+	base: T,
+	options: Options
+) {
+	const rootOptions = {
+		...options,
+		[DefsKey]: mapValues(options[DefsKey], (v, k) =>
+			CloneType(v, { title: k })
+		) as Defs
+	}
+
+	return CloneType(base, rootOptions) as unknown as TRoot<T>
+}
+
+export function SourceRootObject<
+	T extends TSchema,
+	Options extends RootOptions
+>(base: T, options: Options) {
+	return CloneType(base, {
+		...options,
+
+		[DefsKey]: mapValues(options[DefsKey], (v, k) =>
+			SourceData(CloneType(v, { title: k }))
+		) as Defs
+	}) as unknown as TRoot
+}

package/schema-source/schema/root/SchemaTransform.ts

@@ -0,0 +1,89 @@
+import {
+	CloneType,
+	type SchemaOptions,
+	type TArray,
+	type TBoolean,
+	type TInteger,
+	type TIntersect,
+	type TLiteral,
+	type TNot,
+	type TNull,
+	type TNumber,
+	type TObject,
+	type TRecord,
+	type TRef,
+	type TRegExp,
+	type TSchema,
+	type TString,
+	type TTuple,
+	type TUnion
+} from '@sinclair/typebox'
+import type { TNullable } from '../Utils.js'
+import type {
+	TDiscriminatedUnion,
+	TDiscriminatorMap
+} from '../utils/DiscriminatedUnion.js'
+import type { TUnionEnum } from '../utils/UnionEnum.js'
+import type { TUnionOneOf } from '../utils/UnionOneOf.js'
+
+export const SchemaKind = [
+	'Array',
+	'Boolean',
+	'Integer',
+	'Intersect',
+	'Literal',
+	'Null',
+	'Number',
+	'Object',
+	'Record',
+	'Ref',
+	'String',
+	'Tuple',
+	'Union',
+	'RegExp',
+	'Not',
+	// custom types
+	'UnionOneOf',
+	'UnionEnum',
+	'DiscriminatedUnion',
+	'Nullable'
+] as const
+
+interface SchemaKindMap extends Record<SchemaKind, TSchema> {
+	Array: TArray
+	Boolean: TBoolean
+	Integer: TInteger
+	Intersect: TIntersect
+	Literal: TLiteral
+	Null: TNull
+	Number: TNumber
+	Object: TObject
+	Record: TRecord
+	Ref: TRef
+	String: TString
+	Tuple: TTuple
+	Union: TUnion
+	RegExp: TRegExp
+	Not: TNot
+	// custom types
+	UnionOneOf: TUnionOneOf<TSchema[]>
+	UnionEnum: TUnionEnum
+	DiscriminatedUnion: TDiscriminatedUnion<TDiscriminatorMap, string>
+	Nullable: TNullable
+}
+
+export type SchemaKind = (typeof SchemaKind)[number]
+
+export type SchemaTransform<T> = (schema: T, options: SchemaOptions) => T
+
+export type SchemaTransforms = {
+	[P in SchemaKind]: SchemaTransform<SchemaKindMap[P]>
+}
+
+export const SchemaTransforms = Object.fromEntries(
+	SchemaKind.map((kind) => [
+		kind,
+		(schema: SchemaKindMap[typeof kind], options: SchemaOptions) =>
+			CloneType(schema, options)
+	])
+) as SchemaTransforms

package/schema-source/schema/root/SourceData.ts

@@ -0,0 +1,151 @@
+import {
+	CloneType,
+	Kind,
+	type SchemaOptions,
+	type TArray,
+	type TIntersect,
+	type TNull,
+	type TObject,
+	type TRecord,
+	type TSchema,
+	type TTuple,
+	type TUnion
+} from '@sinclair/typebox'
+import { mapValues, omit } from 'lodash-es'
+import type { TNullable } from '../Utils.js'
+import {
+	ComputedPropertyBrand,
+	GetSourceDataSchema,
+	SourceOptionalBrand
+} from '../utils/Computed.js'
+import type { TDiscriminatedUnion } from '../utils/DiscriminatedUnion.js'
+import { SetOptional } from '../utils/SetOptional.js'
+import { keysWithDefaults } from '../utils/typebox.js'
+import type { TUnionOneOf } from '../utils/UnionOneOf.js'
+import { NiceSchema } from './NiceSchema.js'
+import { type SchemaKind, SchemaTransforms } from './SchemaTransform.js'
+
+/**
+ * Transform a schema into the more lenient format used for Datasworn source data.
+ */
+export function SourceData<T extends TSchema>(
+	schema: T,
+	options: SchemaOptions = {}
+) {
+	const schemaKind = schema[Kind] as SchemaKind
+
+	let baseSchema: TSchema
+
+	if (GetSourceDataSchema in schema) {
+		const getter = schema[GetSourceDataSchema] as (s: T) => TSchema
+		baseSchema = getter(schema)
+	} else baseSchema = schema
+
+	const transform = transforms[schemaKind]
+	if (typeof transform === 'undefined')
+		throw new Error(`No transform available for Kind: ${baseSchema[Kind]}`)
+
+	const result = NiceSchema(transform(baseSchema as any, options))
+
+	return result
+}
+
+const transforms: SchemaTransforms = {
+	...SchemaTransforms,
+	Array: <T extends TArray>(schema: T, options: SchemaOptions) => {
+		const result = CloneType(schema, options)
+		result.items = SourceData(result.items)
+		return result
+	},
+
+	Intersect: <T extends TIntersect>(schema: T, options: SchemaOptions) => {
+		const result = CloneType(schema, options)
+		result.allOf = result.allOf.map((v) => SourceData(v))
+
+		return result
+	},
+
+	Object: <T extends TObject>(schema: T, options: SchemaOptions) => {
+		const optionalProps = keysWithDefaults(schema)
+
+		for (const [key, property] of Object.entries<any>(schema.properties))
+			if (property[ComputedPropertyBrand] || property[SourceOptionalBrand])
+				optionalProps.push(key as any)
+
+		if (optionalProps.length === 0) return CloneType(schema, options)
+
+		const base = SetOptional(schema, optionalProps)
+
+		const nuOptions = omit(
+			CloneType(schema, options),
+			...Object.keys(base),
+			'required'
+		)
+
+		const result = CloneType(base, nuOptions) as T // defaults arent part of the type data, so it's close enough
+
+		return result
+	},
+
+	Record: <T extends TRecord>(schema: T, options: SchemaOptions) => {
+		const newSchema = CloneType(schema, options)
+
+		newSchema.patternProperties = mapValues(newSchema.patternProperties, (v) =>
+			SourceData(v)
+		)
+
+		return newSchema
+	},
+
+	Tuple: <T extends TTuple>(schema: T, options: SchemaOptions) => {
+		const result = CloneType(schema, options)
+
+		if (Array.isArray(result.items))
+			result.items = result.items.map((item) => SourceData(item))
+
+		return result
+	},
+	Union: <T extends TUnion>(schema: T, options: SchemaOptions) => {
+		const result = CloneType(schema, options)
+
+		result.anyOf = result.anyOf.map((item) => SourceData(item))
+
+		return result
+	},
+
+	Nullable: <T extends TNullable>(schema: T, options: SchemaOptions) => {
+		const result = CloneType(schema, options)
+
+		result.anyOf = result.anyOf.map((item) => SourceData(item)) as [
+			TSchema,
+			TNull
+		]
+
+		return result
+	},
+	UnionOneOf: <T extends TUnionOneOf<TSchema[]>>(
+		schema: T,
+		options: SchemaOptions
+	) => {
+		const result = CloneType(schema, options)
+
+		result.oneOf = result.oneOf.map((item) => SourceData(item))
+
+		return result
+	},
+	DiscriminatedUnion: (<T extends TDiscriminatedUnion<any, string>>(
+		schema: T,
+		options: SchemaOptions
+	) => {
+		const result = CloneType(schema, options)
+
+		result.allOf = result.allOf.map((ifThen) => ({
+			...ifThen,
+			// biome-ignore lint/suspicious/noThenProperty: required for JSON Schema if-then-else
+			then: SourceData(ifThen.then)
+		})) as any[]
+		// result.oneOf = result.oneOf.map((member) => SourceData(member)) as any
+
+		return result
+	}) as any
+}

package/schema-source/schema/rules/ConditionMeterRule.ts

@@ -0,0 +1,25 @@
+import { type Static, Type } from '@sinclair/typebox'
+import { Meter } from '../common/Inputs.js'
+import { MarkdownString } from '../common/Text.js'
+import { Assign } from '../utils/FlatIntersect.js'
+import { Tags } from './TagRule.js'
+
+export const ConditionMeterRule = Assign(
+	Type.Object({
+		description: Type.Ref(MarkdownString, {
+			description: 'A description of this condition meter.'
+		}),
+		shared: Type.Boolean({
+			default: false,
+			description: 'Is this condition meter shared by all players?'
+		}),
+		tags: Type.Optional(Type.Ref(Tags, { releaseStage: 'experimental' }))
+	}),
+	Meter(Type.Literal(true)),
+	{
+		$id: 'ConditionMeterRule',
+		description: 'Describes a standard player character condition meter.'
+	}
+)
+
+export type ConditionMeterRule = Static<typeof ConditionMeterRule>

package/schema-source/schema/rules/ImpactRule.ts

@@ -0,0 +1,54 @@
+import { type Static, Type } from '@sinclair/typebox'
+import { ConditionMeterKey } from '../common/Player.js'
+import { Label, MarkdownString } from '../common/Text.js'
+import { Dictionary } from '../generic/Dictionary.js'
+import { Tags } from './TagRule.js'
+
+export const ImpactRule = Type.Object(
+	{
+		label: Type.Ref(Label, {
+			description: 'The label for this impact.'
+		}),
+		description: Type.Ref(MarkdownString, {
+			description: 'A description of this impact.'
+		}),
+		shared: Type.Boolean({
+			default: false,
+			description: 'Is this impact applied to all players at once?'
+		}),
+		prevents_recovery: Type.Array(Type.Ref(ConditionMeterKey), {
+			default: [],
+			description:
+				"Any ruleset condition meters that can't recover when this impact is active."
+		}),
+		permanent: Type.Boolean({
+			default: false,
+			description: 'Is this impact permanent?'
+		}),
+		tags: Type.Optional(Type.Ref(Tags, { releaseStage: 'experimental' }))
+	},
+	{
+		$id: 'ImpactRule',
+		description: 'Describes a standard impact/debility.'
+	}
+)
+export type ImpactRule = Static<typeof ImpactRule>
+
+export const ImpactCategory = Type.Object(
+	{
+		label: Type.Ref(Label, {
+			description: 'A label for this impact category.'
+		}),
+		description: Type.Ref(MarkdownString, {
+			description: 'A description of this impact category.'
+		}),
+		contents: Dictionary(Type.Ref(ImpactRule), {
+			description: 'A dictionary object of the Impacts in this category.'
+		})
+	},
+	{
+		$id: 'ImpactCategory',
+		description: 'Describes a category of standard impacts/debilities.'
+	}
+)
+export type ImpactCategory = Static<typeof ImpactCategory>

package/schema-source/schema/rules/SpecialTrackRule.ts

@@ -0,0 +1,29 @@
+import { type Static, Type } from '@sinclair/typebox'
+import { Label, MarkdownString } from '../common/Text.js'
+import { Tags } from './TagRule.js'
+
+export const SpecialTrackRule = Type.Object(
+	{
+		label: Type.Ref(Label, {
+			description: 'A label for this special track.'
+		}),
+		description: Type.Ref(MarkdownString, {
+			description: 'A description of this special track.'
+		}),
+		shared: Type.Boolean({
+			default: false,
+			description: 'Is this track shared by all players?'
+		}),
+		optional: Type.Boolean({
+			default: false,
+			description: 'Is this track an optional rule?'
+		}),
+		tags: Type.Optional(Type.Ref(Tags, { releaseStage: 'experimental' }))
+	},
+	{
+		$id: 'SpecialTrackRule',
+		description:
+			'Describes a special track like Bonds (classic Ironsworn), Failure (Delve), or Legacies (Starforged).'
+	}
+)
+export type SpecialTrackRule = Static<typeof SpecialTrackRule>

package/schema-source/schema/rules/StatRule.ts

@@ -0,0 +1,23 @@
+import { type Static, Type } from '@sinclair/typebox'
+
+import { Label, MarkdownString } from '../common/Text.js'
+import { Tags } from './TagRule.js'
+
+export const StatRule = Type.Object(
+	{
+		label: Type.Ref(Label, {
+			description: 'A label for this stat.',
+			examples: ['edge']
+		}),
+		description: Type.Ref(MarkdownString, {
+			description: 'A description of this stat.',
+			examples: ['Quickness, agility, and prowess when fighting at a distance.']
+		}),
+		tags: Type.Optional(Type.Ref(Tags, { releaseStage: 'experimental' }))
+	},
+	{
+		$id: 'StatRule',
+		description: 'Describes a standard player character stat.'
+	}
+)
+export type StatRule = Static<typeof StatRule>