@okcy/core 1.0.0

package/README.md

@@ -0,0 +1,41 @@
+# @okcy/core
+
+Vue 3 工具库，聚合常用工具函数与 composable。
+
+## 安装
+
+```bash
+pnpm add @okcy/core
+```
+
+## 入口
+
+| 子路径 | 说明 |
+|--------|------|
+| `.` / `./index` | 空入口（仅类型导出） |
+| `./utils` | 通用工具：`@vueuse/core` 重导出、字符串/数组/Oss 工具、Vue composable、Zod、断言等 |
+| `./toolkit` | es-toolkit 兼容层 + `isNotNil` / `isJSON` / `pascalCase` / `isBlank` / `isPositive` |
+| `./crypto` | `crypto.js` 重导出 |
+| `./dayjs` | dayjs + 中文语言包 + `DatePattern`（`ll`/`lll`/`LL`/`LLL`）+ 无效日期 fallback `--` |
+| `./emittery` | emittery 重导出 |
+
+## 用法示例
+
+```ts
+import { dayjs, DatePattern, localeZhCn } from "@okcy/core/dayjs";
+localeZhCn();
+dayjs("2024-01-01").format(DatePattern.ll); // "2024-01-01"
+
+import { isNotNil, pascalCase } from "@okcy/core/toolkit";
+pascalCase("hello-world"); // "HelloWorld"
+
+import { AliOssAbstract } from "@okcy/core/utils";
+class MyOss extends AliOssAbstract {
+  baseUrl = "https://my-bucket.oss-cn-hangzhou.aliyuncs.com";
+}
+```
+
+## 依赖
+
+- Vue 3、`@vueuse/core`
+- dayjs、crypto.js、emittery、es-toolkit、zod

package/dist/crypto.d.mts

@@ -0,0 +1 @@
+export * from "crypto.js";

package/dist/crypto.mjs

@@ -0,0 +1,2 @@
+export * from "crypto.js";
+export {};

package/dist/dayjs.d.mts

@@ -0,0 +1,12 @@
+import "dayjs/locale/zh-cn.js";
+import dayjs from "dayjs/esm/index.js";
+//#region src/dayjs.d.ts
+export declare const DatePattern: {
+  ll: string;
+  lll: string;
+  LL: string;
+  LLL: string;
+};
+export declare const localeZhCn: () => void;
+//#endregion
+export { dayjs };

package/dist/dayjs.mjs

@@ -0,0 +1,21 @@
+import "dayjs/locale/zh-cn.js";
+import dayjs from "dayjs/esm/index.js";
+//#region src/dayjs.ts
+const DatePattern = {
+	ll: "YYYY-MM-DD",
+	lll: "YYYY-MM-DD HH:mm",
+	LL: "YYYY年MM月DD日",
+	LLL: "YYYY年MM月DD日 HH:mm"
+};
+const localeZhCn = () => {
+	dayjs.locale("zh-cn");
+	dayjs.extend(function(dayjsClass, Ctor, dayjs) {
+		const _format = Ctor.prototype.format;
+		Ctor.prototype.format = function(format) {
+			const fun = _format.bind(this);
+			return this.isValid() ? fun(format) : "--";
+		};
+	});
+};
+//#endregion
+export { DatePattern, dayjs, localeZhCn };

package/dist/emittery.d.mts

@@ -0,0 +1,2 @@
+import Emitter from "emittery";
+export { Emitter, Emitter as Emittery, Emitter as default };

package/dist/emittery.mjs

@@ -0,0 +1,5 @@
+import Emitter from "emittery";
+//#region src/emittery.ts
+var emittery_default = Emitter;
+//#endregion
+export { Emitter, Emitter as Emittery, emittery_default as default };

package/dist/index.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/index.mjs

@@ -0,0 +1 @@
+export {};

package/dist/toolkit.d.mts

@@ -0,0 +1,14 @@
+import { isJSON, isNotNil } from "es-toolkit";
+export * from "es-toolkit/compat";
+//#region src/es-toolkit/my.d.ts
+export declare const isPositive: (n: any) => boolean;
+/**
+ * 将字符串转换为 PascalCase
+ * 支持 kebab-case, snake_case, camelCase, 空格分隔等格式
+ * @param {string} str - 输入字符串
+ * @returns {string} PascalCase 格式的字符串
+ */
+export declare const pascalCase: (str: string) => string;
+export declare const isBlank: (value: unknown) => boolean;
+//#endregion
+export { isJSON, isNotNil };

package/dist/toolkit.mjs

@@ -0,0 +1,21 @@
+import { isJSON, isNil, isNotNil, isString } from "es-toolkit";
+export * from "es-toolkit/compat";
+//#region src/es-toolkit/my.ts
+const isPositive = (n) => typeof n === "number" && !isNaN(n) && n > 0;
+/**
+* 将字符串转换为 PascalCase
+* 支持 kebab-case, snake_case, camelCase, 空格分隔等格式
+* @param {string} str - 输入字符串
+* @returns {string} PascalCase 格式的字符串
+*/
+const pascalCase = (str) => {
+	if (typeof str !== "string") return "";
+	return str.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[-_\s]+/g, " ").trim().split(/\s+/).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+};
+const isBlank = (value) => {
+	if (isNil(value)) return true;
+	if (isString(value)) return value.trim() === "";
+	return true;
+};
+//#endregion
+export { isBlank, isJSON, isNotNil, isPositive, pascalCase };

package/dist/utils.d.mts

