@datasworn-community/build-tools 0.2.0

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

@@ -0,0 +1,255 @@
+import {
+	CloneType,
+	Kind,
+	type ObjectOptions,
+	type SchemaOptions,
+	type Static,
+	type TLiteral,
+	type TObject,
+	type TRefUnsafe,
+	type TSchema,
+	type TUnion,
+	Type,
+	TypeRegistry
+} from '@sinclair/typebox'
+import { omit } from 'lodash-es'
+import { Discriminator, Mapping, Members } from '../Symbols.js'
+import { Assign, type TAssign } from './FlatIntersect.js'
+import { IfThenElse, type TIfThenElse } from './IfThen.js'
+import type { PickByType } from './typebox.js'
+import { type TUnionEnum, UnionEnum } from './UnionEnum.js'
+
+type DiscriminableKeyOf<T> = keyof T & keyof PickByType<T, string> & string
+type DiscriminatorValueOf<T, D extends DiscriminableKeyOf<T>> = T[D] & string
+export type DiscriminatorMap<T, D extends DiscriminableKeyOf<T>> = {
+	[K in T as DiscriminatorValueOf<T, D>]: K
+}
+
+type ValueIn<T extends Record<any, TSchema>> =
+	T extends Record<any, infer U extends TSchema> ? U : never
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type TDiscriminableish<
+	K extends string = string,
+	D extends string = string,
+	TBase extends TObject = TObject
+> =
+	| TDiscriminable<K, D, TBase>
+	| TRefUnsafe<TDiscriminable<K, D, TBase>>
+	| TObject<any>
+	| TRefUnsafe<TObject<any>>
+
+export function Discriminable<
+	K extends string,
+	V extends string,
+	TBase extends TObject = TObject
+>(base: TBase, discriminator: K, mappingKey: V, options = {}) {
+	const mixin = Type.Object({
+		[discriminator]: Type.Literal(mappingKey)
+	}) as TObject<{ [P in K]: TLiteral<V> }>
+	return Assign(base, mixin, options) as TDiscriminable<K, V, TBase>
+}
+export type TDiscriminable<
+	K extends string,
+	V extends string,
+	TBase extends TObject = TObject
+> = TAssign<TBase, TObject<{ [P in K]: TLiteral<V> }>>
+export type Discriminable<
+	K extends string,
+	V extends string,
+	TBase extends object
+> = Assign<TBase, { [P in K]: V }>
+
+export type TDiscriminableBy<
+	T extends TObject,
+	D extends string,
+	V extends string = string
+> = TObject<T['properties'] & { [K in D]: TLiteral<V> }>
+
+export type TDiscriminableKeyOf<T extends TDiscriminableish> =
+	DiscriminableKeyOf<Static<T>>
+
+export type TDiscriminableKeyFor<
+	T extends TDiscriminatorMap<TDiscriminableish>
+> = keyof Static<ValueIn<T>> & string
+
+type TDiscriminatorValueOf<
+	T extends TDiscriminableish,
+	D extends TDiscriminableKeyOf<T>
+> = Static<T[D]>
+
+type _TDiscriminatorValueFor<
+	T extends TDiscriminatorMap<TDiscriminableish>,
+	D extends TDiscriminableKeyFor<T>
+> = Static<T[keyof T] & TSchema>[D]
+
+export type TDiscriminatorMap<
+	T extends TDiscriminableish = TDiscriminableish,
+	D extends TDiscriminableKeyOf<T> = TDiscriminableKeyOf<T>
+> = Record<D, T & TDiscriminableish>
+// > = {
+// 	[Schema in T as Static<T>[D] & string]: Schema
+// }TDiscriminatedUnion
+
+// type TDiscriminatorMap<D extends string, V extends string = string> = {
+// 	[K in V]: TDiscriminable<D, K>
+// }
+
+export interface TDiscriminatedUnion<
+	M extends
+		TDiscriminatorMap<TDiscriminableish> = TDiscriminatorMap<TDiscriminableish>,
+	D extends string = string
+> extends TSchema {
+	type: 'object'
+	static: Static<TUnion<ValueIn<M>[]>>
+
+	properties: Record<D, TUnionEnum<string[]>>
+
+	// without this, schemata won't validate if they add any new properties (which they almost certainly will)
+	additionalProperties: true
+
+	allOf: TIfThenElse<
+		TObject<{ [K in D]: TDiscriminatorValueOf<ValueIn<M>, any> }>,
+		ValueIn<M>
+	>[]
+
+	[Kind]: 'DiscriminatedUnion'
+	[Discriminator]: D
+	[Mapping]: M
+}
+
+export type TDiscriminatorMappingOf<
+	T extends TDiscriminatedUnion<any, string>
+> = T[typeof Mapping]
+
+export type TDiscriminatedMemberType<T extends TDiscriminatedUnion<any>> =
+	T extends TDiscriminatedUnion<
+		infer U extends TDiscriminatorMap<TDiscriminableish>,
+		any
+	>
+		? keyof U
+		: never
+
+export type TDiscriminatedMember<
+	T extends TDiscriminatedUnion<any>,
+	TMemberType extends TDiscriminatedMemberType<T> = TDiscriminatedMemberType<T>
+> = T extends TDiscriminatedUnion<infer U> ? U[TMemberType] : never
+
+export function DiscriminatedUnion<
+	M extends TDiscriminatorMap<TDiscriminableish<string, string, TObject>>,
+	D extends string & keyof Static<ValueIn<M>>
+>(mapping: M, discriminator: D, options: SchemaOptions = {}) {
+	if (!TypeRegistry.Has('DiscriminatedUnion'))
+		TypeRegistry.Set('DiscriminatedUnion', DiscriminatedUnionCheck)
+
+	const allOf = (Object.entries(mapping) as [string, TSchema][]).map(
+		([value, schema]) =>
+			(Discriminated as any)(
+				'$id' in schema ? Type.Ref(schema) : schema,
+				discriminator,
+				value
+			)
+	)
+	const discriminatorValues = UnionEnum(Object.keys(mapping) as string[])
+
+	return {
+		...options,
+		properties: { [discriminator]: discriminatorValues },
+		additionalProperties: true,
+		allOf,
+		required: [discriminator],
+		type: 'object',
+		remarks: `Deserialize as a discriminated union/polymorphic object type, using the \`${discriminator}\` property as a discriminator.`,
+
+		[Discriminator]: discriminator,
+		[Mapping]: mapping,
+
+		[Kind]: 'DiscriminatedUnion'
+	} as unknown as TDiscriminatedUnion<M, D>
+}
+
+export function OmitDiscriminatedUnionMembers<
+	TBase extends TDiscriminatedUnion<TDiscriminatorMap<TDiscriminableish>>,
+	TOmitKeys extends (keyof TBase[typeof Mapping])[]
+>(base: TBase, omitKeys: TOmitKeys, options: ObjectOptions = {}) {
+	const remapping = {} as Omit<TBase[typeof Mapping], TOmitKeys[number]>
+
+	for (const k in base[Mapping])
+		if (!omitKeys.includes(k as any))
+			// @ts-expect-error
+			remapping[k] = base[Mapping][k]
+
+	return (DiscriminatedUnion as any)(
+		remapping,
+		base[Discriminator],
+		options
+	) as TOmitDiscriminatedUnionMembers<TBase, TOmitKeys>
+}
+export type TOmitDiscriminatedUnionMembers<
+	TBase extends TDiscriminatedUnion<TDiscriminatorMap<TDiscriminableish>>,
+	TOmitKeys extends (keyof TBase[typeof Mapping])[]
+> = TDiscriminatedUnion<
+	Omit<TBase[typeof Mapping], TOmitKeys[number]>,
+	TBase[typeof Discriminator] & string
+>
+
+function DiscriminatedUnionCheck(
+	schema: TDiscriminatedUnion<any, string>,
+	value: unknown
+) {
+	const discriminator = schema[Discriminator]
+	// const members = schema[Members]
+	const mapping = schema.properties[discriminator].enum
+
+	// const memberSchema = UnionOneOf(members)
+	// const memberValidator = Value.Check()
+
+	return (value as any[]).every((item) => mapping.includes(item[discriminator]))
+}
+
+export function TDiscriminatedUnion<
+	T extends TDiscriminatedUnion<any, string> = TDiscriminatedUnion<any, string>
+>(schema: unknown): schema is T {
+	return (schema as T)[Kind] === 'DiscriminatedUnion'
+}
+
+export function ToUnion<T extends TObject[]>(
+	schema: TDiscriminatedUnion<any, string>
+) {
+	const base = omit(CloneType(schema), [
+		'type',
+		'allOf',
+		'additionalProperties',
+		'oneOf',
+		Kind,
+		Discriminator,
+		Members
+	])
+
+	const anyOf = schema.allOf.map(({ then }) => then) as unknown as T
+
+	return Type.Union(anyOf, omit(base, ['properties']))
+}
+
+function Discriminated<
+	T extends TSchema,
+	K extends keyof Static<T>,
+	V extends Static<T>[K] & string
+>(schema: T, discriminator: K, value: V, options: SchemaOptions = {}) {
+	return omit(
+		IfThenElse(
+			{
+				condition: omit(
+					Type.Object(
+						{ [discriminator]: Type.Literal(value) }
+						// unset these to reduce schema clutter; they're redundant once the schema is composed
+					),
+					['required', 'type']
+				) as TObject,
+				ifTrue: schema
+			},
+			options
+		),
+		['required', 'type']
+	)
+}

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

