@datasworn-community/build-tools 0.2.0

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

@@ -0,0 +1,22 @@
+import { type TObject, type TOmit, Type } from '@sinclair/typebox'
+import { IdKey, SourceInfoKey } from '../../scripts/const.js'
+
+const MetaKeys = [
+	IdKey,
+	SourceInfoKey,
+	'rendering',
+	'name',
+	'suggestions',
+	'canonical_name',
+	'color'
+] as const
+type MetaKeys = (typeof MetaKeys)[number]
+/**
+ * Omits common metadata and localization keys.
+ */
+
+export function OmitMeta<T extends TObject>(schema: T) {
+	return Type.Omit(schema, MetaKeys)
+}
+export type OmitMeta<T> = Omit<T, MetaKeys>
+export type TOmitMeta<T extends TObject> = TOmit<T, MetaKeys[]>

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

@@ -0,0 +1,27 @@
+import {
+	CloneType,
+	type ObjectOptions,
+	type TObject,
+	type TOptional,
+	type TSchema,
+	Type,
+	TypeGuard
+} from '@sinclair/typebox'
+import { omitBy } from 'lodash-es'
+import type { ConditionalExcept, OptionalKeysOf } from 'type-fest'
+
+export type OmitOptional<T extends object> = Omit<T, OptionalKeysOf<T>>
+
+export type TOmitOptional<T extends TObject> = TObject<
+	ConditionalExcept<T['properties'], TOptional<TSchema>>
+>
+export function OmitOptional<T extends TObject>(
+	schema: T,
+	options: ObjectOptions = {}
+) {
+	const base = CloneType(schema)
+
+	base.properties = omitBy(base.properties, (v) => TypeGuard.IsOptional(v))
+
+	return Type.Object(base.properties, options) as TOmitOptional<T>
+}

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

@@ -0,0 +1,26 @@
+import {
+	type SchemaOptions,
+	type Static,
+	type TObject,
+	Type
+} from '@sinclair/typebox'
+import { Assign, type TAssign } from './FlatIntersect.js'
+
+export type PartialExcept<T, K extends keyof T> = Pick<T, K> &
+	Partial<Omit<T, K>>
+
+export type TPartialExcept<
+	T extends TObject,
+	_K extends (keyof Static<T>)[]
+> = TAssign<TObject, TObject> // Simplified due to TComputed type issues
+/** Make everything optional except for the provided keys  */
+export function PartialExcept<
+	T extends TObject,
+	K extends Array<keyof Static<T>>
+>(schema: T, requiredKeys: [...K], options: SchemaOptions = {}) {
+	return Assign(
+		Type.Pick(schema, requiredKeys) as TObject,
+		Type.Partial(Type.Omit(schema, requiredKeys)) as TObject,
+		options
+	)
+}

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

@@ -0,0 +1,44 @@
+import {
+	CloneType,
+	type ObjectOptions,
+	type Static,
+	type TObject
+} from '@sinclair/typebox'
+import { Nullable, type TNullable } from './Nullable.js'
+import type { ObjectProperties } from './ObjectProperties.js'
+
+export function SetNullable<
+	T extends TObject,
+	K extends Array<keyof Static<T>>
+>(
+	schema: T,
+	keys: [...K],
+	{
+		defaultToNull = false,
+		...options
+	}: ObjectOptions & { defaultToNull?: boolean } = {}
+) {
+	// @ts-expect-error
+	const base = CloneType(schema, options) as TSetNullable<T, K>
+
+	const nullableOptions: ObjectOptions = {}
+
+	if (defaultToNull) nullableOptions.default = null
+
+	for (const key of keys as Array<keyof T['properties']>) {
+		if (!(key in base.properties)) continue
+		// @ts-expect-error
+		base.properties[key] = Nullable(base.properties[key], nullableOptions)
+	}
+
+	return base
+}
+
+export type TSetNullable<
+	T extends TObject,
+	K extends Array<keyof Static<T>>
+> = TObject<
+	Omit<ObjectProperties<T>, K[number]> & {
+		[P in K[number]]: TNullable<ObjectProperties<T>[P]>
+	}
+>

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

