@datasworn-community/build-tools 0.2.2 → 0.2.3

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

@@ -7,11 +7,13 @@ import {
 	Type
 } from '@sinclair/typebox'
 
+import { IdElements } from '@datasworn-community/core'
 import ids from '../../builders/IdBuilder.js'
-import Pattern from '../../pkg-core/IdElements/Pattern.js'
 import JtdType from '../../scripts/json-typedef/typedef.js'
 import { JsonTypeDef } from '../Symbols.js'
 
+import Pattern = IdElements.Pattern
+
 export const RulesetId = Type.String({
 	$id: 'RulesetId',
 	examples: ['classic', 'starforged'],

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

@@ -5,7 +5,9 @@ import {
 	type TString,
 	Type
 } from '@sinclair/typebox'
-import type TypeId from '../../pkg-core/IdElements/TypeId.js'
+import { IdElements } from '@datasworn-community/core'
+
+import type TypeId = IdElements.TypeId
 import { Computed } from '../Utils.js'
 import { pascalCase } from '../utils/string.js'
 

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

@@ -1,6 +1,8 @@
 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 { IdElements } from '@datasworn-community/core'
+
+import type TypeId = IdElements.TypeId
 import { setSourceDataSchema } from '../Utils.js'
 import { pascalCase } from '../utils/string.js'
 import { PrimarySubtypeNode, PrimaryTypeNode } from './PrimaryTypeNode.js'

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

@@ -9,7 +9,7 @@ import {
 	Type
 } from '@sinclair/typebox'
 import type { SetRequired } from 'type-fest'
-import TypeId from '../../pkg-core/IdElements/TypeId.js'
+import { IdElements } from '@datasworn-community/core'
 import {
 	CollectionsKey,
 	ContentsKey,
@@ -19,6 +19,8 @@ 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 TypeId = IdElements.TypeId
 import { Dictionary, type TDictionary } from './Dictionary.js'
 import { PrimarySubtypeNode, PrimaryTypeNode } from './PrimaryTypeNode.js'
 

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

@@ -1,5 +1,7 @@
 import { type ObjectOptions, type TObject, Type } from '@sinclair/typebox'
-import type TypeId from '../../pkg-core/IdElements/TypeId.js'
+import { IdElements } from '@datasworn-community/core'
+
+import type TypeId = IdElements.TypeId
 import { pascalCase } from '../utils/string.js'
 import { IdNode } from './IdNode.js'
 

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

@@ -1,5 +1,7 @@
 import type { ObjectOptions, TObject } from '@sinclair/typebox'
-import type TypeId from '../../pkg-core/IdElements/TypeId.js'
+import { IdElements } from '@datasworn-community/core'
+
+import type TypeId = IdElements.TypeId
 import { setSourceDataSchema } from '../Utils.js'
 import { pascalCase } from '../utils/string.js'
 import { PrimaryTypeNode } from './PrimaryTypeNode.js'

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

@@ -6,7 +6,9 @@ import {
 	Type
 } from '@sinclair/typebox'
 import type { SetRequired } from 'type-fest'
-import type TypeId from '../../pkg-core/IdElements/TypeId.js'
+import { IdElements } from '@datasworn-community/core'
+
+import type TypeId = IdElements.TypeId
 import { CssColor, SvgImageUrl, WebpImageUrl } from '../common/Metadata.js'
 import { SourcedNode } from '../generic/SourcedNode.js'
 import { Discriminable } from '../Utils.js'

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

@@ -1,5 +1,5 @@
 import { type Static, Type } from '@sinclair/typebox'
-import TypeId from '../../pkg-core/IdElements/TypeId.js'
+import { IdElements } from '@datasworn-community/core'
 import JtdType from '../../scripts/json-typedef/typedef.js'
 import Id, { RulesetId } from '../common/Id.js'
 import { DiceExpression } from '../common/Rolls.js'
@@ -9,6 +9,8 @@ import { Nullable, UnionEnum } from '../Utils.js'
 import { type PascalCase, pascalCase } from '../utils/string.js'
 import { TagSchema } from './TagSchema.js'
 
+import TypeId = IdElements.TypeId
+
 type _NodeSchemaName<T extends string> = PascalCase<T>
 type EmbeddedNodeSchemaName<T extends string> = `Embedded${PascalCase<T>}`
 type IdSchemaName<T extends string> = `${PascalCase<T>}Id`

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

@@ -10,7 +10,7 @@ import {
 	Type
 } from '@sinclair/typebox'
 import type { Writable } from 'type-fest'
-import TypeId from '../../pkg-core/IdElements/TypeId.js'
+import { IdElements } from '@datasworn-community/core'
 import {
 	EnhancesKey,
 	IdKey,
@@ -19,6 +19,8 @@ import {
 	type TypeSep
 } from '../../scripts/const.js'
 import { Computed } from './Computed.js'
+
+import TypeId = IdElements.TypeId
 import { pascalCase } from './string.js'
 
 const EmbeddedDictionaryKeys = Object.values(TypeId.BranchKey)

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

@@ -1,13 +1,13 @@
 import { camelCase } from 'lodash-es'
 import type { PascalCase as PascalCaseNoDot } from 'type-fest'
-import type { Join, Split } from '../../pkg-core/Utils/String.js'
+import type { Utils } from '@datasworn-community/core'
 
 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, '.'>, '_'>
+	Utils.Join<Utils.Split<T, '.'>, '_'>
 >
 
 export function pascalCase<Str extends string = string>(str: Str) {

package/schema-source/scripts/augmentations.ts

@@ -0,0 +1,70 @@
+import { type Kind, type Static, type TSchema, Type } from '@sinclair/typebox'
+import { DiceExpression } from '../schema/common/Rolls.js'
+import type {
+	Inherits,
+	JsonTypeDef,
+	Namespace,
+	Simplify,
+	Typescript
+} from '../schema/Symbols.js'
+import { UnionEnum } from '../schema/Utils.js'
+import type { Metadata } from './json-typedef/typedef.js'
+
+export const Keywords = {
+	releaseStage: UnionEnum(['experimental', 'release'], {
+		default: 'release'
+	}),
+	i18n: Type.Boolean({ default: false }),
+	deprecated: Type.Boolean({ default: false }),
+	remarks: Type.String(),
+	rollable: Type.Union([Type.Boolean(), DiceExpression], {
+		description:
+			'This array represents rows in a rollable table. If `true`, use the `dice` property of the parent object to roll. Alternatively, provide a dice expression to use.',
+		default: false
+	})
+} as const
+
+type TypeParamCodeGenData = {
+	/** Default value for the type parameter. */
+	default?: string
+	parameters?: Record<string, TypeParamCodeGenData>
+	constraint?: string
+}
+
+type TypeCodeGenData = {
+	id: string
+	/**
+	 * Key is the type generic parameter ID (e.g. `TType`).
+	 */
+	parameters?: Record<string, TypeParamCodeGenData>
+}
+
+declare module '@sinclair/typebox' {
+	interface SchemaOptions {
+		rollable?: Static<typeof Keywords.rollable>
+		remarks?: Static<typeof Keywords.remarks>
+		releaseStage?: Static<typeof Keywords.releaseStage>
+		deprecated?: Static<typeof Keywords.deprecated>
+		[Namespace]?: string
+		[Inherits]?: TypeCodeGenData[]
+		/** A less complex alternate version of the schema for use with code generation tools. */
+		[Simplify]?: TSchema
+		[Typescript]?: (identifier: string, schema: TSchema) => string
+		[JsonTypeDef]?: {
+			/** JTD schema to override the automatic conversion. Schema metadata will automatically be inherited from the JSON schema. */
+			schema?: TSchema & { [Kind]: `TypeDef:${string}` }
+			/** If true, this schema will be ignored when generating JTD schema. */
+			skip?: boolean
+			metadata?: Metadata
+		}
+	}
+	interface StringOptions extends SchemaOptions {
+		i18n?: Static<typeof Keywords.i18n>
+	}
+}
+
+declare global {
+	interface ObjectConstructor {
+		keys<T extends object>(object: T): (keyof T)[]
+	}
+}

package/schema-source/scripts/codegen/schemaToTsDeclaration.ts

@@ -0,0 +1,290 @@
+import {
+	Kind,
+	type TArray,
+	type TObject,
+	type TSchema,
+	type TTuple,
+	TypeGuard
+} from '@sinclair/typebox'
+import {
+	isEqual,
+	isNull,
+	isUndefined,
+	map,
+	mapValues,
+	pick,
+	repeat,
+	uniq
+} from 'lodash-es'
+import { Typescript } from '../../schema/Symbols.js'
+import {
+	TDiscriminatedUnion,
+	TNullable,
+	TUnionEnum
+} from '../../schema/Utils.js'
+import { $schema } from '../const.js'
+import Log from '../utils/Log.js'
+
+export function extractDefs(defs: Record<string, TSchema>) {
+	return mapValues(defs, (v, k) => renderDefinition(k, v))
+}
+
+// keywords where they can be included close to as-is. boolean keywords generally have their value omitted, leaving just the tag: "@i18n" rather than "@i18n true"
+const extractableKeywords: string[] = [
+	'minimum',
+	'maximum',
+	'i18n',
+	'deprecated'
+]
+
+// keywords where a string value is expected, and the string value is the keyword
+const extractableKeywordValues: string[] = ['releaseStage']
+
+function extractKeywords(schema: TSchema) {
+	const jsDoc: string[] = []
+
+	if (schema.description) jsDoc.push(schema.description)
+	if (schema.remarks) jsDoc.push(tag('remarks', schema.remarks))
+	if (schema.pattern)
+		jsDoc.push(tag('pattern', wrapCodeBlock(`/${schema.pattern}/`)))
+	if (schema.examples)
+		jsDoc.push(
+			...schema.examples
+				.filter(
+					(example: unknown) =>
+						typeof example !== 'string' || !example.includes('*')
+				)
+				.map((example: unknown) => {
+					let tagContent = renderJsValue(example)
+					if (tagContent.includes('\n'))
+						tagContent = formatSourceCode(tagContent)
+
+					return tag('example', tagContent)
+				})
+		)
+	if (!isUndefined(schema.default)) {
+		if (!isEqual(schema.default, schema.const)) {
+			let tagContent = renderJsValue(schema.default)
+			if (tagContent.includes('\n'))
+				tagContent = `\n${formatSourceCode(tagContent)}`
+			jsDoc.push(tag('default', tagContent))
+		}
+	}
+
+	jsDoc.push(
+		...toTags(
+			mapValues(pick(schema, ...extractableKeywords), (v, _k) =>
+				v === true ? undefined : v
+			)
+		)
+	)
+
+	jsDoc.push(
+		...Object.values(pick(schema, ...extractableKeywordValues)).map((k) =>
+			tag(k as string)
+		)
+	)
+
+	return jsDoc
+}
+
+function renderJsDoc(lines: string[]) {
+	return [
+		'/**',
+		...lines
+			.join('\n')
+			.split('\n')
+			.map((line) => ` * ${line}`),
+		' */'
+	].join('\n')
+}
+
+function extractType(schema: TSchema): string {
+	switch (true) {
+		case TypeGuard.IsIntersect(schema):
+			return uniq(schema.allOf.map(extractType))
+				.map((type) => (type.includes('|') ? `(${type})` : type))
+				.join(' & ')
+
+		case TypeGuard.IsThis(schema):
+		case TypeGuard.IsRef(schema):
+			// special case: embedded schema
+			return schema.$ref === $schema ? 'unknown' : schema.$ref
+		case TypeGuard.IsLiteral(schema):
+			return JSON.stringify(schema.const)
+		case TypeGuard.IsInteger(schema):
+			return 'number'
+		case TypeGuard.IsString(schema):
+		case TypeGuard.IsBoolean(schema):
+		case TypeGuard.IsNull(schema):
+		case TypeGuard.IsNumber(schema):
+			return schema.type
+		case TypeGuard.IsTuple(schema):
+			return extractTupleType(schema)
+		case TypeGuard.IsArray(schema):
+			return extractArrayType(schema)
+		case schema[Kind] === 'Object':
+		case TypeGuard.IsObject(schema):
+			return extractObjectLiteralType(schema as any)
+		case TypeGuard.IsUnion(schema):
+		case schema[Kind] === 'Union':
+		case TNullable(schema):
+			return uniq(schema.anyOf.map(extractType)).join(' | ')
+		case TypeGuard.IsRecord(schema): {
+			const keyType = 'DictKey'
+			const valueType = extractType(Object.values(schema.patternProperties)[0])
+			return `Record<${keyType}, ${valueType}>`
+		}
+		case TDiscriminatedUnion(schema):
+			return uniq(schema.allOf.map((item) => extractType(item.then))).join(
+				' | '
+			)
+		case TUnionEnum(schema):
+			return uniq(schema.enum.map((v) => JSON.stringify(v))).join(' | ')
+
+		default: {
+			Log.info(JSON.stringify(schema))
+			throw new Error(
+				`missing transform for kind of ${JSON.stringify(schema?.$id)}: ${JSON.stringify(schema[Kind])}`
+			)
+		}
+	}
+}
+
+function extractArrayType(schema: TArray<TSchema>): string {
+	const innerType = extractType(schema.items)
+	const isComplexType = innerType.match(/[^A-z]/)
+	return isComplexType ? `Array<${innerType}>` : `${innerType}[]`
+}
+
+type ParsedType = { type: string; jsDoc: string[] }
+
+function parseType(schema: TSchema): ParsedType {
+	return {
+		type: extractType(schema),
+		jsDoc: extractKeywords(schema)
+	}
+}
+
+function indent(text: string, levels = 1) {
+	const indentString = repeat('\t', levels)
+	return text
+		.replaceAll(/\n/g, `\n${indentString}`)
+		.replaceAll(/^/g, indentString)
+}
+
+function renderProperty(key: string, schema: TSchema) {
+	let head = key
+	if (TypeGuard.IsOptional(schema)) head += '?'
+	const { type, jsDoc } = parseType(schema)
+
+	const lines = []
+
+	if (jsDoc.length > 0) lines.push(renderJsDoc(jsDoc))
+
+	lines.push(`${head}: ${type};`)
+
+	return lines.join('\n')
+}
+
+function renderTypeAlias(identifier: string, schema: TSchema) {
+	const data = parseType(schema)
+	const lines = []
+
+	if (data.jsDoc.length > 0) lines.push(renderJsDoc(data.jsDoc))
+
+	lines.push(`export type ${identifier} = ${data.type}`)
+
+	return lines.join('\n')
+}
+
+function renderInterface(identifier: string, schema: TObject) {
+	const data = parseType(schema)
+
+	const lines = []
+
+	if (data.jsDoc.length > 0) lines.push(renderJsDoc(data.jsDoc))
+
+	lines.push(`export interface ${identifier} ${data.type}`)
+
+	return lines.join('\n')
+}
+
+function extractObjectLiteralType(schema: TObject): string {
+	const properties = Object.entries(schema.properties).map((entry) =>
+		renderProperty(...entry)
+	)
+	const typeLines = [`{`, indent(properties.join('\n')), `}`]
+
+	return typeLines.join('\n')
+}
+
+function extractTupleType(schema: TTuple): string {
+	const items = (schema.items as TSchema[]).map(extractType)
+	return [`[`, indent(items.join(',\n')), `]`].join('\n')
+}
+
+function tag(tag: string, text?: string) {
+	if (text) return `@${tag} ${text}`
+	return `@${tag}`
+}
+
+function toTags(tags: Record<string, string | undefined>) {
+	return Object.entries(tags).map((strings) => tag(...strings))
+}
+
+function renderDefinition(identifier: string, schema: TSchema) {
+	switch (true) {
+		case Typescript in schema:
+			return schema[Typescript]?.(identifier, schema)
+		case TypeGuard.IsObject(schema):
+			return renderInterface(identifier, schema)
+		default:
+			return renderTypeAlias(identifier, schema)
+	}
+}
+
+function renderJsValue(value: unknown): string {
+	let result: string
+	switch (true) {
+		case Array.isArray(value):
+			result =
+				value.length === 0 ? '[]' : `[ ${value.map(renderJsValue).join(', ')} ]`
+			break
+		case isUndefined(value):
+			result = 'undefined'
+			break
+		case isNull(value):
+			result = 'null'
+			break
+
+		case typeof value === 'object':
+			result =
+				Object.keys(value as any).length === 0
+					? '{}'
+					: `{\n${indent(
+							map(value as any, (v, k) => `${k}: ${renderJsValue(v)}`).join(
+								',\n'
+							)
+						)}\n}`
+			break
+		case typeof value === 'string':
+		case typeof value === 'number':
+		case typeof value === 'boolean':
+			result = JSON.stringify(value)
+			break
+		default:
+			throw new Error()
+	}
+	return result
+}
+
+function wrapCodeBlock(code: string) {
+	return `\`\`\`javascript\n${code}\n\`\`\``
+}
+
+function formatSourceCode(code: string) {
+	if (code.includes('\n')) code = wrapCodeBlock(indent(code))
+
+	return code
+}

package/schema-source/scripts/codegen/tsDocTags.ts

@@ -0,0 +1,75 @@
+// @alpha
+// @beta
+// @category
+// @defaultValue
+// @deprecated
+// @enum
+// @event
+// @eventProperty
+// @example
+// @experimental
+// @group
+// @hidden
+// @ignore
+// {@inheritDoc}
+// @interface
+// @internal
+// {@label}
+// {@link}
+// @module
+// @namespace
+// @overload
+// @override
+// @packageDocumentation
+// @param
+// @private
+// @privateRemarks
+// @property
+// @protected
+// @public
+// @readonly
+// @remarks
+// @returns
+// @satisfies
+// @sealed
+// @see
+// @template
+// @throws
+// @typeParam
+
+import { Type } from '@sinclair/typebox'
+import type { KeywordDefinition } from 'ajv'
+
+// @virtual
+const _tags: Record<string, Omit<KeywordDefinition, 'keyword'>> = {
+	alpha: { metaSchema: Type.Boolean() },
+	beta: { metaSchema: Type.Boolean() },
+	category: { metaSchema: Type.String() },
+	deprecated: { metaSchema: Type.Boolean() },
+	event: { metaSchema: Type.Boolean() },
+	eventProperty: { metaSchema: Type.Boolean() },
+	example: { metaSchema: Type.Boolean() },
+	experimental: { metaSchema: Type.Boolean() },
+	group: { metaSchema: Type.Array(Type.String()) },
+	hidden: { metaSchema: Type.Boolean() },
+	ignore: { metaSchema: Type.Boolean() },
+	interface: { metaSchema: Type.Boolean() },
+	internal: { metaSchema: Type.Boolean() },
+	namespace: { metaSchema: Type.Array(Type.String()) },
+	overload: { metaSchema: Type.Boolean() },
+	override: { metaSchema: Type.Boolean() },
+	packageDocumentation: { metaSchema: Type.Boolean() },
+	param: { metaSchema: Type.Boolean() },
+	private: { metaSchema: Type.Boolean() },
+	privateRemarks: { metaSchema: Type.String() },
+	property: { metaSchema: Type.Boolean() },
+	remarks: { metaSchema: Type.String() },
+	returns: { metaSchema: Type.Boolean() },
+	satisfies: { metaSchema: Type.Boolean() },
+	sealed: { metaSchema: Type.Boolean() },
+	see: { metaSchema: Type.Array(Type.String()) },
+	template: { metaSchema: Type.Boolean() },
+	throws: { metaSchema: Type.Boolean() },
+	typeParam: { metaSchema: Type.Boolean() },
+	virtual: { metaSchema: Type.Boolean() }
+}

package/schema-source/scripts/codegen/writeTypescriptTypes.ts

@@ -0,0 +1,35 @@
+import path from 'node:path'
+import { DataswornSchema, DataswornSourceSchema } from '../../schema/Root.js'
+import {
+	CORE_COMMON,
+	DefsKey,
+	DIR_HISTORY_CURRENT,
+	ROOT_TYPES_OUT
+} from '../const.js'
+import { emptyDir, writeCode } from '../utils/readWrite.js'
+import { extractDefs } from './schemaToTsDeclaration.js'
+
+const rootSchemas = {
+	Datasworn: DataswornSchema,
+	DataswornSource: DataswornSourceSchema
+} satisfies Record<string, unknown>
+
+await emptyDir(ROOT_TYPES_OUT)
+
+const writeJobs: Promise<void>[] = []
+
+for (const identifier in rootSchemas) {
+	const value = rootSchemas[identifier as keyof typeof rootSchemas]
+
+	const paths = [
+		path.join(ROOT_TYPES_OUT, `${identifier}.d.ts`),
+		path.join(CORE_COMMON, `${identifier}.ts`),
+		path.join(DIR_HISTORY_CURRENT, `${identifier}.d.ts`)
+	]
+
+	const fileContents = Object.values(extractDefs(value[DefsKey])).join('\n\n')
+
+	for (const path of paths) writeJobs.push(writeCode(path, fileContents))
+}
+
+await Promise.all(writeJobs)

package/schema-source/scripts/const.ts

@@ -1,5 +1,5 @@
 import path from 'node:path'
-import { DATASWORN_SCHEMA_VERSION } from '@datasworn-community/core'
+import { DATASWORN_SCHEMA_VERSION, IdElements } from '@datasworn-community/core'
 
 const root = process.cwd()
 
@@ -16,7 +16,12 @@ export const ROOT_OUTPUT = path.join(root, 'datasworn')
 export const ROOT_SOURCE_DATA = path.join(root, 'source_data')
 export const ROOT_HISTORY = path.join(root, 'packages/core/migration')
 export const DIR_HISTORY_CURRENT = path.join(ROOT_HISTORY, VERSION)
-export const ROOT_TYPES_OUT = path.join(root, 'packages/core/src')
+// Disposable scratch copy of generated types, emptied and rewritten on every
+// `generate` run. Must stay distinct from CORE_COMMON: writeTypescriptTypes
+// empties this directory before writing, and CORE_COMMON holds core's
+// hand-written runtime source alongside the generated Datasworn.ts/
+// DataswornSource.ts files.
+export const ROOT_TYPES_OUT = path.join(root, '.generated/types')
 export const CORE_COMMON = path.join(root, 'packages/core/src')
 
 export const SCHEMA_PATH = path.join(
@@ -53,3 +58,36 @@ export const DefsKey = 'definitions' as const
 
 /** Identifier for the type at the root of a Datasworn JSON file. */
 export const rootSchemaName = 'RulesPackage'
+
+// Re-exported from core's IdElements/CONST.js. Upstream colocates these
+// scripts with pkg-core under one `src/`, so its const.ts can `export *`
+// straight from the relative path; here build-tools and core are separate
+// workspace packages, so the keys are re-exported through core's public API.
+export const COLLECTION_DEPTH_MAX = IdElements.CONST.COLLECTION_DEPTH_MAX
+export type COLLECTION_DEPTH_MAX = typeof COLLECTION_DEPTH_MAX
+export const COLLECTION_DEPTH_MIN = IdElements.CONST.COLLECTION_DEPTH_MIN
+export type COLLECTION_DEPTH_MIN = typeof COLLECTION_DEPTH_MIN
+export const MdLinkPrefix = IdElements.CONST.MdLinkPrefix
+export type MdLinkPrefix = typeof MdLinkPrefix
+export const PathKeySep = IdElements.CONST.PathKeySep
+export type PathKeySep = typeof PathKeySep
+export const TypeSep = IdElements.CONST.TypeSep
+export type TypeSep = typeof TypeSep
+export const PrefixSep = IdElements.CONST.PrefixSep
+export type PrefixSep = typeof PrefixSep
+export const WildcardString = IdElements.CONST.WildcardString
+export type WildcardString = typeof WildcardString
+export const GlobstarString = IdElements.CONST.GlobstarString
+export type GlobstarString = typeof GlobstarString
+export const CollectionsKey = IdElements.CONST.CollectionsKey
+export type CollectionsKey = typeof CollectionsKey
+export const ContentsKey = IdElements.CONST.ContentsKey
+export type ContentsKey = typeof ContentsKey
+export const EnhancesKey = IdElements.CONST.EnhancesKey
+export type EnhancesKey = typeof EnhancesKey
+export const ReplacesKey = IdElements.CONST.ReplacesKey
+export type ReplacesKey = typeof ReplacesKey
+export const IdKey = IdElements.CONST.IdKey
+export type IdKey = typeof IdKey
+export const SourceInfoKey = IdElements.CONST.SourceInfoKey
+export type SourceInfoKey = typeof SourceInfoKey