@kubb/core 2.0.0-beta.10 → 2.0.0-beta.12

package/src/build.ts

@@ -1,18 +1,17 @@
-import pc from 'picocolors'
+import c from 'tinyrainbow'
 
-import { clean } from './utils/clean.ts'
-import { createLogger, LogLevel } from './utils/logger.ts'
-import { randomPicoColour } from './utils/randomColour.ts'
-import { read } from './utils/read.ts'
+import { clean } from './fs/clean.ts'
+import { read } from './fs/read.ts'
 import { URLPath } from './utils/URLPath.ts'
 import { isInputPath } from './config.ts'
 import { FileManager } from './FileManager.ts'
+import { createLogger, LogLevel, randomCliColour } from './logger.ts'
 import { PluginManager } from './PluginManager.ts'
 import { isPromise } from './PromiseManager.ts'
 
 import type { KubbFile } from './FileManager.ts'
+import type { Logger } from './logger.ts'
 import type { KubbPlugin, PluginContext, PluginParameter, TransformResult } from './types.ts'
-import type { Logger } from './utils/logger.ts'
 import type { QueueJob } from './utils/Queue.ts'
 
 type BuildOptions = {
@@ -51,7 +50,7 @@ async function setup(options: BuildOptions): Promise<PluginManager> {
   } catch (e) {
     if (isInputPath(config)) {
       throw new Error(
-        'Cannot read file/URL defined in `input.path` or set with `kubb generate PATH` in the CLI of your Kubb config ' + pc.dim(config.input.path),
+        'Cannot read file/URL defined in `input.path` or set with `kubb generate PATH` in the CLI of your Kubb config ' + c.dim(config.input.path),
         {
           cause: e,
         },
@@ -117,20 +116,20 @@ async function setup(options: BuildOptions): Promise<PluginManager> {
       }
 
       if (logger.logLevel === LogLevel.debug) {
-        logger.info(`PluginKey ${pc.dim(JSON.stringify(plugin.key))} \nwith source\n\n${code}`)
+        logger.info(`PluginKey ${c.dim(JSON.stringify(plugin.key))} \nwith source\n\n${code}`)
       }
     }
   })
 
   pluginManager.on('executed', (executer) => {
     const { hookName, plugin, output, parameters } = executer
-    const messsage = `${randomPicoColour(plugin.name)} Executing ${hookName}`
+    const messsage = `${randomCliColour(plugin.name)} Executing ${hookName}`
 
     if (logger.logLevel === LogLevel.info && logger.spinner) {
       if (hookName === 'writeFile') {
         const [_code, path] = parameters as PluginParameter<'writeFile'>
 
-        logger.spinner.suffixText = pc.dim(path)
+        logger.spinner.suffixText = c.dim(path)
       } else {
         logger.spinner.suffixText = messsage
       }
@@ -139,9 +138,9 @@ async function setup(options: BuildOptions): Promise<PluginManager> {
     if (logger.logLevel === LogLevel.debug) {
       logger.info(messsage)
       const logs = [
-        parameters && `${pc.bgWhite(`Parameters`)} ${randomPicoColour(plugin.name)} ${hookName}`,
+        parameters && `${c.bgWhite(`Parameters`)} ${randomCliColour(plugin.name)} ${hookName}`,
         JSON.stringify(parameters, undefined, 2),
-        output && `${pc.bgWhite('Output')} ${randomPicoColour(plugin.name)} ${hookName}`,
+        output && `${c.bgWhite('Output')} ${randomCliColour(plugin.name)} ${hookName}`,
         output,
       ].filter(Boolean)
 

package/src/fs/index.ts

@@ -0,0 +1,3 @@
+export { clean } from './clean.ts'
+export { getRelativePath, read, readSync } from './read.ts'
+export { write } from './write.ts'

package/src/index.ts

@@ -3,16 +3,16 @@ import { build } from './build.ts'
 import type { ObjValueTuple, TupleToUnion } from '@kubb/types'
 
 export { build, safeBuild } from './build.ts'
-export * from './config.ts'
-export * from './errors.ts'
-export * from './FileManager.ts'
+export { defineConfig, isInputPath } from './config.ts'
+export { Warning } from './errors.ts'
+export { FileManager, KubbFile } from './FileManager.ts'
 export { Generator } from './Generator.ts'
 export { PackageManager } from './PackageManager.ts'
 // dprint-ignore
 export { createPlugin, pluginName as name, pluginName } from './plugin.ts'
 export { PluginManager } from './PluginManager.ts'
 export { PromiseManager } from './PromiseManager.ts'
-export * from './types.ts'
+export type * from './types.ts'
 
 export interface _Register {}
 export type Plugins = _Register

package/src/{utils/logger.ts → logger.ts}

@@ -1,6 +1,8 @@
-import pc from 'picocolors'
+import seedrandom from 'seedrandom'
+import c, { createColors } from 'tinyrainbow'
 
 import type { Ora } from 'ora'
+import type { Formatter } from 'tinyrainbow'
 
 export const LogLevel = {
   silent: 'silent',
@@ -47,7 +49,7 @@ export function createLogger({ logLevel, name, spinner }: Props): Logger {
 
   const warn: Logger['warn'] = (message) => {
     if (message && spinner) {
-      spinner.warn(pc.yellow(message))
+      spinner.warn(c.yellow(message))
       logs.push(message)
     }
   }
@@ -73,4 +75,37 @@ export function createLogger({ logLevel, name, spinner }: Props): Logger {
   return logger
 }
 
-export { default as pc } from 'picocolors'
+const defaultColours = ['black', 'blue', 'darkBlue', 'cyan', 'gray', 'green', 'darkGreen', 'magenta', 'red', 'darkRed', 'yellow', 'darkYellow'] as const
+
+export function randomColour(text?: string, colours = defaultColours): string {
+  if (!text) {
+    return 'white'
+  }
+
+  const random = seedrandom(text)
+  const colour = colours.at(Math.floor(random() * colours.length)) || 'white'
+
+  return colour
+}
+
+export function randomCliColour(text?: string, colors = defaultColours): string {
+  const colours = createColors(true)
+
+  if (!text) {
+    return colours.white(text)
+  }
+
+  const colour = randomColour(text, colors)
+  const isDark = colour.includes('dark')
+  const key = colour.replace('dark', '').toLowerCase() as keyof typeof colours
+  const formatter: Formatter = colours[key] as Formatter
+
+  if (isDark) {
+    return c.bold(formatter(text))
+  }
+
+  if (typeof formatter !== 'function') {
+    throw new Error('Formatter for picoColor is not of type function/Formatter')
+  }
+  return formatter(text)
+}

package/src/plugin.ts

@@ -21,7 +21,7 @@ type Options = {
   resolvePath: PluginContext['resolvePath']
   resolveName: PluginContext['resolveName']
   logger: PluginContext['logger']
-  getPlugins: () => KubbPlugin[]
+  getPlugins: () => Array<KubbPlugin>
   plugin?: PluginContext['plugin']
 }
 

package/src/transformers/casing.ts

@@ -1,9 +1,9 @@
-import { camelCase as changeCaseCamel, camelCaseTransformMerge, pascalCase as changePascalCase, pascalCaseTransformMerge } from 'change-case'
+import { camelCase as changeCaseCamel, pascalCase as changePascalCase } from 'change-case'
 
 export function camelCase(text: string): string {
-  return changeCaseCamel(text, { delimiter: '', stripRegexp: /[^A-Z0-9$]/gi, transform: camelCaseTransformMerge })
+  return changeCaseCamel(text, { delimiter: '', mergeAmbiguousCharacters: true })
 }
 
 export function pascalCase(text: string): string {
-  return changePascalCase(text, { delimiter: '', stripRegexp: /[^A-Z0-9$]/gi, transform: pascalCaseTransformMerge })
+  return changePascalCase(text, { delimiter: '', mergeAmbiguousCharacters: true })
 }

package/src/types.ts

@@ -1,9 +1,9 @@
 import type { PossiblePromise } from '@kubb/types'
 import type { FileManager, KubbFile } from './FileManager.ts'
 import type { OptionsPlugins, PluginUnion } from './index.ts'
+import type { Logger, LogLevel } from './logger.ts'
 import type { PluginManager } from './PluginManager.ts'
 import type { Cache } from './utils/cache.ts'
-import type { Logger, LogLevel } from './utils/logger.ts'
 
 // config
 

package/src/utils/index.ts

@@ -1,18 +1,10 @@
-export * from './cache.ts'
-export * from './cache.ts'
-export * from './clean.ts'
-export * from './FunctionParams.ts'
-export * from './FunctionParams.ts'
-export * from './logger.ts'
-export * from './promise.ts'
-export * from './Queue.ts'
-export * from './Queue.ts'
-export * from './randomColour.ts'
-export * from './read.ts'
-export * from './renderTemplate.ts'
-export * from './throttle.ts'
-export * from './timeout.ts'
-export * from './TreeNode.ts'
-export * from './uniqueName.ts'
-export * from './URLPath.ts'
-export * from './write.ts'
+export type { FunctionParamsAST } from './FunctionParams.ts'
+export { FunctionParams } from './FunctionParams.ts'
+export { isPromise, isPromiseFulfilledResult, isPromiseRejectedResult } from './promise.ts'
+export type { QueueJob } from './Queue.ts'
+export { Queue } from './Queue.ts'
+export { renderTemplate } from './renderTemplate.ts'
+export { timeout } from './timeout.ts'
+export { getUniqueName, setUniqueName } from './uniqueName.ts'
+export type { URLObject } from './URLPath.ts'
+export { URLPath } from './URLPath.ts'

package/src/utils/randomColour.ts

@@ -1,39 +0,0 @@
-import pc from 'picocolors'
-import seedrandom from 'seedrandom'
-
-import type { Formatter } from 'picocolors/types.ts'
-
-const defaultColours = ['black', 'blue', 'darkBlue', 'cyan', 'gray', 'green', 'darkGreen', 'magenta', 'red', 'darkRed', 'yellow', 'darkYellow'] as const
-
-export function randomColour(text?: string, colours = defaultColours): string {
-  if (!text) {
-    return 'white'
-  }
-
-  const random = seedrandom(text)
-  const colour = colours.at(Math.floor(random() * colours.length)) || 'white'
-
-  return colour
-}
-
-export function randomPicoColour(text?: string, colors = defaultColours): string {
-  const colours = pc.createColors(true)
-
-  if (!text) {
-    return colours.white(text)
-  }
-
-  const colour = randomColour(text, colors)
-  const isDark = colour.includes('dark')
-  const key = colour.replace('dark', '').toLowerCase() as keyof typeof colours
-  const formatter: Formatter = colours[key] as Formatter
-
-  if (isDark) {
-    return pc.bold(formatter(text))
-  }
-
-  if (typeof formatter !== 'function') {
-    throw new Error('Formatter for picoColor is not of type function/Formatter')
-  }
-  return formatter(text)
-}

package/src/utils/throttle.ts

@@ -1,30 +0,0 @@
-export const throttle = <R, A extends any[]>(fn: (...args: A) => R, delay: number): [(...args: A) => R | undefined, () => void] => {
-  let wait = false
-  let timeout: NodeJS.Timeout
-  let cancelled = false
-
-  return [
-    (...args: A) => {
-      if (cancelled) {
-        return undefined
-      }
-      if (wait) {
-        return undefined
-      }
-
-      const val = fn(...args)
-
-      wait = true
-
-      timeout = setTimeout(() => {
-        wait = false
-      }, delay)
-
-      return val
-    },
-    () => {
-      cancelled = true
-      clearTimeout(timeout)
-    },
-  ]
-}