@wener/common 1.0.4 → 2.0.1

package/src/resource/schema/ResourceActionType.ts

@@ -0,0 +1,123 @@
+import { z } from 'zod/v4';
+import type { EnumValues } from './types';
+
+export const ResourceActionType = Object.freeze({
+	__proto__: null,
+	Approve: 'Approve',
+	AssignOwner: 'AssignOwner',
+	Bind: 'Bind',
+	BindCustomer: 'BindCustomer',
+	BindEntity: 'BindEntity',
+	BindUser: 'BindUser',
+	Cancel: 'Cancel',
+	ChangePassword: 'ChangePassword',
+	ClaimOwner: 'ClaimOwner',
+	Close: 'Close',
+	Communicate: 'Communicate',
+	Complete: 'Complete',
+	Create: 'Create',
+	Delete: 'Delete',
+	Deny: 'Deny',
+	Disable: 'Disable',
+	Download: 'Download',
+	Edit: 'Edit',
+	Enable: 'Enable',
+	List: 'List',
+	Login: 'Login',
+	Logout: 'Logout',
+	Manage: 'Manage',
+	Publish: 'Publish',
+	Purge: 'Purge',
+	Read: 'Read',
+	Reject: 'Reject',
+	ReleaseOwner: 'ReleaseOwner',
+	ResetPassword: 'ResetPassword',
+	ReturnForRevision: 'ReturnForRevision',
+	Revise: 'Revise',
+	SaveDraft: 'SaveDraft',
+	Signup: 'Signup',
+	Submit: 'Submit',
+	SubmitAgency: 'SubmitAgency',
+	SubmitVendor: 'SubmitVendor',
+	Suspend: 'Suspend',
+	Terminate: 'Terminate',
+	Timeout: 'Timeout',
+	Unbind: 'Unbind',
+	UnbindCustomer: 'UnbindCustomer',
+	UnbindEntity: 'UnbindEntity',
+	UnbindUser: 'UnbindUser',
+	Undelete: 'Undelete',
+	Unpublish: 'Unpublish',
+	Update: 'Update',
+	UpdateNotes: 'UpdateNotes',
+	UpdateTags: 'UpdateTags',
+	Upload: 'Upload',
+	Validate: 'Validate',
+	View: 'View',
+	Write: 'Write',
+} as const);
+export type ResourceActionType = EnumValues<typeof ResourceActionType>;
+export const ResourceActionTypeSchema = z
+	.union([
+		z.literal(ResourceActionType.Approve).describe('批准'),
+		z.literal(ResourceActionType.AssignOwner).describe('分配负责人'),
+		z.literal(ResourceActionType.Bind).describe('绑定'),
+		z.literal(ResourceActionType.BindCustomer).describe('绑定客户'),
+		z.literal(ResourceActionType.BindEntity).describe('绑定实体'),
+		z.literal(ResourceActionType.BindUser).describe('绑定用户'),
+		z.literal(ResourceActionType.Cancel).describe('取消'),
+		z.literal(ResourceActionType.ChangePassword).describe('修改密码'),
+		z.literal(ResourceActionType.ClaimOwner).describe('认领负责人'),
+		z.literal(ResourceActionType.Close).describe('关闭'),
+		z.literal(ResourceActionType.Communicate).describe('沟通'),
+		z.literal(ResourceActionType.Complete).describe('完成'),
+		z.literal(ResourceActionType.Create).describe('创建'),
+		z.literal(ResourceActionType.Delete).describe('删除'),
+		z.literal(ResourceActionType.Deny).describe('拒绝'),
+		z.literal(ResourceActionType.Disable).describe('禁用'),
+		z.literal(ResourceActionType.Download).describe('下载'),
+		z.literal(ResourceActionType.Edit).describe('编辑'),
+		z.literal(ResourceActionType.Enable).describe('启用'),
+		z.literal(ResourceActionType.List).describe('列表'),
+		z.literal(ResourceActionType.Login).describe('登录'),
+		z.literal(ResourceActionType.Logout).describe('登出'),
+		z.literal(ResourceActionType.Manage).describe('管理'),
+		z.literal(ResourceActionType.Publish).describe('发布'),
+		z.literal(ResourceActionType.Purge).describe('彻底删除'),
+		z.literal(ResourceActionType.Read).describe('读取'),
+		z.literal(ResourceActionType.Reject).describe('驳回'),
+		z.literal(ResourceActionType.ReleaseOwner).describe('释放负责人'),
+		z.literal(ResourceActionType.ResetPassword).describe('重置密码'),
+		z.literal(ResourceActionType.ReturnForRevision).describe('退回修订'),
+		z.literal(ResourceActionType.Revise).describe('修订'),
+		z.literal(ResourceActionType.SaveDraft).describe('保存草稿'),
+		z.literal(ResourceActionType.Signup).describe('注册'),
+		z.literal(ResourceActionType.Submit).describe('提交'),
+		z.literal(ResourceActionType.SubmitAgency).describe('提交机构'),
+		z.literal(ResourceActionType.SubmitVendor).describe('提交供应商'),
+		z.literal(ResourceActionType.Suspend).describe('暂停'),
+		z.literal(ResourceActionType.Terminate).describe('终止'),
+		z.literal(ResourceActionType.Timeout).describe('超时'),
+		z.literal(ResourceActionType.Unbind).describe('解绑'),
+		z.literal(ResourceActionType.UnbindCustomer).describe('解绑客户'),
+		z.literal(ResourceActionType.UnbindEntity).describe('解绑实体'),
+		z.literal(ResourceActionType.UnbindUser).describe('解绑用户'),
+		z.literal(ResourceActionType.Undelete).describe('恢复删除'),
+		z.literal(ResourceActionType.Unpublish).describe('取消发布'),
+		z.literal(ResourceActionType.Update).describe('更新'),
+		z.literal(ResourceActionType.UpdateNotes).describe('修改备注'),
+		z.literal(ResourceActionType.UpdateNotes).describe('更新备注'),
+		z.literal(ResourceActionType.UpdateTags).describe('更新标签'),
+		z.literal(ResourceActionType.Upload).describe('上传'),
+		z.literal(ResourceActionType.Validate).describe('校验'),
+		z.literal(ResourceActionType.View).describe('查看'),
+		z.literal(ResourceActionType.Write).describe('写入'),
+	])
+	.meta({
+		title: 'ResourceAction',
+		description: '资源操作',
+		type: 'string',
+	});
+export const ResourceActionDataSchema = z.object({
+	reason: z.string().optional().describe('操作原因'),
+});

