mirror of
https://github.com/misode/misode.github.io.git
synced 2026-04-25 08:06:51 +00:00
109 lines
3.3 KiB
TypeScript
109 lines
3.3 KiB
TypeScript
import type { CollectionRegistry, SchemaRegistry } from '@mcschema/core'
|
|
import { DataModel } from '@mcschema/core'
|
|
import * as java15 from '@mcschema/java-1.15'
|
|
import * as java16 from '@mcschema/java-1.16'
|
|
import * as java17 from '@mcschema/java-1.17'
|
|
import * as java18 from '@mcschema/java-1.18'
|
|
import config from '../config.json'
|
|
import { fetchData } from './DataFetcher'
|
|
import { message } from './Utils'
|
|
|
|
export const VersionIds = ['1.15', '1.16', '1.17', '1.18'] as const
|
|
export type VersionId = typeof VersionIds[number]
|
|
|
|
export type BlockStateRegistry = {
|
|
[block: string]: {
|
|
properties?: {
|
|
[key: string]: string[],
|
|
},
|
|
default?: {
|
|
[key: string]: string,
|
|
},
|
|
},
|
|
}
|
|
|
|
type VersionData = {
|
|
collections: CollectionRegistry,
|
|
schemas: SchemaRegistry,
|
|
blockStates: BlockStateRegistry,
|
|
}
|
|
const Versions: Record<string, VersionData | Promise<VersionData>> = {}
|
|
|
|
type ModelData = {
|
|
model: DataModel,
|
|
version: VersionId,
|
|
}
|
|
const Models: Record<string, ModelData> = {}
|
|
|
|
const versionGetter: {
|
|
[versionId in VersionId]: {
|
|
getCollections: () => CollectionRegistry,
|
|
getSchemas: (collections: CollectionRegistry) => SchemaRegistry,
|
|
}
|
|
} = {
|
|
1.15: java15,
|
|
1.16: java16,
|
|
1.17: java17,
|
|
1.18: java18,
|
|
}
|
|
|
|
async function getVersion(id: VersionId): Promise<VersionData> {
|
|
if (!Versions[id]) {
|
|
Versions[id] = (async () => {
|
|
try {
|
|
const collections = versionGetter[id].getCollections()
|
|
const blockStates: BlockStateRegistry = {}
|
|
await fetchData(id, collections, blockStates)
|
|
const schemas = versionGetter[id].getSchemas(collections)
|
|
Versions[id] = { collections, schemas, blockStates }
|
|
return Versions[id]
|
|
} catch (e) {
|
|
throw new Error(`Cannot get version "${id}": ${message(e)}`)
|
|
}
|
|
})()
|
|
return Versions[id]
|
|
}
|
|
return Versions[id]
|
|
}
|
|
|
|
export async function getModel(version: VersionId, id: string): Promise<DataModel> {
|
|
if (!Models[id] || Models[id].version !== version) {
|
|
const versionData = await getVersion(version)
|
|
const schemaName = config.generators.find(g => g.id === id)?.schema
|
|
if (!schemaName) {
|
|
throw new Error(`Cannot find model ${id}`)
|
|
}
|
|
try {
|
|
const schema = versionData.schemas.get(schemaName)
|
|
const model = new DataModel(schema, { wrapLists: true })
|
|
if (Models[id]) {
|
|
model.reset(Models[id].model.data, false)
|
|
} else {
|
|
model.validate(true)
|
|
model.history = [JSON.stringify(model.data)]
|
|
}
|
|
Models[id] = { model, version }
|
|
} catch (e) {
|
|
throw new Error(`Cannot get generator "${id}" for version "${version}": ${message(e)}`)
|
|
}
|
|
}
|
|
return Models[id].model
|
|
}
|
|
|
|
export async function getCollections(version: VersionId): Promise<CollectionRegistry> {
|
|
const versionData = await getVersion(version)
|
|
return versionData.collections
|
|
}
|
|
|
|
export async function getBlockStates(version: VersionId): Promise<BlockStateRegistry> {
|
|
const versionData = await getVersion(version)
|
|
return versionData.blockStates
|
|
}
|
|
|
|
export function checkVersion(versionId: string, minVersionId: string | undefined, maxVersionId?: string) {
|
|
const version = config.versions.findIndex(v => v.id === versionId)
|
|
const minVersion = minVersionId ? config.versions.findIndex(v => v.id === minVersionId) : 0
|
|
const maxVersion = maxVersionId ? config.versions.findIndex(v => v.id === maxVersionId) : config.versions.length - 1
|
|
return minVersion <= version && version <= maxVersion
|
|
}
|