@datasworn-community/build-tools 0.2.0

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

@@ -0,0 +1,176 @@
+import { type Static, Type } from '@sinclair/typebox'
+import TypeId from '../../pkg-core/IdElements/TypeId.js'
+import JtdType from '../../scripts/json-typedef/typedef.js'
+import Id, { RulesetId } from '../common/Id.js'
+import { DiceExpression } from '../common/Rolls.js'
+import { Dictionary } from '../generic/Dictionary.js'
+import { JsonTypeDef } from '../Symbols.js'
+import { Nullable, UnionEnum } from '../Utils.js'
+import { type PascalCase, pascalCase } from '../utils/string.js'
+import { TagSchema } from './TagSchema.js'
+
+type _NodeSchemaName<T extends string> = PascalCase<T>
+type EmbeddedNodeSchemaName<T extends string> = `Embedded${PascalCase<T>}`
+type IdSchemaName<T extends string> = `${PascalCase<T>}Id`
+type WildcardIdSchemaName<T extends string> = `${PascalCase<T>}IdWildcard`
+
+function getNodeSchemaName<T extends string>(typeId: T) {
+	return pascalCase(typeId)
+}
+
+function getEmbeddedNodeSchemaName<T extends string>(typeId: T) {
+	return `Embedded${pascalCase(typeId)}` as EmbeddedNodeSchemaName<T>
+}
+
+function getIdSchemaName<T extends string>(typeId: T) {
+	return `${pascalCase(typeId)}Id` as IdSchemaName<T>
+}
+function getWildcardIdSchemaName<T extends string>(typeId: T) {
+	return `${pascalCase(typeId)}IdWildcard` as WildcardIdSchemaName<T>
+}
+
+const AnyPrimary = TypeId.Primary.map(getNodeSchemaName)
+
+const _EmbedOnly = TypeId.EmbedOnly.map(getNodeSchemaName)
+const _EmbeddedPrimary = TypeId.EmbeddablePrimary.map(getEmbeddedNodeSchemaName)
+
+// TODO: could this be generated by iterating over objects and picking the ones with `tags` properties?
+const AnyPrimaryId = AnyPrimary.map(getIdSchemaName)
+const AnyPrimaryIdWildcard = AnyPrimary.map(getWildcardIdSchemaName)
+
+export const CollectionType = UnionEnum<typeof TypeId.Collection>(
+	TypeId.Collection,
+	{
+		$id: 'CollectionType'
+	}
+)
+export type CollectionType = Static<typeof CollectionType>
+
+export const CollectableType = UnionEnum(TypeId.Collectable, {
+	$id: 'CollectableType'
+})
+export type CollectableType = Static<typeof CollectableType>
+
+export const NonCollectableType = UnionEnum(TypeId.NonCollectable, {
+	$id: 'NonCollectableType'
+})
+export type NonCollectableType = Static<typeof NonCollectableType>
+
+export const EmbedOnlyType = UnionEnum(TypeId.EmbedOnly, {
+	$id: 'EmbedOnlyType'
+})
+export type EmbedOnlyType = Static<typeof EmbedOnlyType>
+
+export const RuleType = UnionEnum(
+	['impact', 'condition_meter', 'special_track', 'stat'],
+	{ $id: 'RuleType' }
+)
+export type RuleType = Static<typeof RuleType>
+
+export const TaggableNodeType = Type.Union(
+	[
+		Type.Ref(CollectableType),
+		Type.Ref(NonCollectableType),
+		Type.Ref(CollectionType),
+		Type.Ref(EmbedOnlyType),
+		Type.Ref(RuleType)
+	],
+	{
+		[JsonTypeDef]: {
+			schema: JtdType.Enum([
+				...TypeId.Primary,
+				...TypeId.EmbedOnly,
+				'impact',
+				'condition_meter',
+				'special_track',
+				'stat'
+			])
+		},
+		$id: 'TaggableNodeType'
+	}
+)
+export type TaggableNodeType = Static<typeof TaggableNodeType>
+
+export { TagSchema }
+
+export const TagRule = Type.Object(
+	{
+		node_types: Nullable(Type.Array(Type.Ref(TaggableNodeType)), {
+			description:
+				'Types of object that can receive this tag, or `null` if any type of object accepts it.',
+			default: null
+		}),
+		$schema: Type.Ref(TagSchema, {
+			description: 'The JSON schema for this tag value.'
+		})
+	},
+	{ $id: 'TagRule' }
+)
+
+// export const TagRule = DiscriminatedUnion(typedTags, 'value_type', {
+// 	$id: 'TagRule'
+// })
+export type TagRule = Static<typeof TagRule>
+
+const TagValueNonId = [
+	Type.Boolean(),
+	Type.Integer(),
+	Type.Ref(Id.DictKey), // from enums
+	Type.Ref(DiceExpression)
+]
+
+export const Tag = Type.Union(
+	[
+		...TagValueNonId,
+		...AnyPrimaryId.map((type) => Type.Ref(type)),
+		Type.Array(
+			Type.Union([
+				// Type.Ref(Id.DictKey), // from enums
+				// Type.Ref(Rolls.DiceExpression),
+				...AnyPrimaryIdWildcard.map((type) => Type.Ref(type))
+			])
+		)
+	],
+	{ $id: 'Tag', [JsonTypeDef]: { schema: JtdType.Any() as any } }
+)
+
+export const Tags = Type.Record(
+	RulesetId,
+	Dictionary(Type.Ref('Tag'), { title: 'RulesPackageTags' }),
+	{
+		releaseStage: 'experimental',
+		$id: 'Tags',
+		key: Id.RulesetId.pattern,
+		description:
+			'A dictionary of tags, keyed by the RulesPackageId that the tags are from.'
+	}
+)
+
+export const CoreTags = Type.Object(
+	{
+		supernatural: Type.Optional(
+			Type.Boolean({
+				description:
+					'This object is supernatural in nature, and is ideal for settings that feature supernatural or mythic powers.'
+			})
+		),
+		technological: Type.Optional(
+			Type.Boolean({
+				description:
+					'This object is technological in nature, and is ideal for settings that feature remarkable technologies.'
+			})
+		),
+		requires_allies: Type.Optional(
+			Type.Boolean({
+				description:
+					'This object requires allies to function, and is intended for co-op play, or guided play with allies. It is not appropriate for solo play.'
+			})
+		)
+	},
+	{ $id: 'CoreTags' }
+)
+const coreNamespaceId = '_core' as const
+
+Tags.properties = {
+	[coreNamespaceId]: Type.Optional(Type.Ref(CoreTags))
+}

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