package/src/resource/schema/ResourceStatus.ts

@@ -0,0 +1,94 @@
+import { z } from 'zod/v4';
+import type { EnumValues } from './types';
+
+export const ResourceStatus = Object.freeze({
+	__proto__: null,
+	Active: 'Active',
+	Approved: 'Approved',
+	Cancelled: 'Cancelled',
+	Closed: 'Closed',
+	Completed: 'Completed',
+	Confirmed: 'Confirmed',
+	Contacted: 'Contacted',
+	Contacting: 'Contacting',
+	Deleted: 'Deleted',
+	Denied: 'Denied',
+	Disabled: 'Disabled',
+	Disqualified: 'Disqualified',
+	Draft: 'Draft',
+	Enabled: 'Enabled',
+	Expired: 'Expired',
+	Failed: 'Failed',
+	InProgress: 'InProgress',
+	Inactive: 'Inactive',
+	Initial: 'Initial',
+	Lost: 'Lost',
+	New: 'New',
+	Nurturing: 'Nurturing',
+	OnHold: 'OnHold',
+	Open: 'Open',
+	Overdue: 'Overdue',
+	Paid: 'Paid',
+	PartiallyPaid: 'PartiallyPaid',
+	Pending: 'Pending',
+	PendingAcceptance: 'PendingAcceptance',
+	PendingApproval: 'PendingApproval',
+	PendingConfirmation: 'PendingConfirmation',
+	PendingResubmission: 'PendingResubmission',
+	Posted: 'Posted',
+	Published: 'Published',
+	Qualified: 'Qualified',
+	Rejected: 'Rejected',
+	Submitted: 'Submitted',
+	Suspended: 'Suspended',
+	Terminated: 'Terminated',
+	Unqualified: 'Unqualified',
+	Void: 'Void',
+	Won: 'Won',
+} as const);
+export type ResourceStatus = EnumValues<typeof ResourceStatus>;
+export const ResourceStatusSchema = z
+	.union([
+		z.literal(ResourceStatus.Active).describe('活跃'),
+		z.literal(ResourceStatus.Approved).describe('已通过'),
+		z.literal(ResourceStatus.Cancelled).describe('已取消'),
+		z.literal(ResourceStatus.Closed).describe('已关闭'),
+		z.literal(ResourceStatus.Completed).describe('已完成'),
+		z.literal(ResourceStatus.Confirmed).describe('已确认'),
+		z.literal(ResourceStatus.Contacted).describe('已联系'),
+		z.literal(ResourceStatus.Contacting).describe('联系中'),
+		z.literal(ResourceStatus.Deleted).describe('已删除'),
+		z.literal(ResourceStatus.Denied).describe('已拒绝'),
+		z.literal(ResourceStatus.Disabled).describe('已禁用'),
+		z.literal(ResourceStatus.Disqualified).describe('不合格'),
+		z.literal(ResourceStatus.Draft).describe('草稿'),
+		z.literal(ResourceStatus.Enabled).describe('已启用'),
+		z.literal(ResourceStatus.Expired).describe('已过期'),
+		z.literal(ResourceStatus.InProgress).describe('进行中'),
+		z.literal(ResourceStatus.Inactive).describe('停用'),
+		z.literal(ResourceStatus.Initial).describe('初始'),
+		z.literal(ResourceStatus.Lost).describe('已失去'),
+		z.literal(ResourceStatus.New).describe('新建'),
+		z.literal(ResourceStatus.Nurturing).describe('培育中'),
+		z.literal(ResourceStatus.OnHold).describe('搁置'),
+		z.literal(ResourceStatus.Open).describe('开放'),
+		z.literal(ResourceStatus.Overdue).describe('逾期'),
+		z.literal(ResourceStatus.Paid).describe('已支付'),
+		z.literal(ResourceStatus.PartiallyPaid).describe('部分支付'),
+		z.literal(ResourceStatus.Pending).describe('待审核'),
+		z.literal(ResourceStatus.PendingAcceptance).describe('待接受'),
+		z.literal(ResourceStatus.PendingApproval).describe('待批准'),
+		z.literal(ResourceStatus.PendingConfirmation).describe('待确认'),
+		z.literal(ResourceStatus.PendingResubmission).describe('待重新提交'),
+		z.literal(ResourceStatus.Posted).describe('已过账'),
+		z.literal(ResourceStatus.Published).describe('已发布'),
+		z.literal(ResourceStatus.Qualified).describe('已合格'),
+		z.literal(ResourceStatus.Rejected).describe('已驳回'),
+		z.literal(ResourceStatus.Submitted).describe('已提交'),
+		z.literal(ResourceStatus.Suspended).describe('暂停'),
+		z.literal(ResourceStatus.Terminated).describe('终止'),
+		z.literal(ResourceStatus.Unqualified).describe('未达标'),
+		z.literal(ResourceStatus.Void).describe('作废'),
+		z.literal(ResourceStatus.Won).describe('已赢得'),
+	])
+	.meta({ title: 'ResourceStatus', description: '资源状态', type: 'string' });

