@kubb/core 2.0.0-beta.1 → 2.0.0-beta.11

package/src/FileManager.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-namespace */
 import crypto from 'node:crypto'
-import { extname } from 'node:path'
+import { extname, resolve } from 'node:path'
 
 import { print } from '@kubb/parser'
 import * as factory from '@kubb/parser/factory'
@@ -8,10 +8,10 @@ import * as factory from '@kubb/parser/factory'
 import isEqual from 'lodash.isequal'
 import { orderBy } from 'natural-orderby'
 
-import { read } from './utils/read.ts'
+import { getRelativePath, read } from './fs/read.ts'
+import { write } from './fs/write.ts'
+import transformers from './transformers/index.ts'
 import { timeout } from './utils/timeout.ts'
-import { transformers } from './utils/transformers/index.ts'
-import { write } from './utils/write.ts'
 import { BarrelManager } from './BarrelManager.ts'
 
 import type { GreaterThan } from '@kubb/types'
@@ -28,7 +28,14 @@ export namespace KubbFile {
      * @example ["useState"]
      * @example "React"
      */
-    name: string | Array<string>
+    name:
+      | string
+      | Array<
+        string | {
+          propertyName: string
+          name?: string
+        }
+      >
     /**
      * Path for the import
      * @xample '@kubb/core'
@@ -38,6 +45,14 @@ export namespace KubbFile {
      * Add `type` prefix to the import, this will result in: `import type { Type } from './path'`.
      */
     isTypeOnly?: boolean
+    /**
+     * Add `* as` prefix to the import, this will result in: `import * as path from './path'`.
+     */
+    isNameSpace?: boolean
+    /**
+     * When root is set it will get the path with relative getRelativePath(root, path).
+     */
+    root?: string
   }
 
   export type Export = {
@@ -104,8 +119,8 @@ export namespace KubbFile {
      */
     id?: string
     /**
-     * Name to be used to dynamicly create the baseName(based on input.path)
-     * Based on UNIX basename
+     * Name to be used to create the path
+     * Based on UNIX basename, `${name}.extName`
      * @link https://nodejs.org/api/path.html#pathbasenamepath-suffix
      */
     baseName: TBaseName
@@ -130,10 +145,6 @@ export namespace KubbFile {
      * This will override `process.env[key]` inside the `source`, see `getFileSource`.
      */
     env?: NodeJS.ProcessEnv
-    /**
-     * @deprecated
-     */
-    validate?: boolean
   }
 
   export type ResolvedFile<
@@ -144,6 +155,12 @@ export namespace KubbFile {
      * @default crypto.randomUUID()
      */
     id: UUID
+    /**
+     * Contains the first part of the baseName, generated based on baseName
+     * @link  https://nodejs.org/api/path.html#pathformatpathobject
+     */
+
+    name: string
   }
 }
 
@@ -156,8 +173,19 @@ type AddResult<T extends Array<KubbFile.File>> = Promise<
 >
 
 type AddIndexesProps = {
-  root: KubbFile.Path
-  extName?: KubbFile.Extname
+  /**
+   * Root based on root and output.path specified in the config
+   */
+  root: string
+  /**
+   * Output for plugin
+   */
+  output: {
+    path: string
+    exportAs?: string
+    extName?: KubbFile.Extname
+    exportType?: 'barrel' | false
+  }
   options?: BarrelManagerOptions
   meta?: KubbFile.File['meta']
 }
@@ -205,10 +233,6 @@ export class FileManager {
   }
 
   #validate(file: KubbFile.File): void {
-    if (!file.validate) {
-      return
-    }
-
     if (!file.path.toLowerCase().endsWith(file.baseName.toLowerCase())) {
       throw new Error(`${file.path} should end with the baseName ${file.baseName}`)
     }
@@ -218,7 +242,7 @@ export class FileManager {
     ...files: T
   ): AddResult<T> {
     const promises = files.map((file) => {
-      this.#validate(file)
+      // this.#validate(file)
 
       if (file.override) {
         return this.#add(file)
@@ -238,7 +262,7 @@ export class FileManager {
 
   async #add(file: KubbFile.File): Promise<KubbFile.ResolvedFile> {
     const controller = new AbortController()
-    const resolvedFile: KubbFile.ResolvedFile = { id: crypto.randomUUID(), ...file }
+    const resolvedFile: KubbFile.ResolvedFile = { id: crypto.randomUUID(), name: transformers.trimExtName(file.baseName), ...file }
 
     this.#cache.set(resolvedFile.path, [{ cancel: () => controller.abort(), ...resolvedFile }])
 
@@ -272,15 +296,45 @@ export class FileManager {
     return this.#add(file)
   }
 
-  async addIndexes({ root, extName = '.ts', meta, options = {} }: AddIndexesProps): Promise<Array<KubbFile.File> | undefined> {
-    const barrelManager = new BarrelManager(options)
+  async addIndexes({ root, output, meta, options = {} }: AddIndexesProps): Promise<Array<KubbFile.File> | undefined> {
+    const { exportType = 'barrel' } = output
 
-    const files = barrelManager.getIndexes(root, extName)
+    if (!exportType) {
+      return undefined
+    }
+
+    const exportPath = output.path.startsWith('./') ? output.path : `./${output.path}`
+    const barrelManager = new BarrelManager({ extName: output.extName, ...options })
+    const files = barrelManager.getIndexes(resolve(root, output.path))
 
     if (!files) {
       return undefined
     }
 
+    const rootFile: KubbFile.File = {
+      path: resolve(root, 'index.ts'),
+      baseName: 'index.ts',
+      source: '',
+      exports: [
+        output.exportAs
+          ? {
+            name: output.exportAs,
+            asAlias: true,
+            path: exportPath,
+            isTypeOnly: options.isTypeOnly,
+          }
+          : {
+            path: exportPath,
+            isTypeOnly: options.isTypeOnly,
+          },
+      ],
+    }
+
+    await this.#addOrAppend({
+      ...rootFile,
+      meta: meta ? meta : rootFile.meta,
+    })
+
     return await Promise.all(
       files.map((file) => {
         return this.#addOrAppend({
@@ -335,51 +389,7 @@ export class FileManager {
   // statics
 
   static getSource<TMeta extends KubbFile.FileMetaBase = KubbFile.FileMetaBase>(file: KubbFile.File<TMeta>): string {
-    if (!FileManager.isExtensionAllowed(file.baseName)) {
-      return file.source
-    }
-
-    const exports = file.exports ? combineExports(file.exports) : []
-    const imports = file.imports ? combineImports(file.imports, exports, file.source) : []
-
-    const importNodes = imports.map((item) => factory.createImportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly }))
-    const exportNodes = exports.map((item) =>
-      factory.createExportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly, asAlias: item.asAlias })
-    )
-
-    return [print([...importNodes, ...exportNodes]), getEnvSource(file.source, file.env)].join('\n')
-  }
-  static combineFiles<TMeta extends KubbFile.FileMetaBase = KubbFile.FileMetaBase>(files: Array<KubbFile.File<TMeta> | null>): Array<KubbFile.File<TMeta>> {
-    return files.filter(Boolean).reduce((acc, file: KubbFile.File<TMeta>) => {
-      const prevIndex = acc.findIndex((item) => item.path === file.path)
-
-      if (prevIndex === -1) {
-        return [...acc, file]
-      }
-
-      const prev = acc[prevIndex]
-
-      if (prev && file.override) {
-        acc[prevIndex] = {
-          imports: [],
-          exports: [],
-          ...file,
-        }
-        return acc
-      }
-
-      if (prev) {
-        acc[prevIndex] = {
-          ...file,
-          source: prev.source && file.source ? `${prev.source}\n${file.source}` : '',
-          imports: [...(prev.imports || []), ...(file.imports || [])],
-          exports: [...(prev.exports || []), ...(file.exports || [])],
-          env: { ...(prev.env || {}), ...(file.env || {}) },
-        }
-      }
-
-      return acc
-    }, [] as Array<KubbFile.File<TMeta>>)
+    return getSource<TMeta>(file)
   }
   static getMode(path: string | undefined | null): KubbFile.Mode {
     if (!path) {
@@ -397,6 +407,37 @@ export class FileManager {
   }
 }
 
+export function getSource<TMeta extends KubbFile.FileMetaBase = KubbFile.FileMetaBase>(file: KubbFile.File<TMeta>): string {
+  if (!FileManager.isExtensionAllowed(file.baseName)) {
+    return file.source
+  }
+
+  const exports = file.exports ? combineExports(file.exports) : []
+  const imports = file.imports ? combineImports(file.imports, exports, file.source) : []
+
+  const importNodes = imports.filter(item => {
+    // isImportNotNeeded
+    // trim extName
+    return item.path !== transformers.trimExtName(file.path)
+  }).map((item) => {
+    return factory.createImportDeclaration({
+      name: item.name,
+      path: item.root ? getRelativePath(item.root, item.path) : item.path,
+      isTypeOnly: item.isTypeOnly,
+    })
+  })
+  const exportNodes = exports.map((item) =>
+    factory.createExportDeclaration({
+      name: item.name,
+      path: item.path,
+      isTypeOnly: item.isTypeOnly,
+      asAlias: item.asAlias,
+    })
+  )
+
+  return [print([...importNodes, ...exportNodes]), getEnvSource(file.source, file.env)].join('\n')
+}
+
 export function combineExports(exports: Array<KubbFile.Export>): Array<KubbFile.Export> {
   const combinedExports = orderBy(exports, [(v) => !v.isTypeOnly], ['asc']).reduce((prev, curr) => {
     const name = curr.name
@@ -452,7 +493,7 @@ export function combineImports(imports: Array<KubbFile.Import>, exports: Array<K
     }
 
     if (Array.isArray(name)) {
-      name = name.filter((item) => hasImportInSource(item))
+      name = name.filter((item) => typeof item === 'string' ? hasImportInSource(item) : hasImportInSource(item.propertyName))
     }
 
     const prevByPath = prev.findLast((imp) => imp.path === curr.path && imp.isTypeOnly === curr.isTypeOnly)

package/src/PluginManager.ts

@@ -1,18 +1,19 @@
 /* eslint-disable @typescript-eslint/ban-types, @typescript-eslint/no-unsafe-argument */
 
+import { transformReservedWord } from './transformers/transformReservedWord.ts'
 import { EventEmitter } from './utils/EventEmitter.ts'
-import { LogLevel } from './utils/logger.ts'
 import { Queue } from './utils/Queue.ts'
-import { transformReservedWord } from './utils/transformers/transformReservedWord.ts'
 import { setUniqueName } from './utils/uniqueName.ts'
 import { ValidationPluginError } from './errors.ts'
 import { FileManager } from './FileManager.ts'
+import { LogLevel } from './logger.ts'
 import { definePlugin as defineCorePlugin } from './plugin.ts'
 import { isPromise, isPromiseRejectedResult } from './PromiseManager.ts'
 import { PromiseManager } from './PromiseManager.ts'
 
 import type { PossiblePromise } from '@kubb/types'
 import type { KubbFile } from './FileManager.ts'
+import type { Logger } from './logger.ts'
 import type { CorePluginOptions } from './plugin.ts'
 import type {
   GetPluginFactoryOptions,
@@ -28,7 +29,6 @@ import type {
   ResolveNameParams,
   ResolvePathParams,
 } from './types.ts'
-import type { Logger } from './utils/logger.ts'
 import type { QueueJob } from './utils/Queue.ts'
 
 type RequiredPluginLifecycle = Required<PluginLifecycle>
@@ -80,12 +80,12 @@ type Events = {
 export class PluginManager {
   readonly plugins: KubbPluginWithLifeCycle[]
   readonly fileManager: FileManager
-  readonly eventEmitter: EventEmitter<Events> = new EventEmitter()
+  readonly events: EventEmitter<Events> = new EventEmitter()
 
   readonly queue: Queue
   readonly config: KubbConfig
 
-  readonly executed: Executer[] = []
+  readonly executed: Array<Executer> = []
   readonly logger: Logger
   readonly #core: KubbPlugin<CorePluginOptions>
 
@@ -129,11 +129,11 @@ export class PluginManager {
         parameters: [params.baseName, params.directory, params.options as object],
       })
 
-      if (paths && paths?.length > 1) {
-        throw new Error(
+      if (paths && paths?.length > 1 && this.logger.logLevel === LogLevel.debug) {
+        this.logger.warn(
           `Cannot return a path where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : '"'} is not unique enough\n\nPaths: ${
             JSON.stringify(paths, undefined, 2)
-          }`,
+          }\n\nFalling back on the first item.\n`,
         )
       }
 
@@ -144,7 +144,6 @@ export class PluginManager {
       parameters: [params.baseName, params.directory, params.options as object],
     }).result
   }
-
   resolveName = (params: ResolveNameParams): string => {
     if (params.pluginKey) {
       const names = this.hookForPluginSync({
@@ -153,11 +152,11 @@ export class PluginManager {
         parameters: [params.name, params.type],
       })
 
-      if (names && names?.length > 1) {
-        throw new Error(
+      if (names && names?.length > 1 && this.logger.logLevel === LogLevel.debug) {
+        this.logger.warn(
           `Cannot return a name where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : '"'} is not unique enough\n\nNames: ${
             JSON.stringify(names, undefined, 2)
-          }`,
+          }\n\nFalling back on the first item.\n`,
         )
       }
 
@@ -172,12 +171,15 @@ export class PluginManager {
     return transformReservedWord(name)
   }
 
+  /**
+   * Instead of calling `pluginManager.events.on` you can use `pluginManager.on`. This one also has better types.
+   */
   on<TEventName extends keyof Events & string>(eventName: TEventName, handler: (...eventArg: Events[TEventName]) => void): void {
-    this.eventEmitter.on(eventName, handler as any)
+    this.events.on(eventName, handler as any)
   }
 
   /**
-   * Run only hook for a specific plugin name
+   * Run a specific hookName for plugin x.
    */
   hookForPlugin<H extends PluginLifecycleHooks>({
     pluginKey,
@@ -203,6 +205,9 @@ export class PluginManager {
 
     return Promise.all(promises)
   }
+  /**
+   * Run a specific hookName for plugin x.
+   */
 
   hookForPluginSync<H extends PluginLifecycleHooks>({
     pluginKey,
@@ -228,7 +233,7 @@ export class PluginManager {
   }
 
   /**
-   * Chains, first non-null result stops and returns
+   * First non-null result stops and will return it's value.
    */
   async hookFirst<H extends PluginLifecycleHooks>({
     hookName,
@@ -263,7 +268,7 @@ export class PluginManager {
   }
 
   /**
-   * Chains, first non-null result stops and returns
+   * First non-null result stops and will return it's value.
    */
   hookFirstSync<H extends PluginLifecycleHooks>({
     hookName,
@@ -299,7 +304,7 @@ export class PluginManager {
   }
 
   /**
-   * Parallel, runs all plugins
+   * Run all plugins in parallel(order will be based on `this.plugin` and if `pre` or `post` is set).
    */
   async hookParallel<H extends PluginLifecycleHooks, TOuput = void>({
     hookName,
@@ -327,7 +332,7 @@ export class PluginManager {
   }
 
   /**
-   * Chains, reduces returned value, handling the reduced value as the first hook argument
+   * Chain all plugins, `reduce` can be passed through to handle every returned value. The return value of the first plugin will be used as the first parameter for the plugin after that.
    */
   hookReduceArg0<H extends PluginLifecycleHooks>({
     hookName,
@@ -379,7 +384,7 @@ export class PluginManager {
     const plugins = [...this.plugins].filter((plugin) => plugin.name !== 'core')
 
     if (hookName) {
-      if (this.logger.logLevel === 'info') {
+      if (this.logger.logLevel === LogLevel.info) {
         const containsHookName = plugins.some((item) => item[hookName])
         if (!containsHookName) {
           this.logger.warn(`No hook ${hookName} found`)
@@ -388,28 +393,46 @@ export class PluginManager {
 
       return plugins.filter((item) => item[hookName])
     }
+    // TODO add test case for sorting with pre/post
 
-    return plugins
+    return plugins.map(plugin => {
+      if (plugin.pre) {
+        const isValid = plugin.pre.every(pluginName => plugins.find(pluginToFind => pluginToFind.name === pluginName))
+
+        if (!isValid) {
+          throw new ValidationPluginError(`This plugin has a pre set that is not valid(${JSON.stringify(plugin.pre, undefined, 2)})`)
+        }
+      }
+
+      return plugin
+    }).sort((a, b) => {
+      if (b.pre?.includes(a.name)) {
+        return 1
+      }
+      if (b.post?.includes(a.name)) {
+        return -1
+      }
+      return 0
+    })
   }
 
   getPluginsByKey(hookName: keyof PluginLifecycle, pluginKey: KubbPlugin['key']): KubbPlugin[] {
     const plugins = [...this.plugins]
-    const [searchKind, searchPluginName, searchIdentifier] = pluginKey
+    const [searchPluginName, searchIdentifier] = pluginKey
 
     const pluginByPluginName = plugins
       .filter((plugin) => plugin[hookName])
       .filter((item) => {
-        const [kind, name, identifier] = item.key
+        const [name, identifier] = item.key
 
         const identifierCheck = identifier?.toString() === searchIdentifier?.toString()
-        const kindCheck = kind === searchKind
         const nameCheck = name === searchPluginName
 
         if (searchIdentifier) {
-          return identifierCheck && kindCheck && nameCheck
+          return identifierCheck && nameCheck
         }
 
-        return kindCheck && nameCheck
+        return nameCheck
       })
 
     if (!pluginByPluginName?.length) {
@@ -417,7 +440,7 @@ export class PluginManager {
 
       const corePlugin = plugins.find((plugin) => plugin.name === 'core' && plugin[hookName])
 
-      if (this.logger.logLevel === 'info') {
+      if (this.logger.logLevel === LogLevel.debug) {
         if (corePlugin) {
           this.logger.warn(`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, falling back on the '@kubb/core' plugin`)
         } else {
@@ -433,7 +456,7 @@ export class PluginManager {
 
   #addExecutedToCallStack(executer: Executer | undefined) {
     if (executer) {
-      this.eventEmitter.emit('executed', executer)
+      this.events.emit('executed', executer)
       this.executed.push(executer)
     }
   }
@@ -463,7 +486,7 @@ export class PluginManager {
       return null
     }
 
-    this.eventEmitter.emit('execute', { strategy, hookName, parameters, plugin })
+    this.events.emit('execute', { strategy, hookName, parameters, plugin })
 
     const task = Promise.resolve()
       .then(() => {
@@ -525,7 +548,7 @@ export class PluginManager {
       return null
     }
 
-    this.eventEmitter.emit('execute', { strategy, hookName, parameters, plugin })
+    this.events.emit('execute', { strategy, hookName, parameters, plugin })
 
     try {
       if (typeof hook === 'function') {
@@ -557,7 +580,7 @@ export class PluginManager {
     const text = `${e.message} (plugin: ${plugin?.name || 'unknown'}, hook: ${hookName || 'unknown'})\n`
 
     this.logger.error(text)
-    this.eventEmitter.emit('error', e)
+    this.events.emit('error', e)
   }
 
   #parse<TPlugin extends KubbUserPluginWithLifeCycle>(
@@ -569,7 +592,7 @@ export class PluginManager {
 
     setUniqueName(plugin.name, usedPluginNames)
 
-    const key = plugin.key || ([plugin.kind, plugin.name, usedPluginNames[plugin.name]].filter(Boolean) as [typeof plugin.kind, typeof plugin.name, string])
+    const key = [plugin.name, usedPluginNames[plugin.name]].filter(Boolean) as [typeof plugin.name, string]
 
     if (plugin.name !== 'core' && usedPluginNames[plugin.name]! >= 2) {
       pluginManager.logger.warn('Using multiple of the same plugin is an experimental feature')
@@ -624,6 +647,6 @@ export class PluginManager {
 
   // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
   static get hooks() {
-    return ['validate', 'buildStart', 'resolvePath', 'resolveName', 'load', 'transform', 'writeFile', 'buildEnd'] as const
+    return ['buildStart', 'resolvePath', 'resolveName', 'load', 'transform', 'writeFile', 'buildEnd'] as const
   }
 }

package/src/build.ts

@@ -1,18 +1,17 @@
 import pc from 'picocolors'
 
-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, randomPicoColour } 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 = {
@@ -116,7 +115,7 @@ async function setup(options: BuildOptions): Promise<PluginManager> {
         logger.spinner.start(`💾 Writing`)
       }
 
-      if (logger.logLevel === 'debug') {
+      if (logger.logLevel === LogLevel.debug) {
         logger.info(`PluginKey ${pc.dim(JSON.stringify(plugin.key))} \nwith source\n\n${code}`)
       }
     }
@@ -157,11 +156,6 @@ export async function build(options: BuildOptions): Promise<BuildOutput> {
 
   const { fileManager, logger } = pluginManager
 
-  await pluginManager.hookParallel<'validate', true>({
-    hookName: 'validate',
-    parameters: [pluginManager.plugins],
-  })
-
   await pluginManager.hookParallel({
     hookName: 'buildStart',
     parameters: [options.config],
@@ -183,11 +177,6 @@ export async function safeBuild(options: BuildOptions): Promise<BuildOutput> {
   const { fileManager, logger } = pluginManager
 
   try {
-    await pluginManager.hookParallel<'validate', true>({
-      hookName: 'validate',
-      parameters: [pluginManager.plugins],
-    })
-
     await pluginManager.hookParallel({
       hookName: 'buildStart',
       parameters: [options.config],

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,17 +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 { SchemaGenerator } from './SchemaGenerator.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 type { Ora } from 'ora'
+import type { Formatter } from 'picocolors/types.ts'
 
 export const LogLevel = {
   silent: 'silent',
@@ -73,4 +75,39 @@ export function createLogger({ logLevel, name, spinner }: Props): Logger {
   return logger
 }
 
+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)
+}
+
 export { default as pc } from 'picocolors'