@@ -0,0 +1,161 @@
+import { type TSchema, Type } from '@sinclair/typebox'
+import type { JSONSchema7 } from 'json-schema'
+import { $schema } from '../../scripts/const.js'
+import JtdType from '../../scripts/json-typedef/typedef.js'
+import { DictKey } from '../common/Id.js'
+import { JsonTypeDef, Typescript } from '../Symbols.js'
+
+const validSchemaTypes = [
+	'boolean',
+	'integer',
+	'number',
+	'string',
+	'null'
+] satisfies JSONSchema7['type']
+
+export function isValidTagSchema(schema: TSchema) {
+	if (validSchemaTypes.includes(schema?.type)) return true
+	// some IDs are union schemas, these are fine
+	if (schema.$id?.endsWith('Id') || schema.$id?.endsWith('IdWildcard'))
+		return true
+	if ('enum' in schema) return true
+	if ('const' in schema) return true
+	if ('anyOf' in schema)
+		return (schema.anyOf as TSchema[]).every(isValidTagSchema)
+
+	return false
+}
+
+const TagSchemaInteger = Type.Object(
+	{ type: Type.Const('integer') },
+	{ title: 'TagSchemaInteger', additionalProperties: true }
+)
+
+const TagSchemaFloat = Type.Object(
+	{
+		type: Type.Const('number')
+	},
+	{ title: 'TagSchemaFloat', additionalProperties: true }
+)
+
+const TagSchemaStringEnum = Type.Object(
+	{
+		enum: Type.Array(Type.Ref(DictKey))
+	},
+	{ title: 'TagSchemaStringEnum', additionalProperties: true }
+)
+
+const TagSchemaIntegerEnum = Type.Object(
+	{
+		enum: Type.Array(Type.Integer())
+	},
+	{
+		title: 'TagSchemaIntegerEnum',
+		additionalProperties: true
+	}
+)
+
+const TagSchemaBoolean = Type.Object(
+	{
+		type: Type.Const('boolean')
+	},
+	{
+		description: 'Schema for a true or false value.',
+		title: 'TagSchemaBoolean',
+		additionalProperties: true
+	}
+)
+
+const TagSchemaDataswornRef = Type.Object(
+	{
+		$ref: Type.Any()
+		// this a placeholder value.
+		// an enum is computed from all datasworn schemata at build time.
+	},
+	{ title: 'TagSchemaDataswornRef', additionalProperties: true }
+)
+
+// future additions - nested objects?
+
+const _schemaKeyBlacklist = [
+	'$id',
+	'$defs',
+	'$schema',
+	'definitions',
+	'dependencies',
+	'if',
+	'then',
+	'else',
+	'allOf',
+	'anyOf',
+	'oneOf',
+	'not',
+	'additionalItems',
+	'additionalProperties'
+] as const satisfies (keyof JSONSchema7)[]
+
+// set here to use as a forward reference
+const TagSchemaId = 'TagSchema' as const
+
+const TagSchemaObject = Type.Object(
+	{
+		type: Type.Const('object'),
+		properties: Type.Record(DictKey, Type.Ref(TagSchemaId))
+		//
+	},
+	{ title: 'TagSchemaObject', additionalProperties: true }
+)
+
+const TagSchemaArray = Type.Object(
+	{
+		type: Type.Const('array'),
+		items: Type.Ref(TagSchemaId)
+		//
+	},
+	{ title: 'TagSchemaArray', additionalProperties: true }
+)
+
+export const TagSchema = Type.Intersect(
+	[
+		Type.Union([
+			TagSchemaDataswornRef as TSchema,
+			// enumerations
+			TagSchemaStringEnum,
+			TagSchemaIntegerEnum,
+			// primitives
+			TagSchemaBoolean,
+			TagSchemaInteger,
+			TagSchemaFloat,
+			// basic string schema intentionally omitted -- strings must be one of datasworn's subtypes or an enum.
+			TagSchemaObject,
+			TagSchemaArray
+		]),
+		Type.Ref($schema)
+		// Type.Not(
+		// 	Type.Record(
+		// 		Type.Enum(Object.fromEntries(schemaKeyBlacklist.map((v) => [v, v]))),
+		// 		Type.Any()
+		// 	)
+		// )
+	],
+	{
+		$id: TagSchemaId,
+		// TODO: JTD schema for JSON schema of JSON schema? :sob:
+		[JsonTypeDef]: { schema: JtdType.Any() as any },
+		// TODO: add json schema type stub lib as dependency; point at this type
+		[Typescript]: (identifier: string, _schema: TSchema) =>
+			`export type ${identifier} = Record<string, unknown>`,
+		description:
+			'JSON schema used to validate the tag data, with a mandatory description. Only a subset of all possible JSON schema are allowed, including references to some Datasworn types.',
+		releaseStage: 'experimental',
+		examples: [
+			Type.Boolean({
+				description: 'An example tag with a simple true/false value.'
+			}),
+			Type.Array(Type.Ref('OracleRollableIdWildcard'), {
+				description:
+					'An example tag with an array of oracle rollable ID wildcards.'
+			})
+		]
+	}
+)