package/src/resource/schema/ResourceType.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod/v4';
+import type { EnumValues } from './types';
+
+export const ResourceType = Object.freeze({
+	__proto__: null,
+	User: 'User',
+	Customer: 'Customer',
+	Contact: 'Contact',
+	Account: 'Account',
+	Order: 'Order',
+	Lead: 'Lead',
+	Opportunity: 'Opportunity',
+} as const);
+export type ResourceType = EnumValues<typeof ResourceType>;
+export const ResourceTypeSchema = z
+	.union([
+		z.literal(ResourceType.User).describe('用户'),
+		z.literal(ResourceType.Customer).describe('客户'),
+		z.literal(ResourceType.Contact).describe('联系人'),
+		z.literal(ResourceType.Account).describe('账户'),
+		z.literal(ResourceType.Order).describe('订单'),
+		z.literal(ResourceType.Lead).describe('线索'),
+		z.literal(ResourceType.Opportunity).describe('商机'),
+	])
+	.meta({ title: 'ResourceType', description: '资源类型', type: 'string' });

package/src/resource/schema/SchemaRegistry.ts

@@ -0,0 +1,42 @@
+import { getGlobalStates } from '@wener/utils';
+import type { JsonSchemaDef } from '../../jsonschema';
+import { toJsonSchema, type SchemaOutput, type TypeSchema } from '../../schema';
+
+const types = getGlobalStates('@wener/common/resource/schema/SchemaRegistry', () => new Map<string, JsonSchemaDef>());
+
+export function get(name: string): JsonSchemaDef;
+export function get<S extends TypeSchema>(schema: S): JsonSchemaDef<SchemaOutput<S>>;
+export function get(needle: TypeSchema | string) {
+	let key = getKey(needle);
+	let found = types.get(key);
+	if (found) {
+		return found;
+	} else {
+		if (typeof needle !== 'string') {
+			return toJsonSchema(needle);
+		}
+	}
+	throw new Error(`Schema not found: ${key}`);
+}
+
+function getKey(s: TypeSchema | string) {
+	let key;
+	if (typeof s === 'string') {
+		key = s;
+	} else {
+		let js = toJsonSchema(s);
+		key = js.$id || js.title;
+	}
+	if (!key) {
+		throw new Error(`Schema must have $id or title`);
+	}
+	return key;
+}
+
+export function add(def: TypeSchema) {
+	types.set(getKey(def), toJsonSchema(def));
+}
+
+export function set(key: TypeSchema | string, def: TypeSchema) {
+	types.set(getKey(key), toJsonSchema(def));
+}

