@kubb/react-fabric 0.7.2 → 0.7.3

package/src/utils/getFunctionParams.ts

@@ -35,10 +35,14 @@ type ParamItem =
       children?: Params
     })
 
+const TSBasicTypes = ['number', 'string', 'null', 'undefined', 'bigint', 'boolean', 'symbol'] as const
+
+type ParamEntry = [key: string, item?: ParamItem | undefined]
+
 export type Params = Record<string, Param | undefined>
 
 type Options = {
-  type: 'constructor' | 'call' | 'object' | 'objectValue'
+  type: 'constructor' | 'call' | 'object' | 'objectValue' | 'callback'
   transformName?: (name: string) => string
   transformType?: (type: string) => string
 }
@@ -64,44 +68,55 @@ function order(items: Array<[key: string, item?: ParamItem]>) {
   )
 }
 
-function parseChild(key: string, item: ParamItem, options: Options): string | null {
-  // @ts-expect-error
-  const entries = order(Object.entries(item.children))
+function processEntry(options: Options): ([key, item]: ParamEntry) => string | null {
+  return function ([key, item]: ParamEntry): string | null {
+    if (!item) return null
 
-  const types: string[] = []
-  const names: string[] = []
+    if (!item.children) return parseItem(key, item, options)
+    if (Object.keys(item.children).length === 0) return null
 
-  const optional = entries.every(([_key, item]) => item?.optional)
+    if (item.mode === 'inlineSpread') {
+      return getFunctionParams(item.children, options)
+    }
 
-  entries.forEach(([key, entryItem]) => {
-    if (entryItem) {
-      const name = parseItem(key, { ...entryItem, type: undefined }, options)
-      if (entryItem.children) {
-        const subTypes = Object.entries(entryItem.children)
-          .map(([key]) => {
-            return key
-          })
-          .join(', ')
-
-        if (subTypes) {
-          names.push(`${name}: { ${subTypes} }`)
-        } else {
-          names.push(name)
-        }
-      } else {
-        if (options.type === 'call' && options.transformName) {
-          names.push(`${key}: ${name}`)
-        } else {
-          names.push(name)
-        }
-      }
+    return parseChild(key, item, options)
+  }
+}
 
-      if (entries.some(([_key, item]) => item?.type)) {
-        types.push(parseItem(key, { ...entryItem, default: undefined }, options))
-      }
+function processChildEntry(options: Options, entries: ParamEntry[]): ([key, item]: ParamEntry) => { name: string | null; type: string | null } | null {
+  return function ([key, item]: ParamEntry): { name: string | null; type: string | null } | null {
+    if (!item) return null
+
+    const result = { name: null, type: null } as { name: string | null; type: string | null }
+
+    const name = parseItem(key, { ...item, type: undefined }, options, item.type)
+
+    if (!item.children) {
+      result.name = options.type === 'call' && options.transformName ? `${key}: ${name}` : name
+    } else {
+      const subTypes = Object.keys(item.children).join(', ')
+      result.name = subTypes ? `${name}: { ${subTypes} }` : name
+    }
+
+    const anySiblingHasType = entries.some(([_k, entries]) => !!entries?.type)
+    if (anySiblingHasType) {
+      result.type = parseItem(key, { ...item, default: undefined }, options, item.type)
     }
-  })
 
+    return result
+  }
+}
+
+function parseChild(key: string, item: ParamItem, options: Options): string | null {
+  const entries = order(Object.entries(item.children as Record<string, ParamItem | undefined>))
+
+  const optional = entries.every(([_key, item]) => item?.optional)
+
+  const childEntryProcessor = processChildEntry(options, entries)
+  const result = entries.map(childEntryProcessor).filter((item): item is { name: string | null; type: string | null } => item !== null)
+
+  const names = result.map(({ name }) => name).filter(Boolean)
+  const types = result.map(({ type }) => type).filter(Boolean)
   const name = item.mode === 'inline' ? key : names.length ? `{ ${names.join(', ')} }` : undefined
   const type = item.type ? item.type : types.length ? `{ ${types.join('; ')} }` : undefined
 
@@ -117,11 +132,11 @@ function parseChild(key: string, item: ParamItem, options: Options): string | nu
       optional: !item.default ? optional : undefined,
     } as ParamItem,
     options,
+    item.type,
   )
 }
 