@@ -0,0 +1,172 @@
+import {
+	type ObjectOptions,
+	type Static,
+	type TLiteral,
+	type TObject,
+	type TOmit,
+	type TRefUnsafe,
+	type TString,
+	type TUnion,
+	Type
+} from '@sinclair/typebox'
+import type { Writable } from 'type-fest'
+import TypeId from '../../pkg-core/IdElements/TypeId.js'
+import {
+	EnhancesKey,
+	IdKey,
+	ReplacesKey,
+	SourceInfoKey,
+	type TypeSep
+} from '../../scripts/const.js'
+import { Computed } from './Computed.js'
+import { pascalCase } from './string.js'
+
+const EmbeddedDictionaryKeys = Object.values(TypeId.BranchKey)
+type EmbeddedDictionaryKeys = (typeof EmbeddedDictionaryKeys)[number]
+
+const ReplacedEmbedKeys = [IdKey] as const
+type ReplacedEmbedKeys = Writable<typeof ReplacedEmbedKeys>
+const OmittedEmbedKeys = [SourceInfoKey, EnhancesKey, ReplacesKey] as const
+type OmittedEmbedKeys = Writable<typeof OmittedEmbedKeys>
+
+type TTypeNode = TObject<{ type: TLiteral<string> }>
+
+export function EmbeddedPrimaryNode<
+	TBase extends TObject,
+	TId extends TRefUnsafe<TString | TUnion<TString[]>>,
+	TEmbedKeys extends EmbeddedDictionaryKeys[]
+>(base: TBase, allowEmbeds: TEmbedKeys, options: ObjectOptions = {}) {
+	const typeSchema = (base as unknown as TTypeNode).properties?.type
+	const typeName = `Embedded${pascalCase(typeSchema?.const ?? 'Unknown')}`
+
+	const _id = Computed(Type.Ref(`${typeName}Id`))
+
+	const forbiddenEmbedChildren = (
+		allowEmbeds == null
+			? EmbeddedDictionaryKeys
+			: EmbeddedDictionaryKeys.filter((k) => !allowEmbeds.includes(k))
+	) as [
+		...Exclude<(typeof EmbeddedDictionaryKeys)[number], TEmbedKeys[number]>[]
+	]
+	const omittedKeys = [
+		...forbiddenEmbedChildren,
+		...ReplacedEmbedKeys,
+		...OmittedEmbedKeys
+	] as const
+
+	const { properties } = Type.Omit(base, omittedKeys)
+
+	const result = Type.Object({ _id, ...properties }, options)
+
+	// @ts-expect-error
+	return result as TEmbeddedNode<TBase, TParentType, TId, TEmbedKeys>
+}
+
+export type TEmbeddedNodeTypeLiteral<
+	TBase extends TTypeNode,
+	TParentType extends string
+> = TLiteral<`${TParentType}${TypeSep}${Static<TBase>['type']}`>
+
+export type TEmbeddedNode<
+	TBase extends TTypeNode,
+	TParentType extends string,
+	TId extends TRefUnsafe<TString | TUnion<TString[]>>,
+	TEmbedKeys extends EmbeddedDictionaryKeys[]
+> = TObject<
+	{
+		_id: TId
+		type: TEmbeddedNodeTypeLiteral<TBase, TParentType>
+	} & TOmit<
+		TBase,
+		[
+			...OmittedEmbedKeys,
+			...ReplacedEmbedKeys,
+			...Exclude<EmbeddedDictionaryKeys, TEmbedKeys[number]>[]
+		]
+	>['properties']
+>
+
+// export function EmbeddedDiscriminatedUnion<
+// 	TUnionBase extends TDiscriminatedUnion<
+// 		TDiscriminatorMap<TDiscriminable<TTypeNode>>
+// 	>,
+// 	TParentType extends string,
+// 	TId extends TRef<TString | TUnion<TString[]>>,
+// 	TEmbedKeys extends EmbeddedDictionaryKeys[] = []
+// >(
+// 	base: TUnionBase,
+// 	parent: TParentType,
+
+// 	allowEmbeds?: TEmbedKeys,
+// 	options: ObjectOptions = {}
+// ) {
+// 	const mapping = base[Mapping]
+// 	type TMapBase = TUnionBase[typeof Mapping]
+// 	type TRemap = {
+// 		[K in keyof TMapBase]: TEmbeddedNode<
+// 			TMapBase[K] & TTypeNode,
+// 			TParentType,
+// 			TId,
+// 			TEmbedKeys
+// 		>
+// 	}
+// 	if (allowEmbeds == null) allowEmbeds = [] as any
+// 	const remapping = {} as TRemap
+
+// 	for (const k in mapping) {
+// 		// @ts-expect-error
+// 		const subtype = base[Mapping][k]
+// 		// @ts-expect-error
+// 		remapping[k] = EmbeddedNode(subtype, parent, allowEmbeds)
+// 	}
+
+// 	return DiscriminatedUnion(
+// 		remapping,
+// 		// @ts-expect-error
+// 		base[Discriminator],
+// 		options
+// 	) as TDiscriminatedUnion<
+// 		TRemap,
+// 		TUnionBase[typeof Discriminator] & TDiscriminableKeyFor<TRemap>
+// 	>
+// }
+
+// export type TEmbeddedDiscriminatorMap<
+// 	TBase extends TDiscriminatorMap<TDiscriminable<TTypeNode>>,
+// 	TParentType extends string,
+// 	TId extends TRef<TString | TUnion<TString[]>>,
+// 	TEmbedKeys extends EmbeddedDictionaryKeys[]
+// > = {
+// 	[K in keyof TBase]: TEmbeddedNode<
+// 		TBase[K] & TTypeNode,
+// 		TParentType,
+// 		TId,
+// 		TEmbedKeys
+// 	>
+// }
+
+// export type TEmbeddedDiscriminatedUnion<
+// 	TUnionBase extends TDiscriminatedUnion<
+// 		TDiscriminatorMap<TDiscriminable<TTypeNode>, 'type'>,
+// 		'type'
+// 	>,
+// 	TParentType extends string,
+// 	TId extends TRef<TString | TUnion<TString[]>>,
+// 	TEmbedKeys extends EmbeddedDictionaryKeys[]
+// > = TDiscriminatedUnion<
+// 	TEmbeddedDiscriminatorMap<
+// 		TUnionBase[typeof Mapping],
+// 		TParentType,
+// 		TId,
+// 		TEmbedKeys
+// 	>,
+// 	TUnionBase[typeof Discriminator] &
+// 		TDiscriminableKeyFor<
+// 			TEmbeddedDiscriminatorMap<
+// 				TUnionBase[typeof Mapping],
+// 				TParentType,
+// 				TId,
+// 				TEmbedKeys
+// 			>
+// 		>
+// >

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