package/src/resource/schema/SexType.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod/v4';
+import type { EnumValues } from './types';
+
+export const SexType = Object.freeze({
+	__proto__: null,
+	Male: 'Male',
+	Female: 'Female',
+	// Intersex
+} as const);
+export type SexType = EnumValues<typeof SexType>;
+export const SexTypeSchema = z
+	.union([z.literal(SexType.Male).describe('男'), z.literal(SexType.Female).describe('女')])
+	.describe('性别');

package/src/resource/schema/types.test.ts

@@ -0,0 +1,18 @@
+import { describe, it } from 'vitest';
+import { createSchemaData, toJsonSchema } from '../../schema';
+import { renderJsonSchemaToMarkdownDoc } from '../../tools/renderJsonSchemaToMarkdownDoc';
+import { AnyResourceSchema } from './AnyResourceSchema';
+
+describe('schema', () => {
+	it('should be convert to jsonschema', () => {
+		console.log(renderJsonSchemaToMarkdownDoc(toJsonSchema(AnyResourceSchema)));
+	});
+
+	it('should create from schema', () => {
+		console.log(
+			createSchemaData(AnyResourceSchema, {
+				all: true,
+			}),
+		);
+	});
+});

package/src/resource/schema/types.ts

@@ -0,0 +1,105 @@
+import { isValid } from 'date-fns';
+import dayjs from 'dayjs';
+import { z } from 'zod/v4';
+
+const TypeIdSchema = z
+	.string()
+	.regex(/^[a-zA-Z0-9]+_[a-zA-Z0-9]+$/, {
+		error: 'ID格式错误',
+	})
+	.describe('ID');
+
+/*
+XXX-XXX-XXXX
+National: (XXX) XXX-XXXX
+Human: XXX.XXX.XXXX xXXX
+International: +XX (XXX) XXX-XXXX
+
+中国
+XXX XXXX XXXX
+XXX-XXXX-XXXX
+XXXXXXXXXXX
++86 XXX XXXX XXXX
++86 XXXXXXXXXXX
+
+0XX-XXXXXXXX
+0XXX-XXXXXXXX
+(0XX) XXXXXXXX
+0XX XXXX XXXX
+0XXXXXXXX
+
+https://uibakery.io/regex-library/phone-number
+https://fakerjs.dev/api/phone
+ */
+
+const PhoneNumberSchema = z
+	.string()
+	.trim()
+	.max(20)
+	.regex(/(^$)|(^[0-9]*$)/, {
+		error: '电话号码只能包含数字',
+	})
+	.meta({
+		format: 'phone',
+	});
+
+function resourceIdOf(entity: string) {
+	return rz.resourceId.meta({ 'x-ref-entity': entity });
+}
+
+// allow empty string
+const JsonDateSchema = z.coerce
+	.string()
+	.trim()
+	.overwrite((v) => {
+		if (v && !/^\d{4}-\d{2}-\d{2}$/.test(v)) {
+			let val = dayjs(v);
+			if (val.isValid()) {
+				return val.format('YYYY-MM-DD');
+			}
+		}
+		return v;
+	})
+	.regex(/(^$)|(^\d{4}-\d{2}-\d{2}$)/, { error: '错误的日期格式' })
+	.refine((value) => !value || isValid(new Date(value)), {
+		error: '错误的日期',
+	})
+	.nullish()
+	.overwrite((v) => v || undefined)
+	.meta({ format: 'date' });
+
+const JsonDateTimeSchema = z.coerce.date().meta({ format: 'date-time', type: 'string' });
+
+const LoginNameSchema = z
+	.string()
+	.trim()
+	.regex(/^[a-z0-9]{3,16}$/, { error: '登录名只能包含小写字母和数字，长度为3-16位' });
+
+// maybe check valid cjk
+const FriendlyNameSchema = z
+	.string()
+	.trim()
+	.max(50)
+	.refine((v) => !/\p{C}/u.test(v), { message: '包含无效字符' })
+	.describe('名称');
+
+const PasswordSchema = z
+	.string()
+	.min(6, { error: '密码长度至少 6 位' })
+	.max(36, { error: '密码长度最多 36 位' })
+	.regex(/^\S*$/, { error: '密码不能包含空格' })
+	.describe('密码')
+	.meta({ sensitive: true });
+
+export const rz = {
+	resourceIdOf: resourceIdOf,
+	date: JsonDateSchema,
+	dateTime: JsonDateTimeSchema,
+	resourceId: TypeIdSchema,
+	phoneNumber: PhoneNumberSchema,
+	loginName: LoginNameSchema,
+	password: PasswordSchema,
+	friendlyName: FriendlyNameSchema,
+} as const;
+
+export type EnumValues<T> = T[Exclude<keyof T, '__proto__'>];

