@datasworn-community/build-tools 0.2.0

package/schema-source/schema/delve/DelveSiteTheme.ts

@@ -0,0 +1,97 @@
+import { type Static, Type } from '@sinclair/typebox'
+import { toJtdElements } from '../../scripts/json-typedef/utils.js'
+import { MarkdownString } from '../common/Text.js'
+import { NonCollectableNode } from '../generic/NonCollectableNode.js'
+import { OracleRollableRowText, StaticRowPartial } from '../oracles/TableRow.js'
+import { JsonTypeDef } from '../Symbols.js'
+import { setSourceDataSchema } from '../Utils.js'
+import { EmbeddedType } from './common.js'
+
+export const DelveSiteThemeFeature = EmbeddedType(
+	OracleRollableRowText,
+	'delve_site_theme',
+	'feature',
+
+	{
+		description:
+			'Represents a single Feature entry from a delve site Theme card.'
+	}
+)
+
+export const DelveSiteThemeDanger = EmbeddedType(
+	OracleRollableRowText,
+	'delve_site_theme',
+	'danger',
+
+	{
+		description:
+			'Represents a single Danger entry from a delve site Theme card.'
+	}
+)
+
+const DelveSiteThemeFeatures = Type.Array(Type.Ref(DelveSiteThemeFeature))
+const DelveSiteThemeDangers = Type.Array(Type.Ref(DelveSiteThemeDanger))
+
+export const DelveSiteTheme = setSourceDataSchema(
+	NonCollectableNode(
+		Type.Object({
+			summary: Type.Ref(MarkdownString, {
+				description: 'The text that appears below the title on the card.'
+			}),
+			descriptipn: Type.Optional(
+				Type.Ref(MarkdownString, {
+					description: 'Optional extended description text.'
+				})
+			),
+			features: Type.Intersect(
+				[
+					DelveSiteThemeFeatures,
+					Type.Tuple([
+						StaticRowPartial(1, 4),
+						StaticRowPartial(5, 8),
+						StaticRowPartial(9, 12),
+						StaticRowPartial(13, 16),
+						StaticRowPartial(17, 20)
+					])
+				],
+				{
+					[JsonTypeDef]: {
+						schema: toJtdElements(DelveSiteThemeFeatures)
+					}
+				}
+			),
+			dangers: Type.Intersect(
+				[
+					DelveSiteThemeDangers,
+					Type.Tuple([
+						StaticRowPartial(1, 5),
+						StaticRowPartial(6, 10),
+						StaticRowPartial(11, 12),
+						StaticRowPartial(13, 14),
+						StaticRowPartial(15, 16),
+						StaticRowPartial(17, 18),
+						StaticRowPartial(19, 20),
+						StaticRowPartial(21, 22),
+						StaticRowPartial(23, 24),
+						StaticRowPartial(25, 26),
+						StaticRowPartial(27, 28),
+						StaticRowPartial(29, 30)
+					])
+				],
+				{
+					[JsonTypeDef]: {
+						schema: toJtdElements(DelveSiteThemeDangers)
+					}
+				}
+			)
+		}),
+		'delve_site_theme',
+		{
+			description: 'A delve site theme card.',
+			$id: 'DelveSiteTheme'
+		}
+	),
+	(schema) => ({ ...schema, additionalProperties: false })
+)
+export type DelveSiteTheme = Static<typeof DelveSiteTheme>
+export type TDelveSiteTheme = typeof DelveSiteTheme

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

@@ -0,0 +1,32 @@
+import {
+	CloneType,
+	type ObjectOptions,
+	type TObject,
+	type TString,
+	Type
+} from '@sinclair/typebox'
+import type TypeId from '../../pkg-core/IdElements/TypeId.js'
+import { Computed } from '../Utils.js'
+import { pascalCase } from '../utils/string.js'
+
+export function EmbeddedType<
+	TBase extends TObject,
+	T extends TypeId.Embedding,
+	T2 extends TypeId.EmbeddableIn<T>
+>(
+	base: TBase,
+	parentTypeId: T,
+	embeddedTypeId: T2,
+	options: ObjectOptions = {}
+) {
+	const schemaName = pascalCase(parentTypeId) + pascalCase(embeddedTypeId)
+	const idSchemaName = `${schemaName}Id`
+
+	const schema = CloneType(base, options)
+
+	schema.$id = schemaName
+	schema.properties._id = Computed(Type.Ref(idSchemaName))
+
+	// @ts-expect-error
+	return schema as TObject<TBase['properties'] & { _id: TString }>
+}