@@ -0,0 +1,22 @@
+import { type SchemaOptions, type Static, Type } from '@sinclair/typebox'
+import { EnumDescription } from './UnionEnum.js'
+import type { UnionEnumFromRecord } from './UnionEnumFromRecord.js'
+
+/** Extracts a literal from a UnionEnum, plus any associated description. */
+
+export function ExtractLiteralFromEnum<
+	T extends ReturnType<typeof UnionEnumFromRecord>,
+	K extends Static<T>
+>(schema: T, key: K, options: SchemaOptions = {}) {
+	const description = schema[EnumDescription][key]
+	return Type.Literal<K>(key, {
+		// [JsonTypeDef]: {
+		// 	metadata: {
+		// 		typescriptType: `${schema.$id?.split('/').pop()}.${pascalCase(key)}`,
+		// 		csharpType: `${schema.$id?.split('/').pop()}.${pascalCase(key)}`
+		// 	}
+		// },
+		description,
+		...options
+	})
+}

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

@@ -0,0 +1,107 @@
+import {
+	CloneType,
+	Kind,
+	type ObjectOptions,
+	type TObject,
+	type TSchema,
+	Type
+} from '@sinclair/typebox'
+import { isEqual } from 'lodash-es'
+
+export type Assign<TTarget, TSource> = Omit<TTarget, keyof TSource> & TSource
+
+// alternate way to compose this type:
+// export type Assign<TTarget, TSource> = {
+// 	[P in keyof TTarget | keyof TSource]: P extends keyof TSource
+// 		? TSource[P]
+// 		: P extends keyof TTarget
+// 			? TTarget[P]
+// 			: never
+// }
+
+export type FlatIntersect<T extends [...object[]]> = T extends [
+	infer U extends object
+]
+	? U
+	: T extends [infer TTarget extends object, infer TSource extends object]
+		? Assign<TTarget, TSource>
+		: T extends [
+					infer TTarget extends object,
+					infer TSource extends object,
+					...infer Tail extends object[]
+				]
+			? FlatIntersect<[Assign<TTarget, TSource>, ...Tail]>
+			: never
+
+// export type TAssign<TBase extends TObject, TOverride extends TObject> = TObject<
+// 	Assign<TBase['properties'], TOverride['properties']>
+// >
+// above version is more precise but more computation-intensive. the one below is close enough for most purposes
+
+export type TAssign<TBase extends TObject, TOverride extends TObject> = TObject<
+	TBase['properties'] & TOverride['properties']
+>
+
+export type TFlatIntersect<T extends [...TObject[]]> = T extends [
+	infer U extends TObject
+]
+	? U
+	: T extends [infer TBase extends TObject, infer TOverride extends TObject]
+		? TAssign<TBase, TOverride>
+		: T extends [
+					infer TBase extends TObject,
+					infer TOverride extends TObject,
+					...infer Tail extends [...TObject[]]
+				]
+			? TFlatIntersect<[TAssign<TBase, TOverride>, ...Tail]>
+			: never
+
+export function Assign<TTarget extends TObject, TSource extends TObject>(
+	target: TTarget,
+	source: TSource,
+	options: ObjectOptions = {}
+) {
+	// Use Record<string, TSchema> to allow mutation, then cast result
+	const mergedProps: Record<string, TSchema> = {
+		...CloneType(target).properties
+	}
+
+	const props = CloneType(source).properties
+	for (const k in props) {
+		const oldProp = mergedProps[k]
+		const newProp = props[k]
+
+		// skip if it's the same thing
+		if (isEqual(oldProp, newProp)) continue
+		// skip if it's the optional version of the same schema
+		if (isEqual(oldProp, Type.Optional(newProp))) continue
+
+		mergedProps[k] = newProp
+	}
+
+	return Type.Object(mergedProps, {
+		[Kind]: 'Object',
+		...options
+	}) as unknown as TAssign<TTarget, TSource>
+}
+
+export function FlatIntersect<T extends TObject[]>(
+	schemas: [...T],
+	options: ObjectOptions = {}
+) {
+	if (schemas.length === 0)
+		throw new Error(
+			`FlatIntersect expected an array of schemas, but the array is empty`
+		)
+
+	const [target, ...sources] = schemas
+
+	let result = CloneType(target, { ...target })
+
+	for (const source of sources) result = Assign(result, source)
+
+	return CloneType(result, {
+		[Kind]: 'Object',
+		...options
+	}) as TFlatIntersect<T>
+}

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