package/src/schema/TypeSchema.d.ts

@@ -0,0 +1,32 @@
+import type {
+	TSchema,
+	StaticDecode as TypeBoxStaticDecode,
+	StaticEncode as TypeBoxStaticEncode,
+} from '@sinclair/typebox';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { z } from 'zod/v4';
+import type { JsonSchemaDef } from '../jsonschema';
+
+export type TypeSchema<I = unknown, O = I> = TSchema | z.ZodSchema<O, I> | JsonSchemaDef | StandardSchemaV1<I, O>;
+
+export type SchemaOutput<S extends TypeSchema> =
+	S extends StandardSchemaV1<infer I, infer O>
+		? O
+		: S extends z.ZodSchema<infer O, infer I>
+			? O
+			: S extends TSchema
+				? TypeBoxStaticEncode<S>
+				: S extends JsonSchemaDef<infer I, infer O>
+					? O
+					: never;
+
+export type SchemaInput<S extends TypeSchema> =
+	S extends StandardSchemaV1<infer I, infer O>
+		? I
+		: S extends z.ZodSchema<infer O, infer I>
+			? I
+			: S extends TSchema
+				? TypeBoxStaticDecode<S>
+				: S extends JsonSchemaDef<infer I, infer O>
+					? I
+					: never;