package/schema-source/schema/entities/EntityPrompt.ts

@@ -0,0 +1,13 @@
+import { type Static, Type } from '@sinclair/typebox'
+import * as Text from '../common/Text.js'
+
+export const EntityPrompt = Type.Object(
+	{ text: Type.Ref(Text.MarkdownString) },
+	{
+		$id: 'EntityPrompt',
+		description:
+			'This type is a placeholder and may see signficant changes in v0.2.0.',
+		releaseStage: 'experimental'
+	}
+)
+export type EntityPrompt = Static<typeof EntityPrompt>

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

@@ -0,0 +1 @@
+export * from './EntityPrompt.js'

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

@@ -0,0 +1,75 @@
+import { CloneType, type ObjectOptions, type TObject } from '@sinclair/typebox'
+import type { SetRequired } from 'type-fest'
+import type TypeId from '../../pkg-core/IdElements/TypeId.js'
+import { setSourceDataSchema } from '../Utils.js'
+import { pascalCase } from '../utils/string.js'
+import { PrimarySubtypeNode, PrimaryTypeNode } from './PrimaryTypeNode.js'
+
+export const CollectableBrand = Symbol('Collectable')
+
+type TCollectableBranded<TBase extends TObject> = TBase & {
+	[CollectableBrand]: 'Collectable'
+}
+
+export function CollectableNode<
+	TBase extends TObject,
+	TType extends TypeId.Collectable
+>(base: TBase, type: TType, options: ObjectOptions = {}) {
+	const $id = pascalCase(type)
+
+	const enhancedBase = PrimaryTypeNode(base, type, {
+		$id,
+		...options,
+		[CollectableBrand]: 'Collectable'
+	})
+
+	return setSourceDataSchema(enhancedBase, (schema: TObject) => ({
+		...CloneType(schema),
+		additionalProperties: true
+	})) as unknown as TCollectableNode<TBase, TType>
+}
+
+/** Simplified type to avoid deep instantiation - uses TObject as base */
+export type TCollectableNode<
+	TBase extends TObject = TObject,
+	TType extends TypeId.Collectable = TypeId.Collectable
+> = TObject & TCollectableBranded<TObject> & { _type: TType; _base: TBase }
+
+export type CollectableNode<
+	TBase extends object,
+	TType extends TypeId.Collectable
+> = PrimaryTypeNode<TBase, TType>
+
+/** Simplified type to avoid deep instantiation */
+export type TCollectableSubtypeNode<
+	TBase extends TObject = TObject,
+	TType extends TypeId.Collectable = TypeId.Collectable,
+	TSubtypeKey extends string = string,
+	TSubtype extends string = string
+> = TCollectableNode<TBase, TType> & {
+	_subtypeKey: TSubtypeKey
+	_subtype: TSubtype
+}
+
+export function CollectableSubtypeNode<
+	TBase extends TObject,
+	TType extends TypeId.Collectable,
+	TSubtypeKey extends string,
+	TSubtype extends string
+>(
+	base: TBase,
+	type: TType,
+	subtypeKey: TSubtypeKey,
+	subtype: TSubtype,
+	options: SetRequired<ObjectOptions, '$id'>
+) {
+	const enhancedBase = PrimarySubtypeNode(base, type, subtypeKey, subtype, {
+		...options,
+		[CollectableBrand]: 'Collectable'
+	})
+
+	return setSourceDataSchema(enhancedBase, (schema: TObject) => ({
+		...CloneType(schema),
+		additionalProperties: true
+	})) as unknown as TCollectableSubtypeNode<TBase, TType, TSubtypeKey, TSubtype>
+}

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