@@ -0,0 +1,50 @@
+import {
+	Kind,
+	type SchemaOptions,
+	type Static,
+	type TSchema
+} from '@sinclair/typebox'
+import { omitBy } from 'lodash-es'
+
+export type TIfThenElse<
+	If extends TSchema,
+	Then extends TSchema,
+	Else extends TSchema | never = never
+> = {
+	[Kind]: 'IfThenElse'
+	if: If
+	then: Then
+	else: Else
+	static: (Static<If> & Static<Then>) | Else extends TSchema
+		? Exclude<Static<Else>, Static<If>>
+		: never
+}
+
+export function IfThenElse<
+	If extends TSchema,
+	Then extends TSchema,
+	Else extends TSchema | never = never
+>(
+	{
+		condition,
+		ifTrue,
+		ifFalse
+	}: {
+		condition: If
+		ifTrue: Then
+		ifFalse?: Else
+	},
+	options: SchemaOptions = {}
+) {
+	return omitBy(
+		{
+			...options,
+			if: condition,
+			// biome-ignore lint/suspicious/noThenProperty: required for JSON Schema if-then-else
+			then: ifTrue,
+			else: ifFalse,
+			[Kind]: 'IfThenElse'
+		},
+		(v, _k) => typeof v === 'undefined'
+	) as TIfThenElse<If, Then, Else>
+}

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