package/src/schema/createSchemaData.ts

@@ -0,0 +1,81 @@
+import { match, P } from 'ts-pattern';
+import type { JsonSchemaDef } from '../jsonschema';
+import { toJsonSchema } from './toJsonSchema';
+import type { SchemaOutput, TypeSchema } from './TypeSchema';
+
+export function createSchemaData<S extends TypeSchema>(
+	ts: S,
+	options: CreateSchemaDataOptions = {},
+): Partial<SchemaOutput<S>> {
+	const schema = toJsonSchema(ts);
+	return createJsonSchemaData(schema, options);
+}
+
+type CreateSchemaDataOptions = Partial<CreateOptions> & {
+	all?: boolean;
+};
+
+function createJsonSchemaData(schema: JsonSchemaDef, options: CreateSchemaDataOptions): any {
+	let skip: CreateOptions['skip'] = (s, ctx) => Boolean(!ctx.required && s.nullable);
+	if (options.all) {
+		skip = () => false;
+	}
+	if (options.skip) {
+		skip = options.skip;
+	}
+	return _create(
+		schema,
+		{
+			skip,
+		},
+		{ required: false },
+	);
+}
+
+type CreateOptions = {
+	skip: (schema: JsonSchemaDef, ctx: { required: boolean }) => boolean;
+};
+
+function _create(schema: JsonSchemaDef, options: CreateOptions, ctx: { required: boolean }): any {
+	const { skip } = options;
+	if (skip(schema, ctx)) {
+		return schema.default;
+	}
+	if (schema.default !== undefined) {
+		return schema.default;
+	}
+	return match(schema as JsonSchemaDef)
+		.returnType<any>()
+		.with({ default: P.select() }, (v) => v)
+		.with({ const: P.nonNullable }, (v) => v.const)
+		.with({ anyOf: P.nonNullable }, (schema) => {
+			return _create(schema.anyOf[0], options, { required: false });
+		})
+		.with({ oneOf: P.nonNullable }, (schema) => {
+			return _create(schema.oneOf[0], options, { required: false });
+		})
+		.with({ type: 'string' }, (schema) => '')
+		.with({ type: P.union('number', 'integer') }, (schema) => 0)
+		.with({ type: 'object' }, () => {
+			const out: Record<string, any> = {};
+
+			let required = schema.required || [];
+			for (const [k, v] of Object.entries(schema.properties || {}) as [string, JsonSchemaDef][]) {
+				const value = _create(v, options, {
+					required: required.includes(k),
+				});
+				if (value === undefined) {
+					continue;
+				}
+				out[k] = value;
+			}
+
+			return out;
+		})
+		.with({ type: 'null' }, () => null)
+		.with({ type: 'boolean' }, (schema) => false)
+		.with({ type: 'array' }, (schema) => [])
+		.otherwise(() => {
+			return undefined;
+		});
+}

package/src/schema/findJsonSchemaByPath.ts

