@dao-style/core 1.13.1-beta.2 → 1.13.1-beta.4

package/dist/utils/types.d.ts

@@ -17,3 +17,23 @@ export type GetSlots<T> = T extends {
 export type Mutable<T> = {
     -readonly [P in keyof T]: T[P];
 };
+type KeyToCamel<T extends string> = T extends `${infer K}-${infer R}` ? `${Capitalize<K>}${KeyToCamel<R>}` : Capitalize<T>;
+type UnionToIoF<U> = (U extends any ? (k: (x: U) => void) => void : never) extends ((k: infer I) => void) ? I : never;
+type UnionPop<U> = UnionToIoF<U> extends {
+    (a: infer A): void;
+} ? A : never;
+type Prepend<U, T extends any[]> = ((a: U, ...r: T) => void) extends (...r: infer R) => void ? R : never;
+type UnionToTupleRecursively<Union, Result extends any[]> = {
+    1: Result;
+    0: UnionToTupleRecursively_<Union, UnionPop<Union>, Result>;
+}[[Union] extends [never] ? 1 : 0];
+type UnionToTupleRecursively_<Union, Element, Result extends any[]> = UnionToTupleRecursively<Exclude<Union, Element>, Prepend<Element, Result>>;
+type UnionToTuple<U> = UnionToTupleRecursively<U, []>;
+type GetKey<Original extends string[], Target extends string> = Original extends [
+    infer T extends string,
+    ...infer R extends string[]
+] ? `on${KeyToCamel<T>}` extends Target ? T : GetKey<R, Target> : string;
+export type ParseEmits<T extends object, TKey extends keyof T = keyof T, KeyUnion extends UnionToTuple<TKey> = UnionToTuple<TKey>> = T extends Record<infer Key extends string, any> ? {
+    [K in `on${KeyToCamel<Key>}`]: KeyUnion extends string[] ? GetKey<KeyUnion, K> extends infer Z ? (Z extends TKey ? T[Z] : never) : never : never;
+} : never;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dao-style/core",
-  "version": "1.13.1-beta.2",
+  "version": "1.13.1-beta.4",
   "scripts": {
     "commit": "git-cz",
     "dev": "npm run dev:docs",