@@ -0,0 +1,16 @@
+import type { SchemaOptions, Static } from '@sinclair/typebox'
+import { EnumDescription, type TUnionEnum } from './UnionEnum.js'
+import { UnionEnumFromRecord } from './UnionEnumFromRecord.js'
+
+export function MergeEnumSchemas<T extends Array<TUnionEnum<string[]>>>(
+	schemas: [...T],
+	options: SchemaOptions = {}
+) {
+	const entries = schemas
+		.map((item) => item[EnumDescription])
+		.reduce((prev, cur) => Object.assign(prev, cur)) as {
+		[P in Static<T[number]>]: string
+	}
+
+	return UnionEnumFromRecord(entries, options)
+}

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

@@ -0,0 +1,6 @@
+import { CloneType } from '@sinclair/typebox'
+import type { TNullable } from './Nullable.js'
+
+export function NonNullable<T extends TNullable>(base: T) {
+	return CloneType(base.anyOf[0])
+}

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

@@ -0,0 +1,29 @@
+import {
+	type SchemaOptions,
+	type TNull,
+	type TSchema,
+	type TUnion,
+	Type
+} from '@sinclair/typebox'
+
+export const isNullable = Symbol('isNullable')
+
+export type TNullable<T extends TSchema = TSchema> = TUnion<[T, TNull]> & {
+	[isNullable]: 'Nullable'
+} /**
+ * Also sets options.default to null. Set it to something else if you don't want that.
+ */
+
+export function Nullable<T extends TSchema>(
+	schema: T,
+	options: SchemaOptions = {}
+) {
+	const newSchema = Type.Union([schema, Type.Null()], options) as TNullable<T>
+	newSchema[isNullable] = 'Nullable'
+
+	return newSchema
+}
+/** Typeguard */
+export function TNullable(schema: unknown): schema is TNullable {
+	return (schema as TNullable)[isNullable] === 'Nullable'
+}

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

@@ -0,0 +1,16 @@
+import { type TLiteralValue, Type } from '@sinclair/typebox'
+import { mapValues } from 'lodash-es'
+
+/** Transform an object of literal values into a schema representing the object. */
+
+export function ObjectLiteral<T extends Record<string, TLiteralValue>>(
+	object: T
+) {
+	return Type.Object(mapValues(object, (v) => Type.Literal(v)))
+}
+/** Extracts all properties that can be rendered as Type.Literal with typebox */
+export type CanBeLiteral<T> = {
+	[K in keyof T as Required<T>[K] extends TLiteralValue | null | undefined
+		? K
+		: never]: Exclude<T[K], null | undefined>
+}

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

@@ -0,0 +1,4 @@
+import type { TObject } from '@sinclair/typebox'
+
+export type ObjectProperties<T extends TObject> = T['properties']
+export type ObjectPropertyKeys<T extends TObject> = keyof ObjectProperties<T>