package/schema-source/schema/tags/canonicalTags.ts

@@ -0,0 +1,29 @@
+import { type TSchema, Type } from '@sinclair/typebox'
+import { UnionEnum } from '../Utils.js'
+
+const _TagsClassic = {}
+const _TagsStarforged = {
+	recommended: Type.Boolean({
+		description: 'This object is ideal for use in Starforged.'
+	})
+} satisfies Record<string, TSchema>
+const _TagsDelve = {} satisfies Record<string, TSchema>
+type _TagParams = {
+	schema: TSchema
+	node_types: []
+}
+const _TagsSunderedIsles = {
+	recommended: Type.Boolean({
+		description: 'This object is ideal for use in Sundered Isles.'
+	}),
+	cursed_version_of: Type.Array(Type.Ref('OracleRollableIdWildcard')),
+	// wrap these into their own objects: "cursed" and "curses"?
+	curse_behavior: Type.Array(UnionEnum(['replace_result', 'add_result'])),
+	cursed_by: Type.Array(Type.String()),
+	region: UnionEnum(['myriads', 'margins', 'reaches'])
+	// overland_region
+	// location
+	// faction_type
+	// ship_size
+	// treasure_size
+} satisfies Record<string, TSchema>

package/schema-source/schema/tools/build/index.ts