@@ -0,0 +1,145 @@
+import {
+	type ObjectOptions,
+	type Static,
+	type TObject,
+	type TRef,
+	type TRefUnsafe,
+	type TSchema,
+	type TUnion,
+	Type
+} from '@sinclair/typebox'
+import type { SetRequired } from 'type-fest'
+import TypeId from '../../pkg-core/IdElements/TypeId.js'
+import {
+	CollectionsKey,
+	ContentsKey,
+	EnhancesKey
+} from '../../scripts/const.js'
+import * as Text from '../common/Text.js'
+import { setSourceOptional } from '../Utils.js'
+import { Assign } from '../utils/FlatIntersect.js'
+import { pascalCase } from '../utils/string.js'
+import { Dictionary, type TDictionary } from './Dictionary.js'
+import { PrimarySubtypeNode, PrimaryTypeNode } from './PrimaryTypeNode.js'
+
+export const CollectionBrand = Symbol('Collection')
+
+type TCollectionDictionary =
+	| TDictionary<TRef | TRefUnsafe<TSchema> | TUnion<TRef[]>>
+	| TUnion<TDictionary<TRef | TRefUnsafe<TSchema> | TUnion<TRef[]>>[]>
+
+export function getCollectionNodeMetadata(
+	enhances: TRef<string>,
+	contentChild?: TCollectionDictionary,
+	collectionChild?: TCollectionDictionary
+) {
+	const props: Record<string, TSchema> = {
+		[EnhancesKey]: Type.Optional(
+			Type.Array(enhances, {
+				description:
+					"This node's content enhances all nodes that match these wildcards, rather than being a standalone item of its own."
+			})
+		),
+		summary: Type.Optional(
+			Type.Ref(Text.MarkdownString, {
+				description:
+					'A brief summary of this collection, 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(Text.MarkdownString, {
+				description:
+					"A longer description of this collection, which might include multiple paragraphs. If it's only a couple sentences, use the `summary` key instead."
+			})
+		)
+	}
+
+	if (contentChild != null) props[ContentsKey] = contentChild
+
+	if (collectionChild != null) props[CollectionsKey] = collectionChild
+
+	return Type.Object(props)
+}
+
+export function CollectionNode<
+	TBase extends TObject,
+	TType extends TypeId.Collection
+>(base: TBase, type: TType, options: ObjectOptions = {}) {
+	const collectableTypeId = TypeId.getCollectableOf(type)
+	const collectableSchemaRef = Type.Ref(pascalCase(collectableTypeId))
+	const thisSchemaId = pascalCase(type)
+	const thisIdSchemaId = `${thisSchemaId}Id`
+
+	const thisWildcardIdRef = Type.Ref(`${thisIdSchemaId}Wildcard`)
+	const _thisIdRef = Type.Ref(thisIdSchemaId)
+	const thisSchemaRef = Type.Ref(thisSchemaId)
+
+	// Use explicit TObject casts to avoid deep type instantiation
+	const metadata = getCollectionNodeMetadata(
+		thisWildcardIdRef,
+		setSourceOptional(Dictionary(collectableSchemaRef)),
+		setSourceOptional(Dictionary(thisSchemaRef))
+	)
+	const enhancedBase: TObject = Assign(
+		metadata as TObject,
+		base as TObject
+	) as TObject
+
+	return PrimaryTypeNode(enhancedBase, type, {
+		...options,
+		$id: thisSchemaId,
+		[CollectionBrand]: 'Collection'
+	}) as unknown as TCollectionNode<TBase, TType>
+}
+
+type TCollectionMeta = ReturnType<typeof getCollectionNodeMetadata>
+type CollectionMeta = Static<TCollectionMeta>
+
+export type CollectionNode<
+	TBase extends object,
+	TType extends TypeId.Collection
+> = PrimaryTypeNode<TBase & CollectionMeta, TType>
+
+/** Simplified type to avoid deep instantiation */
+export type TCollectionNode<
+	TBase extends TObject = TObject,
+	TType extends TypeId.Collection = TypeId.Collection
+> = TObject & {
+	$id: string
+	[CollectionBrand]: 'Collection'
+	_collectionType: TType
+	_collectionBase: TBase
+}
+
+export function CollectionSubtypeNode<
+	TBase extends TObject,
+	TType extends TypeId.Collection,
+	TSubtypeKey extends string,
+	TSubtype extends string
+>(
+	base: TBase,
+	type: TType,
+	subtypeKey: TSubtypeKey,
+	subtype: TSubtype,
+	contents: TCollectionDictionary | undefined,
+	collections: TCollectionDictionary | undefined,
+	options: SetRequired<ObjectOptions, '$id'>
+) {
+	const baseSchemaName = pascalCase(type)
+	const _thisSchemaName = baseSchemaName + pascalCase(subtype)
+
+	const thisIdWildcardRef = Type.Ref(`${baseSchemaName}IdWildcard`)
+
+	// Use explicit TObject casts to avoid deep type instantiation
+	const metadata = getCollectionNodeMetadata(
+		thisIdWildcardRef,
+		contents,
+		collections
+	)
+	const enhancedBase: TObject = Assign(
+		metadata as TObject,
+		base as TObject
+	) as TObject
+
+	return PrimarySubtypeNode(enhancedBase, type, subtypeKey, subtype, options)
+}

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