@@ -0,0 +1,48 @@
+import {
+	CloneType,
+	type ObjectOptions,
+	type Static,
+	type TObject,
+	Type,
+	TypeGuard
+} from '@sinclair/typebox'
+import { omit } from 'lodash-es'
+import type * as TypeFest from 'type-fest'
+import type { TAssign } from './FlatIntersect.js'
+
+export type SetOptional<
+	BaseType,
+	Keys extends keyof BaseType
+> = TypeFest.SetOptional<BaseType, Keys>
+
+export type TSetOptional<
+	T extends TObject,
+	_K extends (keyof Static<T>)[]
+> = TAssign<TObject, TObject> // Simplified due to TComputed type issues
+/** Make the provided keys optional */
+export function SetOptional<
+	T extends TObject,
+	K extends Array<keyof Static<T>>
+>(schema: T, optionalKeys: [...K], options: ObjectOptions = {}) {
+	const base = omit(CloneType(schema), ['$id']) as T
+
+	const toRemove: string[] = []
+
+	for (const k of optionalKeys as string[]) {
+		// skip if no such prop exists
+		if (base.properties[k] == null) continue
+		// skip if it's already optional
+		if (TypeGuard.IsOptional(base.properties[k])) continue
+		base.properties[k] = Type.Optional(base.properties[k])
+		// flag key for removal from "required" array
+		toRemove.push(k)
+	}
+
+	if (Array.isArray(base.required))
+		base.required = base.required.filter((k) => toRemove.includes(k))
+
+	return Type.Object(base.properties, {
+		...omit(base, ['properties', 'required']),
+		...options
+	})
+}

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

@@ -0,0 +1,82 @@
+// adapted from https://github.com/sinclairzx81/typebox/blob/master/examples/prototypes/union-enum.ts
+
+import {
+	CloneType,
+	Hint,
+	Kind,
+	type SchemaOptions,
+	type TEnum,
+	type TSchema,
+	Type,
+	TypeRegistry
+} from '@sinclair/typebox'
+import { isInteger, omit, set } from 'lodash-es'
+import { JsonTypeDef } from '../Symbols.js'
+
+export const EnumDescription = Symbol('EnumDescription')
+export const Description = Symbol('Description')
+
+export interface TUnionEnum<
+	T extends string[] | number[] | readonly string[] | readonly number[] =
+		| string[]
+		| number[]
+		| readonly string[]
+		| readonly number[]
+> extends TSchema {
+	[Kind]: 'UnionEnum'
+	[EnumDescription]: Record<T[number], string>
+	[Description]?: string | undefined
+	static: T[number]
+	enum: [...T]
+}
+
+export function UnionEnum<
+	T extends string[] | number[] | readonly string[] | readonly number[]
+>(literals: T, options: SchemaOptions = {}) {
+	if (!TypeRegistry.Has('UnionEnum'))
+		TypeRegistry.Set('UnionEnum', UnionEnumCheck)
+
+	const result = {
+		...options,
+		[Kind]: 'UnionEnum',
+		enum: [...literals]
+	} as TUnionEnum<T>
+
+	if (result.enum.every(isInteger) && result[JsonTypeDef])
+		set(result[JsonTypeDef], 'metadata.typescriptType', literals.join(' | '))
+	return result
+}
+
+export function TUnionEnum(schema: any): schema is TUnionEnum {
+	if (!Array.isArray(schema?.enum)) return false
+	return (
+		schema.enum.every((item: any) => typeof item === 'string') ||
+		schema.enum.every((item: any) => typeof item === 'number')
+	)
+}
+
+function UnionEnumCheck(schema: TUnionEnum<any>, value: unknown) {
+	return schema.enum.includes(value as string | number)
+}
+
+export function ToEnum<T extends TUnionEnum>(schema: T) {
+	const anyOf = schema.enum.map((value) =>
+		Type.Literal(value, { description: schema[EnumDescription]?.[value] })
+	)
+	const options = omit(CloneType(schema), [
+		Kind,
+		EnumDescription,
+		Description,
+		'static',
+		'enum'
+	])
+
+	const result = Type.Union(anyOf, {
+		...options,
+		description: schema[Description],
+
+		[Hint]: 'Enum'
+	}) as unknown as TEnum
+
+	return result
+}

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