@@ -0,0 +1,48 @@
+import { type Static, Type } from '@sinclair/typebox'
+import {
+	PKG_SCOPE_COMMUNITY,
+	PKG_SCOPE_OFFICIAL
+} from '../../../scripts/const.js'
+import { UnionEnumFromRecord } from '../../utils/UnionEnumFromRecord.js'
+
+export const RulesPackageConfig = Type.Object({
+	id: Type.String({
+		description:
+			'The namespace ID for this data set. This is the first path element of all its object IDs.'
+	}),
+	description: Type.Optional(Type.String()),
+	type: Type.Union([Type.Literal('ruleset'), Type.Literal('expansion')]),
+	pkg: Type.Object({
+		name: Type.String({
+			description: 'The package ID, not including its scope (see `scope`).'
+		}),
+		private: Type.Boolean({ default: false }),
+		description: Type.String(),
+		keywords: Type.Array(Type.String()),
+		authors: Type.Array(
+			Type.Object({
+				name: Type.String(),
+				email: Type.String({ format: 'email' }),
+				url: Type.String({ format: 'uri' })
+			})
+		),
+		scope: UnionEnumFromRecord(
+			{
+				[PKG_SCOPE_OFFICIAL]: 'Official Ironsworn content.',
+				[PKG_SCOPE_COMMUNITY]:
+					'Ironsworn-compatible content from third parties.'
+			},
+			{
+				description: 'The namespace or scope used by the package.',
+				default: PKG_SCOPE_COMMUNITY
+			}
+		)
+	}),
+	paths: Type.Object({
+		source: Type.String(),
+		assets: Type.Optional(Type.Array(Type.String()))
+	})
+
+	// TODO: configure more of package construction from here, e.g. content of package.json
+})
+export type RulesPackageConfig = Static<typeof RulesPackageConfig>

package/schema-source/schema/tools/i18n/index.ts

@@ -0,0 +1,9 @@
+import { type Static, Type } from '@sinclair/typebox'
+
+export const Term = Type.Object({
+	context: Type.String(),
+	value: Type.Union([Type.String(), Type.Null()]),
+	source: Type.Array(Type.String()),
+	markdown: Type.Boolean(),
+})
+export type Term = Static<typeof Term>

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

@@ -0,0 +1,82 @@
+import {
+	CloneType,
+	type SchemaOptions,
+	type Static,
+	type TObject,
+	type TSchema
+} from '@sinclair/typebox'
+
+/** Symbol indicating that this property is computed at build time, and is therefore optional in DataswornSource */
+export const ComputedPropertyBrand = Symbol('ComputedProperty')
+
+type ComputedOptions<
+	T extends TSchema,
+	ParentObject extends TObject
+> = SchemaOptions & {
+	[ComputedPropertyBrand]:
+		| 'ComputedProperty'
+		| ComputedPropertyFn<T, ParentObject>
+}
+
+/** Create a schema that is computed at build time, and is therefore optional in DataswornSource */
+// TODO: make it possible for this to supply a function that computes the property!
+export function Computed<
+	T extends TSchema,
+	ParentObject extends TObject = TObject
+>(
+	schema: T,
+	options: ComputedOptions<T, ParentObject> = {
+		[ComputedPropertyBrand]: 'ComputedProperty'
+	}
+) {
+	return CloneType(schema, {
+		...options
+	}) as TComputed<T, ParentObject>
+}
+export type TComputed<
+	T extends TSchema,
+	ParentObject extends TObject = TObject
+> = T & {
+	[ComputedPropertyBrand]:
+		| 'ComputedProperty'
+		| ComputedPropertyFn<T, ParentObject>
+}
+
+type ComputedPropertyFn<T extends TSchema, ParentObject extends TObject> = (
+	object: Static<ParentObject>,
+	property: string,
+	pointer: string
+) => Static<T>
+
+/** Symbol indicating that this property is optional in DataswornSource */
+export const SourceOptionalBrand = Symbol('SourceOptional')
+
+/** Flags a schema as being optional in DataswornSource. Mutates the original schema.
+ * @remarks Functionally similar to {@link Computed}, but with different semantics.
+ */
+export function setSourceOptional<T extends TSchema>(schema: T) {
+	if (schema == null) return schema
+	;(schema as TSourceOptional<T>)[SourceOptionalBrand] = 'SourceOptional'
+	return schema as TSourceOptional<T>
+}
+export type TSourceOptional<T extends TSchema> = T & {
+	[SourceOptionalBrand]: 'SourceOptional'
+}
+
+export const GetSourceDataSchema = Symbol('GetSourceDataSchema')
+
+/** Provide an override value  */
+export function setSourceDataSchema<
+	T extends TSchema,
+	SourceSchema extends TSchema
+>(schema: T, sourceSchema: SourceSchema | ((schema: T) => SourceSchema)): T {
+	// @ts-expect-error
+	schema[GetSourceDataSchema] =
+		typeof sourceSchema === 'function' ? sourceSchema : () => sourceSchema
+
+	return schema as THasSourceSchema<T, SourceSchema>
+}
+export type THasSourceSchema<
+	T extends TSchema = TSchema,
+	SourceSchema extends TSchema = TSchema
+> = T & { [GetSourceDataSchema]: (schema: T) => SourceSchema }