@@ -0,0 +1,39 @@
+import {
+	type ObjectOptions,
+	type TRecord,
+	type TSchema,
+	type TString,
+	Type
+} from '@sinclair/typebox'
+import Id from '../common/Id.js'
+
+export const DictionaryBrand = Symbol('Dictionary')
+
+/**
+ *
+ * @param schema The schema to use as the dictionary value.
+ * @param key The schema to use as the dictionary key (default: Id.DictKey)
+ * @param options Any object options to apply to this schema.
+ */
+export function Dictionary<T extends TSchema>(
+	schema: T,
+	{ key, ...options }: { key?: TString } & ObjectOptions = { key: Id.DictKey }
+) {
+	const dict =
+		// Type.Transform(
+		Type.Record(key ?? Id.DictKey, schema, {
+			default: {},
+			remarks: 'Deserialize as a dictionary object.',
+			[DictionaryBrand]: 'Dictionary',
+			...options
+		}) as TDictionary<T>
+	// )
+	// .Decode((value) => new Map<string, Static<T>>(Object.entries(value)))
+	// .Encode((value) => Object.fromEntries(Array.from(value.entries())))
+
+	return dict
+}
+export type TDictionary<T extends TSchema = TSchema> = TRecord<TString, T> & {
+	[DictionaryBrand]: 'Dictionary'
+}
+export type Dictionary<T> = Record<string, T>

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

@@ -0,0 +1,19 @@
+import { type ObjectOptions, type TObject, Type } from '@sinclair/typebox'
+import type TypeId from '../../pkg-core/IdElements/TypeId.js'
+import { pascalCase } from '../utils/string.js'
+import { IdNode } from './IdNode.js'
+
+export function EmbedOnlyNode<
+	TBase extends TObject,
+	TType extends TypeId.EmbedOnly,
+	TParentType extends TypeId.CanEmbedType<TType>
+>(
+	base: TBase,
+	typeId: TType,
+	parentType: TParentType,
+	options: ObjectOptions = {}
+) {
+	const $id = pascalCase(parentType) + pascalCase(typeId)
+	const idSchemaName = `${$id}Id`
+	return IdNode(base, Type.Ref(idSchemaName), { $id, ...options })
+}

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

@@ -0,0 +1,38 @@
+import {
+	type ObjectOptions,
+	type TObject,
+	type TSchema,
+	type TString,
+	Type
+} from '@sinclair/typebox'
+import { EnhancesKey } from '../../scripts/const.js'
+import * as Utils from '../Utils.js'
+import { Assign } from '../utils/FlatIntersect.js'
+
+/**
+ * Enhances multiple rules elements
+ */
+
+export function EnhanceMany<T extends TObject, ID extends TSchema = TString>(
+	schema: T,
+	wildcardID: ID,
+	options: ObjectOptions = {}
+) {
+	const base = Utils.OmitMeta(schema) as TObject
+	const mixin = Type.Object({
+		[EnhancesKey]: Utils.Nullable(Type.Array(wildcardID), {
+			description:
+				'An array of wildcard IDs. An item must match one of the wildcard IDs to receive this enhancement. If this is `null`, any ID is valid.',
+			default: null
+		})
+	})
+	return Assign(mixin, base, options)
+}
+export type TEnhanceMany<
+	T extends TObject,
+	ID extends TSchema = TString
+> = ReturnType<typeof EnhanceMany<T, ID>>
+
+export type EnhanceMany<T, WildcardID = string> = Utils.OmitMeta<T> & {
+	[EnhancesKey]?: WildcardID[]
+}

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

