Function parseNode

ark/schema/parse.ts:151–218

(ctx: NodeParseContext)

}

export const parseNode = (ctx: NodeParseContext): BaseNode => {
	const impl = nodeImplementationsByKind[ctx.kind]
	const configuredSchema =
		impl.applyConfig?.(ctx.def, ctx.$.resolvedConfig) ?? ctx.def
	const inner: dict = {}
	const { meta: metaSchema, ...innerSchema } = configuredSchema as dict & {
		meta?: TypeMeta.Collapsible
	}

	const meta: ArkEnv.meta & dict =
		metaSchema === undefined ? {}
		: typeof metaSchema === "string" ? { description: metaSchema }
		: (metaSchema as never)

	// ensure node entries are parsed in order of precedence, with non-children
	// parsed first
	const innerSchemaEntries = entriesOf(innerSchema)
		.sort(([lKey], [rKey]) =>
			isNodeKind(lKey) ?
				isNodeKind(rKey) ? precedenceOfKind(lKey) - precedenceOfKind(rKey)
				:	1
			: isNodeKind(rKey) ? -1
			: lKey < rKey ? -1
			: 1
		)
		.filter(([k, v]) => {
			// move meta. prefixed props to meta, overwriting existing nested
			// props of the same name if they exist
			if (k.startsWith("meta.")) {
				const metaKey = k.slice(5)
				meta[metaKey] = v
				return false
			}
			return true
		})

	for (const entry of innerSchemaEntries) {
		const k = entry[0]
		const keyImpl = impl.keys[k]
		if (!keyImpl)
			return throwParseError(`Key ${k} is not valid on ${ctx.kind} schema`)

		const v = keyImpl.parse ? keyImpl.parse(entry[1], ctx) : entry[1]
		if (v !== unset && (v !== undefined || keyImpl.preserveUndefined))
			inner[k] = v
	}

	if (impl.reduce && !ctx.prereduced) {
		const reduced = impl.reduce(inner, ctx.$)
		if (reduced) {
			if (reduced instanceof Disjoint) return reduced.throw()

			// we can't cache this reduction for now in case the reduction involved
			// impliedSiblings
			return withMeta(reduced, meta)
		}
	}