@@ -0,0 +1,36 @@
+import type { SchemaOptions } from '@sinclair/typebox'
+import { map } from 'lodash-es'
+import {
+	Description,
+	EnumDescription,
+	type TUnionEnum,
+	UnionEnum
+} from './UnionEnum.js'
+
+export function UnionEnumFromRecord<K extends string>(
+	entries: Record<K, string>,
+	options?: SchemaOptions
+): TUnionEnum<K[]>
+export function UnionEnumFromRecord<T extends string[] | number[]>(
+	entries: Record<T[number], string>,
+	options: SchemaOptions = {}
+): TUnionEnum<T> {
+	const literals = Object.keys(entries).map((k) =>
+		Number.isInteger(Number(k)) ? Number(k) : k
+	) as T
+
+	let description = map(
+		entries,
+		(description, literal) => `  - \`${literal?.toString()}\`: ${description}`
+	).join('\n')
+
+	if (options.description)
+		description = `${options.description}\n\n${description}`
+
+	return UnionEnum(literals, {
+		[Description]: options.description,
+		[EnumDescription]: entries,
+		...options,
+		description
+	})
+}

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

@@ -0,0 +1,80 @@
+/** adapted from https://github.com/sinclairzx81/typebox/blob/master/examples/prototypes/union-oneof.ts */
+
+import {
+	Kind,
+	type SchemaOptions,
+	type Static,
+	type TSchema,
+	TypeRegistry
+} from '@sinclair/typebox'
+import { Value } from '@sinclair/typebox/value'
+import { Members } from '../Symbols.js'
+
+export interface TUnionOneOf<T extends TSchema[]> extends TSchema {
+	[Kind]: 'UnionOneOf'
+	static: { [K in keyof T]: Static<T[K]> }[number]
+	oneOf: T
+	[Members]: T // to make JTD inference easier
+}
+
+/** `[Experimental]` Creates a Union type with a `oneOf` schema representation */
+export function UnionOneOf<T extends TSchema[]>(
+	oneOf: [...T],
+	options: SchemaOptions = {}
+) {
+	function UnionOneOfCheck(schema: TUnionOneOf<TSchema[]>, value: unknown) {
+		return (
+			schema.oneOf.reduce(
+				(acc: number, schema: any) =>
+					Value.Check(schema, value) ? acc + 1 : acc,
+				0
+			) === 1
+		)
+	}
+	if (!TypeRegistry.Has('UnionOneOf'))
+		TypeRegistry.Set('UnionOneOf', UnionOneOfCheck)
+	return {
+		...options,
+		[Kind]: 'UnionOneOf',
+		[Members]: oneOf, // to make JTD inference easier
+		oneOf
+	} as TUnionOneOf<T>
+}
+
+// import { TypeSystem } from '@sinclair/typebox/system'
+// import { Value } from '@sinclair/typebox/value'
+// import { Members } from '../../../json-typedef/symbol.js'
+
+// const UnionOneOfKind = 'UnionOneOf'
+
+// TypeSystem.Type(UnionOneOfKind, UnionOneOfCheck)
+
+// function UnionOneOfCheck(schema: TUnionOneOf<TSchema[]>, value: unknown) {
+// 	return (
+// 		schema.oneOf.reduce(
+// 			(acc: number, schema: any) =>
+// 				Value.Check(schema, value) ? acc + 1 : acc,
+// 			0
+// 		) === 1
+// 	)
+// }
+
+// export interface TUnionOneOf<T extends TSchema[] = TSchema[]> extends TSchema {
+// 	[Kind]: typeof UnionOneOfKind
+// 	[Members]: [...T]
+// 	static: Static<TUnion<T>>
+// 	oneOf: T
+// }
+
+// /** Creates a Union type with a `oneOf` schema representation */
+// export function UnionOneOf<T extends TSchema[]>(
+// 	oneOf: [...T],
+// 	options: SchemaOptions = {}
+// ) {
+// 	return {
+// 		...options,
+// 		[Kind]: UnionOneOfKind,
+// 		oneOf,
+// 		[Members]: oneOf
+// 	} as TUnionOneOf<T>
+// }

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