@@ -0,0 +1,40 @@
+import {
+	Kind,
+	type ObjectOptions,
+	type Static,
+	type TObject,
+	Type
+} from '@sinclair/typebox'
+import type { TAnyId } from '../common/Id.js'
+import { Documentation } from '../common/Text.js'
+import { Computed } from '../Utils.js'
+import { FlatIntersect } from '../utils/FlatIntersect.js'
+import { setDescriptions } from '../utils/typebox.js'
+
+const IdNodeBase = Type.Object({
+	_id: Computed(Type.String()),
+	_comment: Type.Optional(Type.Ref(Documentation))
+})
+
+export function IdNode<TBase extends TObject>(
+	base: TBase,
+	_id: TAnyId,
+	options: ObjectOptions = {}
+) {
+	const enhancedBase = FlatIntersect(
+		[IdNodeBase, Type.Object({ _id: Computed(_id) }), base],
+		{
+			[Kind]: 'Object',
+			...options
+		}
+	)
+
+	return setDescriptions(enhancedBase, {
+		_id: 'The unique Datasworn ID for this node.'
+	})
+}
+export type TIdNode<TBase extends TObject> = ReturnType<
+	typeof IdNode<TBase>
+> & { static: IdNode<Static<TBase>> }
+
+export type IdNode<TBase extends object> = TBase & Static<typeof IdNodeBase>

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

@@ -0,0 +1,11 @@
+import { Type } from '@sinclair/typebox'
+import * as Text from '../common/Text.js'
+
+export const Cyclopedia = Type.Object({
+	name: Type.Ref(Text.Label),
+	features: Type.Array(Type.Ref(Text.MarkdownString)),
+	summary: Type.Optional(Type.Ref(Text.MarkdownString)),
+	description: Type.Ref(Text.MarkdownString),
+	quest_starter: Type.Optional(Type.Ref(Text.MarkdownString)),
+	your_truth: Type.Optional(Type.Ref(Text.MarkdownString))
+})

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

@@ -0,0 +1,38 @@
+import type { ObjectOptions, TObject } from '@sinclair/typebox'
+import type TypeId from '../../pkg-core/IdElements/TypeId.js'
+import { setSourceDataSchema } from '../Utils.js'
+import { pascalCase } from '../utils/string.js'
+import { PrimaryTypeNode } from './PrimaryTypeNode.js'
+
+export const NonCollectableBrand = Symbol('NonCollectable')
+
+export function NonCollectableNode<
+	TBase extends TObject,
+	TType extends TypeId.NonCollectable
+>(base: TBase, type: TType, options: ObjectOptions = {}) {
+	const $id = pascalCase(type)
+	const enhancedBase = PrimaryTypeNode(base, type, {
+		$id,
+		[NonCollectableBrand]: 'NonCollectable',
+		...options
+	})
+	return setSourceDataSchema(enhancedBase, (schema) => ({
+		...schema,
+		additionalProperties: true
+	})) as unknown as TNonCollectableNode<TBase, TType>
+}
+
+/** Simplified type to avoid deep instantiation */
+export type TNonCollectableNode<
+	TBase extends TObject = TObject,
+	TType extends TypeId.NonCollectable = TypeId.NonCollectable
+> = TObject & {
+	[NonCollectableBrand]: 'NonCollectable'
+	_type: TType
+	_base: TBase
+}
+
+export type NonCollectableNode<
+	TBase extends object,
+	TType extends TypeId.NonCollectable
+> = PrimaryTypeNode<TBase, TType>

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