-function parseItem(name: string, item: ParamItem, options: Options): string {
-  const acc: string[] = []
+function parseItem(name: string, item: ParamItem, options: Options, parentType?: string): string {
   const transformedName = options.transformName ? options.transformName(name) : name
   const transformedType = options.transformType && item.type ? options.transformType(item.type) : item.type
 
@@ -132,57 +147,59 @@ function parseItem(name: string, item: ParamItem, options: Options): string {
   if (options.type === 'objectValue') {
     return item.value ? `${transformedName}: ${item.value}` : transformedName
   }
+  if (options.type === 'callback') {
+    const isObject = (transformedType?.includes('{') && transformedType?.includes('}')) ?? false
+
+    if (transformedType === parentType) {
+      if (transformedType && !TSBasicTypes.includes(transformedType as (typeof TSBasicTypes)[number])) {
+        return `${transformedName}: { [K in keyof ${transformedType}]: () => ${transformedType}[K] }`
+      }
+    }
+    if (item.default) {
+      if (isObject) return transformedType ? `${transformedName}: ${transformedType} = ${item.default}` : `${transformedName} = ${item.default}`
+      return transformedType ? `${transformedName}: () => ${transformedType} = () => ${item.default}` : `${transformedName} = () => ${item.default}`
+    }
+    if (item.optional) {
+      if (isObject) return transformedType ? `${transformedName}?: ${transformedType}` : transformedName
+      return transformedType ? `${transformedName}?: () => ${transformedType}` : transformedName
+    }
+    if (transformedType) {
+      if (isObject) return `${transformedName}: ${transformedType}`
+      return `${transformedName}: () => ${transformedType}`
+    }
+    return transformedName
+  }
 
-  //LEGACY
-  if (item.type && options.type === 'constructor') {
+  if (options.type === 'constructor') {
+    if (item.mode === 'inlineSpread') {
+      return `... ${transformedName}`
+    }
+    if (item.value) {
+      return `${transformedName} : ${item.value}`
+    }
+    if (item.default) {
+      return transformedType ? `${transformedName}: ${transformedType} = ${item.default}` : `${transformedName} = ${item.default}`
+    }
     if (item.optional) {
-      acc.push(`${transformedName}?: ${transformedType}`)
-    } else {
-      acc.push(`${transformedName}: ${transformedType}${item.default ? ` = ${item.default}` : ''}`)
+      return transformedType ? `${transformedName}?: ${transformedType}` : `${transformedName}`
     }
-  } else if (item.default && options.type === 'constructor') {
-    acc.push(`${transformedName} = ${item.default}`)
-  } else if (item.value) {
-    acc.push(`${transformedName} : ${item.value}`)
-  } else if (item.mode === 'inlineSpread') {
-    acc.push(`... ${transformedName}`)
-  } else {
-    acc.push(transformedName)
+    if (transformedType) {
+      return `${transformedName}: ${transformedType}`
+    }
+
+    return transformedName
   }
 
-  return acc[0] as string
+  return transformedName
 }
 
 export function getFunctionParams(params: Params, options: Options): string {
-  const entries = order(Object.entries(params as Record<string, ParamItem | undefined>))
+  const entries: ParamEntry[] = order(Object.entries(params as Record<string, ParamItem | undefined>))
+  const entryProcessor = processEntry(options)
 
   return entries
-    .reduce((acc, [key, item]) => {
-      if (!item) {
-        return acc
-      }
-
-      if (item.children) {
-        if (Object.keys(item.children).length === 0) {
-          return acc
-        }
-
-        if (item.mode === 'inlineSpread') {
-          return [...acc, getFunctionParams(item.children, options)]
-        }
-
-        const parsedItem = parseChild(key, item, options)
-        if (!parsedItem) {
-          return acc
-        }
-
-        return [...acc, parsedItem]
-      }
-
-      const parsedItem = parseItem(key, item, options)
-
-      return [...acc, parsedItem]
-    }, [] as string[])
+    .map(entryProcessor)
+    .filter((item): item is string => item !== null)
     .join(', ')
 }
 
@@ -233,4 +250,8 @@ export class FunctionParams {
   toConstructor(): string {
     return getFunctionParams(this.#params, { type: 'constructor' })
   }
+
+  toCallback(): string {
+    return getFunctionParams(this.#params, { type: 'callback' })
+  }
 }