@@ -0,0 +1,204 @@
+import {
+	CloneType,
+	type SchemaOptions,
+	type TRef,
+	type TSchema,
+	Type
+} from '@sinclair/typebox'
+import {
+	forEach,
+	isEmpty,
+	isNull,
+	keyBy,
+	mapValues,
+	omit,
+	omitBy,
+	set
+} from 'lodash-es'
+import type { SetRequired, SnakeCase } from 'type-fest'
+import * as Player from '../common/Player.js'
+import { CollectableType, NonCollectableType, type Rules } from '../Rules.js'
+import { pascalCase } from './string.js'
+import { UnionEnum } from './UnionEnum.js'
+
+/** Build-time configuration for a tag rule, used to generate TypeBox schemas. */
+type TagRuleConfig =
+	| TagRuleConfigPrimitive
+	| TagRuleConfigEnum
+	| TagRuleConfigIdRef
+
+interface TagRuleConfigBase {
+	description: string
+	node_types: (CollectableType | NonCollectableType)[] | null
+}
+
+interface TagRuleConfigPrimitive extends TagRuleConfigBase {
+	value_type: 'boolean' | 'integer'
+	array?: boolean
+}
+
+interface TagRuleConfigEnum extends TagRuleConfigBase {
+	value_type: 'enum'
+	enum: string[]
+	array?: boolean
+}
+
+interface TagRuleConfigIdRef extends TagRuleConfigBase {
+	value_type: CollectableType | NonCollectableType
+	wildcard?: boolean
+}
+
+export function generateRulesetSchemas(rulesPackage: string, rules: Rules) {
+	const ConditionMeterKey = UnionEnum(
+		Object.keys(rules.condition_meters),
+		omit(CloneType(Player.ConditionMeterKey), 'examples', 'type')
+	)
+
+	const StatKey = UnionEnum(
+		Object.keys(rules.stats),
+		omit(CloneType(Player.StatKey), 'examples', 'type')
+	)
+
+	return {
+		ConditionMeterKey,
+		StatKey,
+		// NB: Rules.tags schema shape doesn't match TagRuleConfig yet; this function is experimental
+		...generateTagSchemas(
+			rulesPackage,
+			rules.tags as unknown as Record<SnakeCase<string>, TagRuleConfig>
+		)
+	}
+}
+
+function generateTagSchema(
+	rulesPackage: string,
+	tagKey: string,
+	tagRule: TagRuleConfig
+): SetRequired<TSchema, '$id' | 'description'> {
+	const $id = `${pascalCase(rulesPackage) + pascalCase(tagKey)}Tag`
+	const { description } = tagRule
+	const options = { description, $id } as SetRequired<
+		SchemaOptions,
+		'$id' | 'description'
+	>
+
+	switch (tagRule.value_type) {
+		case 'boolean':
+		case 'integer': {
+			const base = (Type as any)[pascalCase(tagRule.value_type)]()
+			return tagRule.array
+				? (Type.Array(base, options) as any)
+				: ({ ...base, ...options } as any)
+		}
+		case 'enum': {
+			const base = UnionEnum(tagRule.enum)
+			return tagRule.array
+				? (Type.Array(base, options) as any)
+				: ({ ...base, ...options } as any)
+		}
+		case 'move':
+		case 'asset':
+		case 'oracle_rollable':
+		case 'atlas_entry':
+		case 'npc':
+		case 'delve_site':
+		case 'delve_site_theme':
+		case 'delve_site_domain':
+		case 'truth':
+		case 'rarity':
+			return tagRule.wildcard
+				? (Type.Array(Type.Ref(`${pascalCase(tagRule.value_type)}WildcardId`), {
+						description
+					}) as any)
+				: (Type.Ref(`${pascalCase(tagRule.value_type)}Id`, options) as any)
+		default: {
+			const _exhaustive: never = tagRule
+			throw new Error(
+				`Unknown tag value type: ${(_exhaustive as TagRuleConfig).value_type}`
+			)
+		}
+	}
+}
+
+const anyType = [...CollectableType.enum, ...NonCollectableType.enum]
+
+function generateTagSchemas(
+	rulesPackage: SnakeCase<string>,
+	tags: Record<SnakeCase<string>, TagRuleConfig>
+) {
+	const allowedTagProperties = Object.fromEntries(
+		anyType.map((k: CollectableType | NonCollectableType) => [
+			k,
+			{} as Record<SnakeCase<string>, TRef>
+		])
+	)
+
+	const tagSchemas: Record<string, TSchema> = {}
+
+	forEach(tags, (tag, tagKey) => {
+		const schema = generateTagSchema(rulesPackage, tagKey, tag)
+		tagSchemas[schema.$id] = schema
+		const pushTo = isNull(tag.node_types) ? anyType : tag.node_types
+
+		for (const objectType of pushTo) {
+			set(
+				allowedTagProperties,
+				[objectType, tagKey].join('.'),
+				Type.Optional(Type.Ref(schema))
+			)
+		}
+	})
+
+	const allowedTagSchemas = omitBy(
+		keyBy(
+			mapValues(allowedTagProperties, (v, k) =>
+				Type.Object(v, {
+					$id: `${pascalCase(rulesPackage)}${pascalCase(k)}Tags`,
+					additionalProperties: true
+				})
+			),
+			(v) => v.$id
+		),
+		(v) => isEmpty(v.properties)
+	)
+
+	const tagNamespacesSchema = keyBy(
+		mapValues(allowedTagSchemas, (v, k) =>
+			Type.Object(
+				{ [rulesPackage]: Type.Optional(Type.Ref(v)) },
+				{
+					additionalProperties: true,
+					$id: k.replace(pascalCase(rulesPackage), '')
+				}
+			)
+		),
+		(v) => v.$id
+	)
+
+	console.log(tagNamespacesSchema)
+
+	return {
+		...tagNamespacesSchema,
+		...tagSchemas,
+		...allowedTagSchemas
+	}
+}
+
+// TODO: generate dummy schemas so the overrides can be inserted later
+
+console.log(
+	generateTagSchemas('sundered_isles', {
+		cursed_version_of: {
+			description: 'This oracle is the cursed version of another oracle.',
+			node_types: ['oracle_rollable'],
+			value_type: 'oracle_rollable',
+			wildcard: true
+		},
+		cursed_by: {
+			description: 'This oracle has a cursed version.',
+			node_types: ['oracle_rollable'],
+			value_type: 'oracle_rollable',
+			wildcard: false
+		}
+	})
+)

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

@@ -0,0 +1,15 @@
+import { camelCase } from 'lodash-es'
+import type { PascalCase as PascalCaseNoDot } from 'type-fest'
+import type { Join, Split } from '../../pkg-core/Utils/String.js'
+
+export function capitalize<Str extends string = string>(str: Str) {
+	return (str[0].toLocaleUpperCase('en-US') + str.slice(1)) as Capitalize<Str>
+}
+
+export type PascalCase<T extends string> = PascalCaseNoDot<
+	Join<Split<T, '.'>, '_'>
+>
+
+export function pascalCase<Str extends string = string>(str: Str) {
+	return capitalize(camelCase(str.split('.').join('_'))) as PascalCase<Str>
+}