@@ -0,0 +1,115 @@
+import {
+	type ObjectOptions,
+	type TObject,
+	type TRef,
+	type TString,
+	Type
+} from '@sinclair/typebox'
+import type { SetRequired } from 'type-fest'
+import type TypeId from '../../pkg-core/IdElements/TypeId.js'
+import { CssColor, SvgImageUrl, WebpImageUrl } from '../common/Metadata.js'
+import { SourcedNode } from '../generic/SourcedNode.js'
+import { Discriminable } from '../Utils.js'
+import { Assign } from '../utils/FlatIntersect.js'
+import { pascalCase } from '../utils/string.js'
+
+const replacesDescription =
+	'This node replaces all nodes that match these wildcards. References to the replaced nodes can be considered equivalent to this node.'
+const PrimaryNodeBase = Type.Object({
+	replaces: Type.Optional(
+		Type.Array(Type.String() as TString | TRef<string>, {
+			description: replacesDescription
+		})
+	),
+	color: Type.Optional(
+		Type.Ref(CssColor, {
+			description:
+				'An optional thematic color associated with this node. For an example, see "Basic Creature Form" (Starforged p. 337).'
+		})
+	),
+	images: Type.Optional(
+		Type.Array(
+			Type.Ref(WebpImageUrl, {
+				description: 'Extra images associated with this node.'
+			})
+		)
+	),
+	icon: Type.Optional(
+		Type.Ref(SvgImageUrl, {
+			description: 'An SVG icon associated with this collection.'
+		})
+	)
+})
+
+export function PrimaryTypeNode<
+	TBase extends TObject,
+	TType extends TypeId.Primary
+>(base: TBase, type: TType, options: ObjectOptions = {}) {
+	const _id = Type.Ref(`${pascalCase(type)}Id`)
+
+	const replaces = Type.Ref(`${pascalCase(type)}IdWildcard`)
+
+	// Explicit TObject type to avoid deep type chain
+	const replacesObj = Type.Object({
+		replaces: Type.Optional(
+			Type.Array(replaces, { description: replacesDescription })
+		)
+	})
+	const mixin: TObject = Assign(
+		PrimaryNodeBase as TObject,
+		replacesObj as TObject
+	) as TObject
+
+	// Use explicit TObject casts to break deep type chain
+	const merged: TObject = Assign(mixin, base as TObject) as TObject
+	const enhancedBase: TObject = Discriminable(merged, 'type', type) as TObject
+
+	return SourcedNode(enhancedBase, _id, options) as unknown as TPrimaryTypeNode<
+		TBase,
+		TType
+	>
+}
+
+/** Simplified type to avoid deep instantiation */
+export type TPrimaryTypeNode<
+	TBase extends TObject = TObject,
+	TType extends TypeId.Primary = TypeId.Primary
+> = TObject & { _primaryType: TType; _primaryBase: TBase }
+
+export type PrimaryTypeNode<
+	TBase extends object,
+	TType extends TypeId.Primary
+> = SourcedNode<Discriminable<'type', TType, TBase>>
+
+export function PrimarySubtypeNode<
+	TBase extends TObject,
+	TType extends TypeId.Primary,
+	TSubtypeKey extends string,
+	TSubtype extends string
+>(
+	base: TBase,
+	type: TType,
+	subtypeKey: TSubtypeKey,
+	subtype: TSubtype,
+	options: SetRequired<ObjectOptions, '$id'>
+) {
+	const superType = PrimaryTypeNode(base, type)
+
+	return Discriminable(
+		superType,
+		subtypeKey,
+		subtype,
+		options
+	) as unknown as TPrimarySubtypeNode<TBase, TType, TSubtypeKey, TSubtype>
+}
+
+/** Simplified type to avoid deep instantiation */
+export type TPrimarySubtypeNode<
+	TBase extends TObject = TObject,
+	TType extends TypeId.Primary = TypeId.Primary,
+	TSubtypeKey extends string = string,
+	TSubtype extends string = string
+> = TPrimaryTypeNode<TBase, TType> & {
+	_subtypeKey: TSubtypeKey
+	_subtype: TSubtype
+}