@@ -0,0 +1,536 @@
+import { ComponentInternalInstance, DefineSetupFnComponent, InjectionKey, Ref, VNode } from "vue";
+import * as z from "zod";
+import { ZodType } from "zod";
+export * from "@vueuse/core";
+//#region src/utils/strUtil.d.ts
+export declare const replaceImgSrc: (html: string, func: (src: string) => string) => string;
+export declare const fixHtml: (html: string, func: (src: string) => string) => string;
+/**
+ * 文字
+ * @param name
+ * @returns
+ */
+export declare const nameGradient: (name: string) => string;
+//#endregion
+//#region src/utils/array.d.ts
+/**
+ * 转树结构
+ * @param array
+ * @param pid
+ * @param childrenKey
+ */
+export declare const arrayToArrayTree: <T>(array: T[], pid?: string, childrenKey?: string) => T[];
+//#endregion
+//#region src/utils/util.d.ts
+/**
+ * 生成uuid
+ * @param size 大小
+ * @returns uuid
+ */
+export declare const generateUUID: (size?: number) => string;
+/**
+ * 数字穿插函数
+ * @param arr 数组
+ * @param separator 分隔符
+ * @param arr 数组
+ */
+export declare const intersperse: <T>(arr: T[], separator: T) => T[];
+/**
+ * 数字穿插函数  [1,2,3]=>[1,0,2,0,3]
+ * @param arr 数组
+ * @param fun 函数
+ * @param arr 数组
+ */
+export declare const intersperseFun: <T>(arr: T[], fun: (index: number) => T) => T[];
+//#endregion
+//#region src/utils/ossUtil.d.ts
+interface StrCndImg {
+  /**
+   * lfit：等比缩放，缩放图限制为指定w与h的矩形内的最大图片。
+   * mfit：等比缩放，缩放图为延伸出指定w与h的矩形框外的最小图片。
+   * fill（默认值）：将原图等比缩放为延伸出指定w与h的矩形框外的最小图片，之后将超出的部分进行居中裁剪。
+   * pad：将原图缩放为指定w与h的矩形内的最大图片，之后使用指定颜色居中填充空白部分。
+   * fixed：固定宽高，强制缩放。
+   */
+  m: "lfit" | "mfit" | "fill" | "pad" | "fixed";
+  w: number;
+  h: number;
+  /**
+   * 背景颜色
+   */
+  c: string;
+  /**
+   * 指定目标缩放图的最长边。
+   */
+  l: number;
+  /**
+   * 指定目标缩放图的最短边。
+   */
+  s: number;
+}
+export interface OSS {
+  baseUrl: string;
+  /**
+   * 生成ossurl
+   * @param src 图片url
+   * @param origin 是否包含域名
+   * @param search 是否包含查询参数
+   * @returns url
+   */
+  cdnUrl(src: string, origin?: boolean, search?: boolean): string;
+  /**
+   * 生成oss图片url
+   * @param src 图片url
+   * @param options 图片参数
+   * @returns 图片url
+   */
+  cdnImg(src: string, options: Partial<StrCndImg>): string;
+}
+/**
+ * 阿里云 oss
+ */
+export declare abstract class AliOssAbstract implements OSS {
+  abstract baseUrl: string;
+  cdnImg: (src?: string, options?: Partial<StrCndImg>) => string;
+  cdnUrl: (src?: string, origin?: boolean, search?: boolean) => string;
+}
+/**
+ * 七牛
+ */
+export declare abstract class QiniuAbstract implements OSS {
+  abstract baseUrl: string;
+  cdnImg: (src: string, options: Partial<StrCndImg>) => string;
+  cdnUrl: (src: string, origin?: boolean, search?: boolean) => string;
+}
+/**
+ * 天翼云
+ */
+export declare abstract class CtOssAbstract implements OSS {
+  abstract baseUrl: string;
+  cdnImg: (src: string, options: Partial<StrCndImg>) => string;
+  cdnUrl: (src: string, origin?: boolean, search?: boolean) => string;
+}
+//#endregion
+//#region src/utils/hook.d.ts
+export declare const useNodeJSX: (name: string, def?: () => any) => import("vue").ComputedRef<(() => any) | ((params?: any) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>[]) | undefined>;
+/**
+ * 获取上级prop没有就获取注入
+ * @param name
+ * @param defaultValue
+ */
+export declare const useInjectProp: <T>(name: string | symbol, defaultValue?: T) => Ref<T>;
+type ActionType<E = any> = {
+  emit?: Record<string, (...args: any) => E>;
+};
+type ResultAction<E extends ActionType, T> = { [K in keyof E["emit"]]: E["emit"][K] extends ((...args: infer Args) => any) ? (callback: (...args: Args) => void) => ResultAction<E, T> : never; } & T;
+export declare const defineAction: <T extends Record<string, any>, Args extends any[] = [], E extends ActionType = {}>(setup: (ctx: E["emit"], ...args: Args) => T, options?: E) => (...args: Args) => ResultAction<E, T>;
+//#endregion
+//#region src/utils/components/createTemplate.d.ts
+export type CreateTemplate = DefineSetupFnComponent<any, any, any> & {
+  jsx: (jsx: VNode) => void;
+  remove: () => void;
+  loadingTemplate: () => DefineSetupFnComponent<any, any, any>;
+};
+export declare const LOADING_KEY: unique symbol;
+interface LoadingHandler {
+  start: () => void;
+  end: () => void;
+}
+export declare const getLoadingHandler: (instance: ComponentInternalInstance) => LoadingHandler | undefined;
+/**
+ * 创建模板
+ */
+export declare const useCreateTemplate: () => CreateTemplate;
+/**
+ * 创建加载模板
+ */
+export declare const useCreateLoading: () => {
+  onSuccess: (callback: (val: boolean) => void) => /*elided*/ any & {
+    loading: import("vue").ComputedRef<boolean>;
+    Template: DefineSetupFnComponent<Record<string, any>, {}, {}, Record<string, any> & {}, import("vue").PublicProps>;
+  };
+} & {
+  loading: import("vue").ComputedRef<boolean>;
+  Template: DefineSetupFnComponent<Record<string, any>, {}, {}, Record<string, any> & {}, import("vue").PublicProps>;
+};
+//#endregion
+//#region src/utils/vue.d.ts
+/**
+ * 外部获取provide
+ * @param key
+ * @param instance
+ */
+export declare const injectExternal: <T>(key: InjectionKey<T> | string, instance?: ComponentInternalInstance) => any;
+//#endregion
+//#region src/utils/assert.d.ts
+/**
+ * 断言工具类
+ */
+export declare abstract class AssertAbstract {
+  /**
+   * 统一的错误抛出方法（私有）
+   * @private
+   * @param {string} methodName - 调用断言的方法名（用于错误前缀）
+   * @param {string} message - 错误信息
+   * @throws {Error}
+   */
+  abstract throwError(methodName: string, message: string): void;
+  /**
+   * 断言条件为真，否则抛出错误
+   * @param {boolean} condition - 要断言的条件
+   * @param {string} [message='Assertion failed'] - 错误信息
+   */
+  isTrue(condition: boolean, message?: string): void;
+  /**
+   * 断言条件为假，否则抛出错误
+   * @param {boolean} condition - 要断言的条件
+   * @param {string} [message='Assertion failed'] - 错误信息
+   */
+  isFalse(condition: boolean, message?: string): void;
+  /**
+   * 断言值不为 null 或 undefined
+   * @param {*} value - 要检查的值
+   * @param {string} [message='Value must not be null or undefined'] - 错误信息
+   */
+  notNull(value: any, message?: string): void;
+  /**
+   * 断言值为非空白字符串（即：是字符串，且去除两端空白后非空）
+   * @param {any} value - 要检查的值
+   * @param {string} [message='must not be blank'] - 错误信息
+   */
+  notBlank(value: any, message?: string): void;
+  /**
+   * 断言值为指定类型
+   * @param {*} value - 要检查的值
+   * @param {string} expectedType - 期望的类型（如 'string', 'number', 'object' 等）
+   * @param {string} [message] - 错误信息
+   */
+  isType(value: any, expectedType: string, message?: string): void;
+  /**
+   * 断言值为非空
+   * @param {any} value - 要检查的字符串
+   * @param {string} [message='must not be empty'] - 错误信息
+   */
+  notEmpty(value: any, message?: string): void;
+  /**
+   * 断言值为整数
+   * @param {number} value - 要检查的数值
+   * @param {string} [message='Value must be an integer'] - 错误信息
+   */
+  isInteger(value: number, message?: string): void;
+  /**
+   * 断言两个值相等（使用严格相等 ===）
+   * @param {*} actual - 实际值
+   * @param {*} expected - 期望值
+   * @param {string} [message] - 错误信息
+   */
+  equals(actual: any, expected: any, message?: string): void;
+  /**
+   * 断言数值在指定范围内（包含边界）
+   * @param {number} value - 要检查的数值
+   * @param {number} min - 最小值（含）
+   * @param {number} max - 最大值（含）
+   * @param {string} [message] - 错误信息
+   */
+  inRange(value: number, min: number, max: number, message?: string): void;
+}
+//#endregion
+//#region src/utils/zod.d.ts
+declare const zod: {
+  ZodError: z.core.$constructor<z.ZodError<unknown>, z.core.$ZodIssue[]>;
+  ZodRealError: z.core.$constructor<z.ZodError>;
+  parse: <T extends z.core.$ZodType>(schema: T, value: unknown, _ctx?: z.core.ParseContext<z.core.$ZodIssue>, _params?: {
+    callee?: z.util.AnyFunc;
+    Err?: z.core.$ZodErrorClass;
+  }) => z.TypeOf<T>;
+  parseAsync: <T extends z.core.$ZodType>(schema: T, value: unknown, _ctx?: z.core.ParseContext<z.core.$ZodIssue>, _params?: {
+    callee?: z.util.AnyFunc;
+    Err?: z.core.$ZodErrorClass;
+  }) => Promise<z.TypeOf<T>>;
+  safeParse: <T extends z.core.$ZodType>(schema: T, value: unknown, _ctx?: z.core.ParseContext<z.core.$ZodIssue>) => z.ZodSafeParseResult<z.TypeOf<T>>;
+  safeParseAsync: <T extends z.core.$ZodType>(schema: T, value: unknown, _ctx?: z.core.ParseContext<z.core.$ZodIssue>) => Promise<z.ZodSafeParseResult<z.TypeOf<T>>>;
+  encode: <T extends z.core.$ZodType>(schema: T, value: z.TypeOf<T>, _ctx?: z.core.ParseContext<z.core.$ZodIssue>) => z.input<T>;
+  decode: <T extends z.core.$ZodType>(schema: T, value: z.input<T>, _ctx?: z.core.ParseContext<z.core.$ZodIssue>) => z.TypeOf<T>;
+  encodeAsync: <T extends z.core.$ZodType>(schema: T, value: z.TypeOf<T>, _ctx?: z.core.ParseContext<z.core.$ZodIssue>) => Promise<z.input<T>>;
+  decodeAsync: <T extends z.core.$ZodType>(schema: T, value: z.input<T>, _ctx?: z.core.ParseContext<z.core.$ZodIssue>) => Promise<z.TypeOf<T>>;
+  safeEncode: <T extends z.core.$ZodType>(schema: T, value: z.TypeOf<T>, _ctx?: z.core.ParseContext<z.core.$ZodIssue>) => z.ZodSafeParseResult<z.input<T>>;
+  safeDecode: <T extends z.core.$ZodType>(schema: T, value: z.input<T>, _ctx?: z.core.ParseContext<z.core.$ZodIssue>) => z.ZodSafeParseResult<z.TypeOf<T>>;
+  safeEncodeAsync: <T extends z.core.$ZodType>(schema: T, value: z.TypeOf<T>, _ctx?: z.core.ParseContext<z.core.$ZodIssue>) => Promise<z.ZodSafeParseResult<z.input<T>>>;
+  safeDecodeAsync: <T extends z.core.$ZodType>(schema: T, value: z.input<T>, _ctx?: z.core.ParseContext<z.core.$ZodIssue>) => Promise<z.ZodSafeParseResult<z.TypeOf<T>>>;
+  ZodType: z.core.$constructor<ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.core.$ZodTypeDef>;
+  _ZodString: z.core.$constructor<z._ZodString<z.core.$ZodStringInternals<unknown>>, z.core.$ZodStringDef>;
+  ZodString: z.core.$constructor<z.ZodString, z.core.$ZodStringDef>;
+  string(params?: string | z.core.$ZodStringParams): z.ZodString;
+  string<T extends string>(params?: string | z.core.$ZodStringParams): z.core.$ZodType<T, T>;
+  ZodStringFormat: z.core.$constructor<z.ZodStringFormat<string>, z.core.$ZodStringFormatDef<string>>;
+  ZodEmail: z.core.$constructor<z.ZodEmail, z.core.$ZodStringFormatDef<"email">>;
+  email(params?: string | z.core.$ZodEmailParams): z.ZodEmail;
+  ZodGUID: z.core.$constructor<z.ZodGUID, z.core.$ZodStringFormatDef<"guid">>;
+  guid(params?: string | z.core.$ZodGUIDParams): z.ZodGUID;
+  ZodUUID: z.core.$constructor<z.ZodUUID, z.core.$ZodUUIDDef>;
+  uuid(params?: string | z.core.$ZodUUIDParams): z.ZodUUID;
+  uuidv4(params?: string | z.core.$ZodUUIDv4Params): z.ZodUUID;
+  uuidv6(params?: string | z.core.$ZodUUIDv6Params): z.ZodUUID;
+  uuidv7(params?: string | z.core.$ZodUUIDv7Params): z.ZodUUID;
+  ZodURL: z.core.$constructor<z.ZodURL, z.core.$ZodURLDef>;
+  url(params?: string | z.core.$ZodURLParams): z.ZodURL;
+  httpUrl(params?: string | Omit<z.core.$ZodURLParams, "protocol" | "hostname">): z.ZodURL;
+  ZodEmoji: z.core.$constructor<z.ZodEmoji, z.core.$ZodStringFormatDef<"emoji">>;
+  emoji(params?: string | z.core.$ZodEmojiParams): z.ZodEmoji;
+  ZodNanoID: z.core.$constructor<z.ZodNanoID, z.core.$ZodStringFormatDef<"nanoid">>;
+  nanoid(params?: string | z.core.$ZodNanoIDParams): z.ZodNanoID;
+  ZodCUID: z.core.$constructor<z.ZodCUID, z.core.$ZodStringFormatDef<"cuid">>;
+  cuid(params?: string | z.core.$ZodCUIDParams): z.ZodCUID;
+  ZodCUID2: z.core.$constructor<z.ZodCUID2, z.core.$ZodStringFormatDef<"cuid2">>;
+  cuid2(params?: string | z.core.$ZodCUID2Params): z.ZodCUID2;
+  ZodULID: z.core.$constructor<z.ZodULID, z.core.$ZodStringFormatDef<"ulid">>;
+  ulid(params?: string | z.core.$ZodULIDParams): z.ZodULID;
+  ZodXID: z.core.$constructor<z.ZodXID, z.core.$ZodStringFormatDef<"xid">>;
+  xid(params?: string | z.core.$ZodXIDParams): z.ZodXID;
+  ZodKSUID: z.core.$constructor<z.ZodKSUID, z.core.$ZodStringFormatDef<"ksuid">>;
+  ksuid(params?: string | z.core.$ZodKSUIDParams): z.ZodKSUID;
+  ZodIPv4: z.core.$constructor<z.ZodIPv4, z.core.$ZodIPv4Def>;
+  ipv4(params?: string | z.core.$ZodIPv4Params): z.ZodIPv4;
+  ZodMAC: z.core.$constructor<z.ZodMAC, z.core.$ZodMACDef>;
+  mac(params?: string | z.core.$ZodMACParams): z.ZodMAC;
+  ZodIPv6: z.core.$constructor<z.ZodIPv6, z.core.$ZodIPv6Def>;
+  ipv6(params?: string | z.core.$ZodIPv6Params): z.ZodIPv6;
+  ZodCIDRv4: z.core.$constructor<z.ZodCIDRv4, z.core.$ZodCIDRv4Def>;
+  cidrv4(params?: string | z.core.$ZodCIDRv4Params): z.ZodCIDRv4;
+  ZodCIDRv6: z.core.$constructor<z.ZodCIDRv6, z.core.$ZodCIDRv6Def>;
+  cidrv6(params?: string | z.core.$ZodCIDRv6Params): z.ZodCIDRv6;
+  ZodBase64: z.core.$constructor<z.ZodBase64, z.core.$ZodStringFormatDef<"base64">>;
+  base64(params?: string | z.core.$ZodBase64Params): z.ZodBase64;
+  ZodBase64URL: z.core.$constructor<z.ZodBase64URL, z.core.$ZodStringFormatDef<"base64url">>;
+  base64url(params?: string | z.core.$ZodBase64URLParams): z.ZodBase64URL;
+  ZodE164: z.core.$constructor<z.ZodE164, z.core.$ZodStringFormatDef<"e164">>;
+  e164(params?: string | z.core.$ZodE164Params): z.ZodE164;
+  ZodJWT: z.core.$constructor<z.ZodJWT, z.core.$ZodJWTDef>;
+  jwt(params?: string | z.core.$ZodJWTParams): z.ZodJWT;
+  ZodCustomStringFormat: z.core.$constructor<z.ZodCustomStringFormat<string>, z.core.$ZodCustomStringFormatDef<string>>;
+  stringFormat<Format extends string>(format: Format, fnOrRegex: ((arg: string) => z.util.MaybeAsync<unknown>) | RegExp, _params?: string | z.core.$ZodStringFormatParams): z.ZodCustomStringFormat<Format>;
+  hostname(_params?: string | z.core.$ZodStringFormatParams): z.ZodCustomStringFormat<"hostname">;
+  hex(_params?: string | z.core.$ZodStringFormatParams): z.ZodCustomStringFormat<"hex">;
+  hash<Alg extends z.util.HashAlgorithm, Enc extends z.util.HashEncoding = "hex">(alg: Alg, params?: {
+    enc?: Enc;
+  } & z.core.$ZodStringFormatParams): z.ZodCustomStringFormat<`${Alg}_${Enc}`>;
+  ZodNumber: z.core.$constructor<z.ZodNumber, z.core.$ZodNumberDef>;
+  number(params?: string | z.core.$ZodNumberParams): z.ZodNumber;
+  ZodNumberFormat: z.core.$constructor<z.ZodNumberFormat, z.core.$ZodNumberFormatDef>;
+  int(params?: string | z.core.$ZodCheckNumberFormatParams): z.ZodInt;
+  float32(params?: string | z.core.$ZodCheckNumberFormatParams): z.ZodFloat32;
+  float64(params?: string | z.core.$ZodCheckNumberFormatParams): z.ZodFloat64;
+  int32(params?: string | z.core.$ZodCheckNumberFormatParams): z.ZodInt32;
+  uint32(params?: string | z.core.$ZodCheckNumberFormatParams): z.ZodUInt32;
+  ZodBoolean: z.core.$constructor<z.ZodBoolean, z.core.$ZodBooleanDef>;
+  boolean(params?: string | z.core.$ZodBooleanParams): z.ZodBoolean;
+  ZodBigInt: z.core.$constructor<z.ZodBigInt, z.core.$ZodBigIntDef>;
+  bigint(params?: string | z.core.$ZodBigIntParams): z.ZodBigInt;
+  ZodBigIntFormat: z.core.$constructor<z.ZodBigIntFormat, z.core.$ZodBigIntFormatDef>;
+  int64(params?: string | z.core.$ZodBigIntFormatParams): z.ZodBigIntFormat;
+  uint64(params?: string | z.core.$ZodBigIntFormatParams): z.ZodBigIntFormat;
+  ZodSymbol: z.core.$constructor<z.ZodSymbol, z.core.$ZodSymbolDef>;
+  symbol(params?: string | z.core.$ZodSymbolParams): z.ZodSymbol;
+  ZodUndefined: z.core.$constructor<z.ZodUndefined, z.core.$ZodUndefinedDef>;
+  undefined: typeof z.undefined;
+  ZodNull: z.core.$constructor<z.ZodNull, z.core.$ZodNullDef>;
+  null: typeof z.null;
+  ZodAny: z.core.$constructor<z.ZodAny, z.core.$ZodAnyDef>;
+  any(): z.ZodAny;
+  ZodUnknown: z.core.$constructor<z.ZodUnknown, z.core.$ZodUnknownDef>;
+  unknown(): z.ZodUnknown;
+  ZodNever: z.core.$constructor<z.ZodNever, z.core.$ZodNeverDef>;
+  never(params?: string | z.core.$ZodNeverParams): z.ZodNever;
+  ZodVoid: z.core.$constructor<z.ZodVoid, z.core.$ZodVoidDef>;
+  void: typeof z.void;
+  ZodDate: z.core.$constructor<z.ZodDate, z.core.$ZodDateDef>;
+  date(params?: string | z.core.$ZodDateParams): z.ZodDate;
+  ZodArray: z.core.$constructor<z.ZodArray<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$ZodArrayDef<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+  array<T extends z.core.SomeType>(element: T, params?: string | z.core.$ZodArrayParams): z.ZodArray<T>;
+  keyof<T extends z.ZodObject>(schema: T): z.ZodEnum<z.util.KeysEnum<T["_zod"]["output"]>>;
+  ZodObject: z.core.$constructor<z.ZodObject<z.core.$ZodLooseShape, z.core.$strip>, z.core.$ZodObjectDef<z.core.$ZodLooseShape>>;
+  object<T extends z.core.$ZodLooseShape = Partial<Record<never, z.core.SomeType>>>(shape?: T, params?: string | z.core.$ZodObjectParams): z.ZodObject<z.util.Writeable<T>, z.core.$strip>;
+  strictObject<T extends z.core.$ZodLooseShape>(shape: T, params?: string | z.core.$ZodObjectParams): z.ZodObject<T, z.core.$strict>;
+  looseObject<T extends z.core.$ZodLooseShape>(shape: T, params?: string | z.core.$ZodObjectParams): z.ZodObject<T, z.core.$loose>;
+  ZodUnion: z.core.$constructor<z.ZodUnion<readonly z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>[]>, z.core.$ZodUnionDef<readonly z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>[]>>;
+  union<const T extends readonly z.core.SomeType[]>(options: T, params?: string | z.core.$ZodUnionParams): z.ZodUnion<T>;
+  ZodXor: z.core.$constructor<z.ZodXor<readonly z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>[]>, z.core.$ZodUnionDef<readonly z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>[]>>;
+  xor<const T extends readonly z.core.SomeType[]>(options: T, params?: string | z.core.$ZodXorParams): z.ZodXor<T>;
+  ZodDiscriminatedUnion: z.core.$constructor<z.ZodDiscriminatedUnion<readonly z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>[], string>, z.core.$ZodDiscriminatedUnionDef<readonly z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>[], string>>;
+  discriminatedUnion<Types extends readonly [z.core.$ZodTypeDiscriminable, ...z.core.$ZodTypeDiscriminable[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | z.core.$ZodDiscriminatedUnionParams): z.ZodDiscriminatedUnion<Types, Disc>;
+  ZodIntersection: z.core.$constructor<z.ZodIntersection<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$ZodIntersectionDef<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+  intersection<T extends z.core.SomeType, U extends z.core.SomeType>(left: T, right: U): z.ZodIntersection<T, U>;
+  ZodTuple: z.core.$constructor<z.ZodTuple<readonly z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>[], z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | null>, z.core.$ZodTupleDef<readonly z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>[], z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | null>>;
+  tuple<T extends readonly [z.core.SomeType, ...z.core.SomeType[]]>(items: T, params?: string | z.core.$ZodTupleParams): z.ZodTuple<T, null>;
+  tuple<T extends readonly [z.core.SomeType, ...z.core.SomeType[]], Rest extends z.core.SomeType>(items: T, rest: Rest, params?: string | z.core.$ZodTupleParams): z.ZodTuple<T, Rest>;
+  tuple(items: [], params?: string | z.core.$ZodTupleParams): z.ZodTuple<[], null>;
+  ZodRecord: z.core.$constructor<z.ZodRecord<z.core.$ZodRecordKey, z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$ZodRecordDef<z.core.$ZodRecordKey, z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+  record<Key extends z.core.$ZodRecordKey, Value extends z.core.SomeType>(keyType: Key, valueType: Value, params?: string | z.core.$ZodRecordParams): z.ZodRecord<Key, Value>;
+  partialRecord<Key extends z.core.$ZodRecordKey, Value extends z.core.SomeType>(keyType: Key, valueType: Value, params?: string | z.core.$ZodRecordParams): z.ZodRecord<Key & z.core.$partial, Value>;
+  looseRecord<Key extends z.core.$ZodRecordKey, Value extends z.core.SomeType>(keyType: Key, valueType: Value, params?: string | z.core.$ZodRecordParams): z.ZodRecord<Key, Value>;
+  ZodMap: z.core.$constructor<z.ZodMap<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$ZodMapDef<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+  map<Key extends z.core.SomeType, Value extends z.core.SomeType>(keyType: Key, valueType: Value, params?: string | z.core.$ZodMapParams): z.ZodMap<Key, Value>;
+  ZodSet: z.core.$constructor<z.ZodSet<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$ZodSetDef<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+  set<Value extends z.core.SomeType>(valueType: Value, params?: string | z.core.$ZodSetParams): z.ZodSet<Value>;
+  ZodEnum: z.core.$constructor<z.ZodEnum<Readonly<Record<string, z.util.EnumValue>>>, z.core.$ZodEnumDef<Readonly<Record<string, z.util.EnumValue>>>>;
+  enum: typeof z.enum;
+  nativeEnum<T extends z.util.EnumLike>(entries: T, params?: string | z.core.$ZodEnumParams): z.ZodEnum<T>;
+  ZodLiteral: z.core.$constructor<z.ZodLiteral<z.util.Literal>, z.core.$ZodLiteralDef<z.util.Literal>>;
+  literal<const T extends ReadonlyArray<z.util.Literal>>(value: T, params?: string | z.core.$ZodLiteralParams): z.ZodLiteral<T[number]>;
+  literal<const T extends z.util.Literal>(value: T, params?: string | z.core.$ZodLiteralParams): z.ZodLiteral<T>;
+  ZodFile: z.core.$constructor<z.ZodFile, z.core.$ZodFileDef>;
+  file(params?: string | z.core.$ZodFileParams): z.ZodFile;
+  ZodTransform: z.core.$constructor<z.ZodTransform<unknown, unknown>, z.core.$ZodTransformDef>;
+  transform<I = unknown, O = I>(fn: (input: I, ctx: z.core.ParsePayload) => O): z.ZodTransform<Awaited<O>, I>;
+  ZodOptional: z.core.$constructor<z.ZodOptional<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$ZodOptionalDef<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+  optional<T extends z.core.SomeType>(innerType: T): z.ZodOptional<T>;
+  ZodExactOptional: z.core.$constructor<z.ZodExactOptional<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$ZodExactOptionalDef<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+  exactOptional<T extends z.core.SomeType>(innerType: T): z.ZodExactOptional<T>;
+  ZodNullable: z.core.$constructor<z.ZodNullable<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$ZodNullableDef<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+  nullable<T extends z.core.SomeType>(innerType: T): z.ZodNullable<T>;
+  nullish<T extends z.core.SomeType>(innerType: T): z.ZodOptional<z.ZodNullable<T>>;
+  ZodDefault: z.core.$constructor<z.ZodDefault<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$ZodDefaultDef<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+  _default<T extends z.core.SomeType>(innerType: T, defaultValue: z.util.NoUndefined<z.TypeOf<T>> | (() => z.util.NoUndefined<z.TypeOf<T>>)): z.ZodDefault<T>;
+  ZodPrefault: z.core.$constructor<z.ZodPrefault<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$ZodPrefaultDef<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+  prefault<T extends z.core.SomeType>(innerType: T, defaultValue: z.input<T> | (() => z.input<T>)): z.ZodPrefault<T>;
+  ZodNonOptional: z.core.$constructor<z.ZodNonOptional<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$ZodNonOptionalDef<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+  nonoptional<T extends z.core.SomeType>(innerType: T, params?: string | z.core.$ZodNonOptionalParams): z.ZodNonOptional<T>;
+  ZodSuccess: z.core.$constructor<z.ZodSuccess<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$ZodSuccessDef<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+  success<T extends z.core.SomeType>(innerType: T): z.ZodSuccess<T>;
+  ZodCatch: z.core.$constructor<z.ZodCatch<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$ZodCatchDef<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+  catch: typeof z.catch;
+  ZodNaN: z.core.$constructor<z.ZodNaN, z.core.$ZodNaNDef>;
+  nan(params?: string | z.core.$ZodNaNParams): z.ZodNaN;
+  ZodPipe: z.core.$constructor<z.ZodPipe<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$ZodPipeDef<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+  pipe<const A extends z.core.SomeType, B extends z.core.$ZodType<unknown, z.TypeOf<A>> = z.core.$ZodType<unknown, z.TypeOf<A>, z.core.$ZodTypeInternals<unknown, z.TypeOf<A>>>>(in_: A, out: B | z.core.$ZodType<unknown, z.TypeOf<A>>): z.ZodPipe<A, B>;
+  ZodCodec: z.core.$constructor<z.ZodCodec<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$ZodCodecDef<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+  codec<const A extends z.core.SomeType, B extends z.core.SomeType = z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>(in_: A, out: B, params: {
+    decode: (value: z.TypeOf<A>, payload: z.core.ParsePayload<z.TypeOf<A>>) => z.util.MaybeAsync<z.input<B>>;
+    encode: (value: z.input<B>, payload: z.core.ParsePayload<z.input<B>>) => z.util.MaybeAsync<z.TypeOf<A>>;
+  }): z.ZodCodec<A, B>;
+  ZodReadonly: z.core.$constructor<z.ZodReadonly<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$ZodReadonlyDef<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+  readonly<T extends z.core.SomeType>(innerType: T): z.ZodReadonly<T>;
+  ZodTemplateLiteral: z.core.$constructor<z.ZodTemplateLiteral<string>, z.core.$ZodTemplateLiteralDef>;
+  templateLiteral<const Parts extends z.core.$ZodTemplateLiteralPart[]>(parts: Parts, params?: string | z.core.$ZodTemplateLiteralParams): z.ZodTemplateLiteral<z.core.$PartsToTemplateLiteral<Parts>>;
+  ZodLazy: z.core.$constructor<z.ZodLazy<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$ZodLazyDef<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+  lazy<T extends z.core.SomeType>(getter: () => T): z.ZodLazy<T>;
+  ZodPromise: z.core.$constructor<z.ZodPromise<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$ZodPromiseDef<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+  promise<T extends z.core.SomeType>(innerType: T): z.ZodPromise<T>;
+  ZodFunction: z.core.$constructor<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>, z.core.$ZodFunctionDef<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
+  _function(): z.ZodFunction;
+  _function<const In extends ReadonlyArray<z.core.$ZodType>>(params: {
+    input: In;
+  }): z.ZodFunction<z.ZodTuple<In, null>, z.core.$ZodFunctionOut>;
+  _function<const In extends ReadonlyArray<z.core.$ZodType>, const Out extends z.core.$ZodFunctionOut = z.core.$ZodFunctionOut>(params: {
+    input: In;
+    output: Out;
+  }): z.ZodFunction<z.ZodTuple<In, null>, Out>;
+  _function<const In extends z.core.$ZodFunctionIn = z.core.$ZodFunctionArgs>(params: {
+    input: In;
+  }): z.ZodFunction<In, z.core.$ZodFunctionOut>;
+  _function<const Out extends z.core.$ZodFunctionOut = z.core.$ZodFunctionOut>(params: {
+    output: Out;
+  }): z.ZodFunction<z.core.$ZodFunctionIn, Out>;
+  _function<In extends z.core.$ZodFunctionIn = z.core.$ZodFunctionArgs, Out extends z.core.$ZodType = z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>(params?: {
+    input: In;
+    output: Out;
+  }): z.ZodFunction<In, Out>;
+  function: typeof z._function;
+  ZodCustom: z.core.$constructor<z.ZodCustom<unknown, unknown>, z.core.$ZodCustomDef<unknown>>;
+  check<O = unknown>(fn: z.core.CheckFn<O>): z.core.$ZodCheck<O>;
+  custom<O>(fn?: (data: unknown) => unknown, _params?: string | z.core.$ZodCustomParams | undefined): z.ZodCustom<O, O>;
+  refine<T>(fn: (arg: NoInfer<T>) => z.util.MaybeAsync<unknown>, _params?: string | z.core.$ZodCustomParams): z.core.$ZodCheck<T>;
+  superRefine<T>(fn: (arg: T, payload: z.RefinementCtx<T>) => void | Promise<void>): z.core.$ZodCheck<T>;
+  describe: typeof z.core.describe;
+  meta: typeof z.core.meta;
+  instanceof: typeof z.instanceof;
+  stringbool: (_params?: string | z.core.$ZodStringBoolParams) => z.ZodCodec<z.ZodString, z.ZodBoolean>;
+  json(params?: string | z.core.$ZodCustomParams): z.ZodJSONSchema;
+  preprocess<A, U extends z.core.SomeType, B = unknown>(fn: (arg: B, ctx: z.RefinementCtx) => A, schema: U): z.ZodPipe<z.ZodTransform<A, B>, U>;
+  lt: typeof z.lt;
+  lte: typeof z.lte;
+  gt: typeof z.gt;
+  gte: typeof z.gte;
+  positive: typeof z.positive;
+  negative: typeof z.negative;
+  nonpositive: typeof z.nonpositive;
+  nonnegative: typeof z.nonnegative;
+  multipleOf: typeof z.multipleOf;
+  maxSize: typeof z.maxSize;
+  minSize: typeof z.minSize;
+  size: typeof z.size;
+  maxLength: typeof z.maxLength;
+  minLength: typeof z.minLength;
+  length: typeof z.length;
+  regex: typeof z.regex;
+  lowercase: typeof z.lowercase;
+  uppercase: typeof z.uppercase;
+  includes: typeof z.includes;
+  startsWith: typeof z.startsWith;
+  endsWith: typeof z.endsWith;
+  property: typeof z.property;
+  mime: typeof z.mime;
+  overwrite: typeof z.overwrite;
+  normalize: typeof z.normalize;
+  trim: typeof z.trim;
+  toLowerCase: typeof z.toLowerCase;
+  toUpperCase: typeof z.toUpperCase;
+  slugify: typeof z.slugify;
+  ZodIssueCode: {
+    readonly invalid_type: "invalid_type";
+    readonly too_big: "too_big";
+    readonly too_small: "too_small";
+    readonly invalid_format: "invalid_format";
+    readonly not_multiple_of: "not_multiple_of";
+    readonly unrecognized_keys: "unrecognized_keys";
+    readonly invalid_union: "invalid_union";
+    readonly invalid_key: "invalid_key";
+    readonly invalid_element: "invalid_element";
+    readonly invalid_value: "invalid_value";
+    readonly custom: "custom";
+  };
+  setErrorMap(map: z.ZodErrorMap): void;
+  getErrorMap(): z.ZodErrorMap<z.core.$ZodIssue> | undefined;
+  ZodFirstPartyTypeKind: typeof z.ZodFirstPartyTypeKind;
+  core: typeof z.core;
+  globalRegistry: z.core.$ZodRegistry<z.GlobalMeta, z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+  registry: typeof z.registry;
+  config: typeof z.config;
+  $output: typeof z.$output;
+  $input: typeof z.$input;
+  $brand: typeof z.$brand;
+  clone: typeof z.clone;
+  regexes: typeof z.regexes;
+  treeifyError: typeof z.treeifyError;
+  prettifyError: typeof z.prettifyError;
+  formatError: typeof z.formatError;
+  flattenError: typeof z.flattenError;
+  TimePrecision: {
+    readonly Any: null;
+    readonly Minute: -1;
+    readonly Second: 0;
+    readonly Millisecond: 3;
+    readonly Microsecond: 6;
+  };
+  util: typeof z.util;
+  NEVER: never;
+  toJSONSchema: typeof z.toJSONSchema;
+  fromJSONSchema: typeof z.fromJSONSchema;
+  locales: typeof z.locales;
+  ZodISODateTime: z.core.$constructor<z.ZodISODateTime, z.core.$ZodISODateTimeDef>;
+  ZodISODate: z.core.$constructor<z.ZodISODate, z.core.$ZodStringFormatDef<"date">>;
+  ZodISOTime: z.core.$constructor<z.ZodISOTime, z.core.$ZodISOTimeDef>;
+  ZodISODuration: z.core.$constructor<z.ZodISODuration, z.core.$ZodStringFormatDef<"duration">>;
+  iso: typeof z.iso;
+  coerce: typeof z.coerce;
+  z: typeof z.z;
+  default: typeof z.z;
+  stringNonEmpty: (message?: string) => z.ZodString;
+  notBlank: (message?: string) => z.ZodCustom<unknown, unknown>;
+  notEmpty: (message?: string) => z.ZodCustom<unknown, unknown>;
+  isTrue: (message?: string) => z.ZodCustom<unknown, unknown>;
+};
+//#endregion
+export { ZodType, zod };

package/dist/utils.mjs

@@ -0,0 +1,361 @@
+import { isBlank } from "./toolkit.mjs";
+import { useVModel } from "@vueuse/core";
+import Emitter from "emittery";
+import { computed, defineComponent, getCurrentInstance, inject, onMounted, onUnmounted, ref, useSlots } from "vue";
+import { isNotNil } from "es-toolkit";
+import { isEmpty } from "es-toolkit/compat";
+import * as z from "zod";
+import { ZodType } from "zod";
+export * from "@vueuse/core";
+//#region src/utils/strUtil.ts
+const replaceImgSrc = (html, func) => {
+	return html?.replace(/(<img[^>]*?src=)(["']?)(.*?)\2([^>]*?>)/gi, (match, prefix, quote, src, suffix) => {
+		return `${prefix}${quote}${func(src)}${quote}${suffix}`;
+	});
+};
+const fixHtml = (html, func) => {
+	return replaceImgSrc(html, func);
+};
+/**
+* 文字
+* @param name
+* @returns
+*/
+const nameGradient = (name) => {
+	let hash = 0;
+	for (let i = 0; i < name.length; i++) hash = name.charCodeAt(i) + ((hash << 5) - hash);
+	const hue = (hash % 360 + 360) % 360;
+	return `linear-gradient(135deg,hsl(${hue}, 55%, 50%),hsl(${(hue + 35) % 360}, 58%, 62%))`;
+};
+//#endregion
+//#region src/utils/array.ts
+/**
+* 转树结构
+* @param array
+* @param pid
+* @param childrenKey
+*/
+const arrayToArrayTree = (array, pid = "0", childrenKey) => {
+	const tree = [];
+	array.forEach((item) => {
+		if (item["pid"] === pid) {
+			const children = arrayToArrayTree(array, item["id"], childrenKey);
+			if (children.length) item[childrenKey || "children"] = children;
+			tree.push(item);
+		}
+	});
+	return tree;
+};
+//#endregion
+//#region src/utils/util.ts
+/**
+* 生成uuid
+* @param size 大小
+* @returns uuid
+*/
+const generateUUID = (size = 21) => {
+	const chars = "ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW";
+	let id = "";
+	for (let i = 0; i < size; i++) id += chars.charAt(Math.floor(Math.random() * 64));
+	return id;
+};
+/**
+* 数字穿插函数
+* @param arr 数组
+* @param separator 分隔符
+* @param arr 数组
+*/
+const intersperse = (arr, separator) => {
+	if (arr.length === 0) return [];
+	return arr.slice(0, -1).flatMap((x) => [x, separator]).concat(arr.at(-1));
+};
+/**
+* 数字穿插函数  [1,2,3]=>[1,0,2,0,3]
+* @param arr 数组
+* @param fun 函数
+* @param arr 数组
+*/
+const intersperseFun = (arr, fun) => {
+	if (arr.length === 0) return [];
+	return arr.slice(0, -1).flatMap((x, index) => [x, fun(index)]).concat(arr.at(-1));
+};
+//#endregion
+//#region src/utils/ossUtil.ts
+/**
+* 阿里云 oss
+*/
+var AliOssAbstract = class {
+	cdnImg = (src, options) => {
+		if (!src) return "";
+		let u = new URL(src, this.baseUrl);
+		if (options) {
+			if (!options.m) options.m = "fill";
+			const str = `image/resize,${Object.keys(options).map((key) => `${key}_${options[key]}`).join(",")},limit_0/auto-orient,1/quality,q_100`;
+			u.searchParams.append("x-oss-process", str);
+		}
+		return u.href;
+	};
+	cdnUrl = (src, origin = true, search = true) => {
+		if (!src) return "";
+		let u = new URL(src, this.baseUrl);
+		if (!search) u.searchParams.forEach((value, key) => u.searchParams.delete(key));
+		return origin ? u.href : u.pathname + u.search;
+	};
+};
+/**
+* 七牛
+*/
+var QiniuAbstract = class {
+	cdnImg = (src, options) => {
+		if (!src) return src;
+		let u = new URL(src, this.baseUrl);
+		if (options) {
+			if (!options.m) options.m = "fill";
+			const str = `imageView2/0/${Object.keys(options).map((key) => `${key}_${options[key]}`).join("/")}/format/jpg/q/75`;
+			u.pathname += `?` + str;
+		}
+		return u.href;
+	};
+	cdnUrl = (src, origin = true, search = true) => {
+		if (!src) return src;
+		let u = new URL(src, this.baseUrl);
+		if (!search) u.searchParams.forEach((value, key) => u.searchParams.delete(key));
+		return origin ? u.href : u.pathname + u.search;
+	};
+};
+/**
+* 天翼云
+*/
+var CtOssAbstract = class {
+	cdnImg = (src, options) => {
+		if (!src) return src;
+		let u = new URL(src, this.baseUrl);
+		if (options) {
+			if (!options.m) options.m = "mfit";
+			const str = `image/resize,${Object.keys(options).map((key) => `${key}_${options[key]}`).join(",")},limit_1/format,jpg/bright,0/contrast,0`;
+			u.searchParams.append("x-image-process", str);
+		}
+		return u.href;
+	};
+	cdnUrl = (src, origin = true, search = true) => {
+		if (!src) return src;
+		let u = new URL(src, this.baseUrl);
+		if (!search) u.searchParams.forEach((value, key) => u.searchParams.delete(key));
+		return origin ? u.href : u.pathname + u.search;
+	};
+};
+//#endregion
+//#region src/utils/hook.ts
+const useNodeJSX = (name, def) => {
+	const instance = getCurrentInstance();
+	return computed(() => {
+		if (!instance) return def;
+		const slots = useSlots();
+		if (slots[name]) return (params) => slots[name](params);
+		if (instance.props[name]) return () => instance.props[name];
+		return def;
+	});
+};
+/**
+* 获取上级prop没有就获取注入
+* @param name
+* @param defaultValue
+*/
+const useInjectProp = (name, defaultValue) => {
+	const instance = getCurrentInstance();
+	const injectValue = inject(name, defaultValue);
+	const key = typeof name === "symbol" ? name.description : name;
+	return useVModel(instance.props, key, null, {
+		passive: true,
+		defaultValue: injectValue
+	});
+};
+const defineAction = (setup, options) => {
+	return (...args) => {
+		const emitter = new Emitter();
+		const ctx = {};
+		if (options?.emit) for (const [methodName, callbackDef] of Object.entries(options.emit)) ctx[methodName] = (...args) => {
+			emitter.emit(methodName, args);
+		};
+		const json = setup(ctx, ...args);
+		if (json) {
+			for (const key in json) if (typeof json[key] === "function") json[key] = json[key].bind(json);
+		}
+		for (const key of Object.keys(ctx)) json[key] = (callback) => {
+			emitter.on(key, ({ data }) => callback(...data));
+			return json;
+		};
+		return json;
+	};
+};
+//#endregion
+//#region src/utils/components/createTemplate.ts
+const LOADING_KEY = Symbol("LOADING_KEY");
+const loadingRegistry = /* @__PURE__ */ new WeakMap();
+const getLoadingHandler = (instance) => {
+	return loadingRegistry.get(instance);
+};
+/**
+* 创建模板
+*/
+const useCreateTemplate = () => {
+	const template = ref();
+	const component = defineComponent(() => {
+		return () => template.value;
+	});
+	component.jsx = (jsx) => {
+		template.value = jsx;
+	};
+	component.remove = () => {
+		template.value = void 0;
+	};
+	return component;
+};
+/**
+* 创建加载模板
+*/
+const useCreateLoading = defineAction((ctx) => {
+	const loadingCount = ref(0);
+	const loading = computed(() => loadingCount.value > 0);
+	const handler = {
+		start() {
+			loadingCount.value++;
+		},
+		end() {
+			loadingCount.value = Math.max(0, loadingCount.value - 1);
+			if (loadingCount.value === 0) ctx.onSuccess(false);
+		}
+	};
+	const instance = getCurrentInstance();
+	onMounted(() => {
+		if (instance) loadingRegistry.set(instance, handler);
+	});
+	onUnmounted(() => {
+		if (instance) loadingRegistry.delete(instance);
+	});
+	return {
+		loading,
+		Template: defineComponent(() => {
+			const slots = useSlots();
+			return () => slots.default?.();
+		})
+	};
+}, { emit: { onSuccess: (val) => void 0 } });
+//#endregion
+//#region src/utils/vue.ts
+/**
+* 外部获取provide
+* @param key
+* @param instance
+*/
+const injectExternal = (key, instance) => {
+	if (!instance) return;
+	return instance?.provides[key] || injectExternal(key, instance.parent);
+};
+//#endregion
+//#region src/utils/assert.ts
+/**
+* 断言工具类
+*/
+var AssertAbstract = class {
+	/**
+	* 断言条件为真，否则抛出错误
+	* @param {boolean} condition - 要断言的条件
+	* @param {string} [message='Assertion failed'] - 错误信息
+	*/
+	isTrue(condition, message = "Assertion failed") {
+		if (!condition) this.throwError("isTrue", message);
+	}
+	/**
+	* 断言条件为假，否则抛出错误
+	* @param {boolean} condition - 要断言的条件
+	* @param {string} [message='Assertion failed'] - 错误信息
+	*/
+	isFalse(condition, message = "Assertion failed") {
+		if (condition) this.throwError("isFalse", message);
+	}
+	/**
+	* 断言值不为 null 或 undefined
+	* @param {*} value - 要检查的值
+	* @param {string} [message='Value must not be null or undefined'] - 错误信息
+	*/
+	notNull(value, message = "Value must not be null or undefined") {
+		if (!isNotNil(value)) this.throwError("notNull", message);
+	}
+	/**
+	* 断言值为非空白字符串（即：是字符串，且去除两端空白后非空）
+	* @param {any} value - 要检查的值
+	* @param {string} [message='must not be blank'] - 错误信息
+	*/
+	notBlank(value, message = "must not be blank") {
+		if (typeof value !== "string") this.throwError("notBlank", message);
+		if (value.trim().length === 0) this.throwError("notBlank", message);
+	}
+	/**
+	* 断言值为指定类型
+	* @param {*} value - 要检查的值
+	* @param {string} expectedType - 期望的类型（如 'string', 'number', 'object' 等）
+	* @param {string} [message] - 错误信息
+	*/
+	isType(value, expectedType, message) {
+		const actualType = typeof value;
+		if (actualType !== expectedType) {
+			const msg = message || `Expected type "${expectedType}", but got "${actualType}"`;
+			this.throwError("isType", msg);
+		}
+	}
+	/**
+	* 断言值为非空
+	* @param {any} value - 要检查的字符串
+	* @param {string} [message='must not be empty'] - 错误信息
+	*/
+	notEmpty(value, message = "must not be empty") {
+		if (isEmpty(value)) this.throwError("notEmpty", message);
+	}
+	/**
+	* 断言值为整数
+	* @param {number} value - 要检查的数值
+	* @param {string} [message='Value must be an integer'] - 错误信息
+	*/
+	isInteger(value, message = "Value must be an integer") {
+		this.isType(value, "number", "Value must be a number for isInteger check");
+		if (!Number.isInteger(value)) this.throwError("isInteger", message);
+	}
+	/**
+	* 断言两个值相等（使用严格相等 ===）
+	* @param {*} actual - 实际值
+	* @param {*} expected - 期望值
+	* @param {string} [message] - 错误信息
+	*/
+	equals(actual, expected, message) {
+		if (actual !== expected) {
+			const msg = message || `Expected ${JSON.stringify(expected)}, but got ${JSON.stringify(actual)}`;
+			this.throwError("equals", msg);
+		}
+	}
+	/**
+	* 断言数值在指定范围内（包含边界）
+	* @param {number} value - 要检查的数值
+	* @param {number} min - 最小值（含）
+	* @param {number} max - 最大值（含）
+	* @param {string} [message] - 错误信息
+	*/
+	inRange(value, min, max, message) {
+		this.isType(value, "number", "Value must be a number for inRange check");
+		if (value < min || value > max) {
+			const msg = message || `Value ${value} is not in range [${min}, ${max}]`;
+			this.throwError("inRange", msg);
+		}
+	}
+};
+//#endregion
+//#region src/utils/zod.ts
+const zod = {
+	...z,
+	stringNonEmpty: (message = "该字段不能为空") => z.string(message).trim().min(1, message),
+	notBlank: (message = "该字段不能为空") => z.custom((val) => isNotNil(val) && !isBlank(val), { error: message }),
+	notEmpty: (message = "该字段不能为空") => z.custom((val) => !isEmpty(val), { error: message }),
+	isTrue: (message = "该字段不能为空") => z.custom((val) => val === true, { error: message })
+};
+//#endregion
+export { AliOssAbstract, AssertAbstract, CtOssAbstract, LOADING_KEY, QiniuAbstract, ZodType, arrayToArrayTree, defineAction, fixHtml, generateUUID, getLoadingHandler, injectExternal, intersperse, intersperseFun, nameGradient, replaceImgSrc, useCreateLoading, useCreateTemplate, useInjectProp, useNodeJSX, zod };

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@okcy/core",
+  "version": "1.0.0",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./crypto": "./dist/crypto.mjs",
+    "./dayjs": "./dist/dayjs.mjs",
+    "./emittery": "./dist/emittery.mjs",
+    "./toolkit": "./dist/toolkit.mjs",
+    "./utils": "./dist/utils.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@vueuse/core": "14.1.0",
+    "crypto.js": "^3.3.4",
+    "dayjs": "^1.11.18",
+    "emittery": "^2.0.0",
+    "es-toolkit": "^1.44.0",
+    "vue": "3.5.24",
+    "zod": "4.3.6"
+  },
+  "devDependencies": {
+    "vite-plus": "0.3.1"
+  },
+  "scripts": {
+    "dev": "vp pack --watch",
+    "build": "vp pack"
+  }
+}