@@ -0,0 +1,37 @@
+import { firstOfMaybeArray } from '@wener/utils';
+import { toJsonSchema } from './toJsonSchema';
+import type { TypeSchema } from './TypeSchema';
+
+export function findJsonSchemaByPath(schema: TypeSchema, objectPath: string) {
+	schema = toJsonSchema(schema);
+	if (!objectPath || !schema) {
+		return undefined;
+	}
+
+	const segments = objectPath.split('.');
+	let currentSchema = schema;
+
+	for (const segment of segments) {
+		// 检查当前 schema 是否是对象类型且有 properties
+		if (
+			currentSchema
+			&& typeof currentSchema === 'object'
+			&& currentSchema.properties
+			&& currentSchema.properties[segment]
+		) {
+			currentSchema = currentSchema.properties[segment];
+			continue;
+		}
+
+		if (/^\d$/.test(segment) || segment === '[]') {
+			if (currentSchema.items) {
+				currentSchema = firstOfMaybeArray(currentSchema.items);
+				continue;
+			}
+		}
+
+		return undefined;
+	}
+
+	return currentSchema;
+}

package/src/schema/getSchemaCache.ts

@@ -0,0 +1,21 @@
+import type { JsonSchemaDef } from '../jsonschema';
+import type { TypeSchema } from './TypeSchema';
+
+type SchemaCache = {
+	jsonschema?: JsonSchemaDef;
+	options?: Array<{ value: string; label: string }>;
+};
+const _cache = new WeakMap<any, SchemaCache>();
+
+export function getSchemaCache<K extends keyof SchemaCache>(
+	obj: TypeSchema,
+	key: K,
+	compute: () => NonNullable<SchemaCache[K]>,
+): NonNullable<SchemaCache[K]> {
+	let c = _cache.get(obj);
+	if (!c) {
+		c = {};
+		_cache.set(obj, c);
+	}
+	return (c[key] ??= compute());
+}

package/src/schema/getSchemaOptions.ts

@@ -0,0 +1,24 @@
+import { deepFreeze } from '@wener/utils';
+import { getSchemaCache } from './getSchemaCache';
+import { toJsonSchema } from './toJsonSchema';
+import type { TypeSchema } from './TypeSchema';
+
+export function getSchemaOptions(s: TypeSchema): Array<{ value: string; label: string }> {
+	let js = toJsonSchema(s);
+	return getSchemaCache(s, 'options', () => {
+		let out =
+			(js.anyOf || js.oneOf)?.map((v) => {
+				let value = v.const;
+				return {
+					label: String(v.description || v.title || value),
+					value: value ? String(value) : '',
+				};
+			}) || [];
+		out = deepFreeze(out);
+		return out;
+	});
+}
+
+export function getSchemaOptionLabel(schema: TypeSchema, value: string | undefined | null): string | undefined {
+	return getSchemaOptions(schema).find((v) => v.value === value)?.label;
+}

package/src/schema/index.ts

@@ -0,0 +1,6 @@
+export type * from './TypeSchema';
+export { isJsonSchema, isZodSchema, isTypeBoxSchema, validate, parseData, type ValidationResult } from './validate';
+export { getSchemaOptions, getSchemaOptionLabel } from './getSchemaOptions';
+export { toJsonSchema } from './toJsonSchema';
+export { findJsonSchemaByPath } from './findJsonSchemaByPath';
+export { createSchemaData } from './createSchemaData';

package/src/schema/toJsonSchema.test.ts

@@ -0,0 +1,37 @@
+import { inspect } from 'node:util';
+import { describe, expect, it } from 'vitest';
+import { z } from 'zod/v4';
+import { toJsonSchema } from './toJsonSchema';
+
+describe('toJsonSchema', () => {
+	it('should handle discriminatedUnion', () => {
+		console.log(
+			inspect(
+				toJsonSchema(
+					z.discriminatedUnion('type', [
+						z.object({
+							type: z.literal('string'),
+							value: z.string(),
+						}),
+						z.object({
+							type: z.literal('number'),
+							value: z.number(),
+						}),
+					]),
+				),
+				{
+					depth: 10,
+					colors: true,
+				},
+			),
+		);
+	});
+
+	it('should cache', () => {
+		let zs = z.object({
+			name: z.string(),
+		});
+
+		expect(toJsonSchema(zs)).toBe(toJsonSchema(zs));
+	});
+});