@kubb/core 1.15.0-canary.20231112T135011 → 2.0.0-alpha.10

package/src/utils/EventEmitter.ts

@@ -0,0 +1,24 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+import { EventEmitter as NodeEventEmitter } from 'node:events'
+
+export class EventEmitter<TEvents extends Record<string, any>> {
+  constructor() {
+    this.#emitter.setMaxListeners(100)
+  }
+  #emitter = new NodeEventEmitter()
+
+  emit<TEventName extends keyof TEvents & string>(eventName: TEventName, ...eventArg: TEvents[TEventName]): void {
+    this.#emitter.emit(eventName, ...(eventArg as []))
+  }
+
+  on<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArg: TEvents[TEventName]) => void): void {
+    this.#emitter.on(eventName, handler as any)
+  }
+
+  off<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArg: TEvents[TEventName]) => void): void {
+    this.#emitter.off(eventName, handler as any)
+  }
+  removeAll(): void {
+    this.#emitter.removeAllListeners()
+  }
+}

package/src/utils/FunctionParams.ts

@@ -0,0 +1,85 @@
+import { camelCase, camelCaseTransformMerge } from 'change-case'
+import { orderBy } from 'natural-orderby'
+
+type FunctionParamsASTWithoutType = {
+  name?: string
+  type?: string
+  /**
+   * @default true
+   */
+  required?: boolean
+  /**
+   * @default true
+   */
+  enabled?: boolean
+  default?: string
+}
+
+type FunctionParamsASTWithType = {
+  name?: never
+  type: string
+  /**
+   * @default true
+   */
+  required?: boolean
+  /**
+   * @default true
+   */
+  enabled?: boolean
+  default?: string
+}
+
+export type FunctionParamsAST = FunctionParamsASTWithoutType | FunctionParamsASTWithType
+export class FunctionParams {
+  public type?: 'generics' | 'typed'
+  public items: FunctionParamsAST[] = []
+  constructor(type?: 'generics' | 'typed') {
+    this.type = type
+
+    return this
+  }
+
+  add(item: FunctionParamsAST | Array<FunctionParamsAST | undefined> | undefined): FunctionParams {
+    if (!item) {
+      return this
+    }
+
+    if (Array.isArray(item)) {
+      item.filter(Boolean).forEach((it) => this.items.push(it))
+      return this
+    }
+    this.items.push(item)
+
+    return this
+  }
+
+  toString(): string {
+    const sortedData = orderBy(this.items.filter(Boolean), [(v) => !v.default, (v) => v.required ?? true], ['desc', 'desc'])
+
+    return sortedData
+      .filter(({ enabled = true }) => enabled)
+      .reduce((acc, { name, type, required = true, ...rest }) => {
+        if (!name) {
+          // when name is not se we will use TypeScript generics
+          acc.push(`${type}${rest.default ? ` = ${rest.default}` : ''}`)
+
+          return acc
+        }
+        // TODO check whey we still need the camelcase here
+        const parameterName = name.startsWith('{') ? name : camelCase(name, { delimiter: '', transform: camelCaseTransformMerge })
+
+        if (type) {
+          if (required) {
+            acc.push(`${parameterName}: ${type}${rest.default ? ` = ${rest.default}` : ''}`)
+          } else {
+            acc.push(`${parameterName}?: ${type}`)
+          }
+        } else {
+          acc.push(`${parameterName}`)
+        }
+
+        return acc
+      }, [] as string[])
+      .join(', ')
+  }
+}

package/src/utils/Queue.ts

@@ -0,0 +1,110 @@
+import crypto from 'node:crypto'
+import { performance } from 'node:perf_hooks'
+
+import { EventEmitter } from './EventEmitter.ts'
+
+export type QueueJob<T = unknown> = {
+  (...args: unknown[]): Promise<T | void>
+}
+
+type RunOptions = {
+  controller?: AbortController
+  name?: string
+  description?: string
+}
+
+type QueueItem = {
+  reject: <T>(reason?: T) => void
+  resolve: <T>(value: T | PromiseLike<T>) => void
+  job: QueueJob<unknown>
+} & Required<RunOptions>
+
+type Events = {
+  jobDone: [result: unknown]
+  jobFailed: [error: Error]
+}
+
+export class Queue {
+  #queue: QueueItem[] = []
+  readonly eventEmitter: EventEmitter<Events> = new EventEmitter()
+
+  #workerCount = 0
+
+  #maxParallel: number
+  #debug = false
+
+  constructor(maxParallel: number, debug = false) {
+    this.#maxParallel = maxParallel
+    this.#debug = debug
+  }
+
+  run<T>(job: QueueJob<T>, options: RunOptions = { controller: new AbortController(), name: crypto.randomUUID(), description: '' }): Promise<T> {
+    return new Promise<T>((resolve, reject) => {
+      const item = { reject, resolve, job, name: options.name, description: options.description || options.name } as QueueItem
+
+      options.controller?.signal.addEventListener('abort', () => {
+        this.#queue = this.#queue.filter((queueItem) => queueItem.name === item.name)
+
+        reject('Aborted')
+      })
+
+      this.#queue.push(item)
+      this.#work()
+    })
+  }
+
+  runSync<T>(job: QueueJob<T>, options: RunOptions = { controller: new AbortController(), name: crypto.randomUUID(), description: '' }): void {
+    new Promise<T>((resolve, reject) => {
+      const item = { reject, resolve, job, name: options.name, description: options.description || options.name } as QueueItem
+
+      options.controller?.signal.addEventListener('abort', () => {
+        this.#queue = this.#queue.filter((queueItem) => queueItem.name === item.name)
+      })
+
+      this.#queue.push(item)
+      this.#work()
+    })
+  }
+
+  get hasJobs(): boolean {
+    return this.#workerCount > 0 || this.#queue.length > 0
+  }
+
+  get count(): number {
+    return this.#workerCount
+  }
+
+  #work(): void {
+    if (this.#workerCount >= this.#maxParallel) {
+      return
+    }
+
+    this.#workerCount++
+
+    let entry: QueueItem | undefined
+    while ((entry = this.#queue.shift())) {
+      const { reject, resolve, job, name, description } = entry
+
+      if (this.#debug) {
+        performance.mark(name + '_start')
+      }
+
+      job()
+        .then((result) => {
+          this.eventEmitter.emit('jobDone', result)
+
+          resolve(result)
+
+          if (this.#debug) {
+            performance.mark(name + '_stop')
+            performance.measure(description, name + '_start', name + '_stop')
+          }
+        })
+        .catch((err) => {
+          this.eventEmitter.emit('jobFailed', err as Error)
+          reject(err)
+        })
+    }
+    this.#workerCount--
+  }
+}

package/src/utils/TreeNode.ts

@@ -0,0 +1,122 @@
+import dirTree from 'directory-tree'
+
+import { FileManager } from '../FileManager.ts'
+
+import type { DirectoryTree, DirectoryTreeOptions } from 'directory-tree'
+
+export type TreeNodeOptions = DirectoryTreeOptions
+
+export class TreeNode<T = unknown> {
+  public data: T
+
+  public parent?: TreeNode<T>
+
+  public children: Array<TreeNode<T>> = []
+
+  constructor(data: T, parent?: TreeNode<T>) {
+    this.data = data
+    this.parent = parent
+    return this
+  }
+
+  addChild(data: T): TreeNode<T> {
+    const child = new TreeNode(data, this)
+    if (!this.children) {
+      this.children = []
+    }
+    this.children.push(child)
+    return child
+  }
+
+  find(data?: T): TreeNode<T> | null {
+    if (!data) {
+      return null
+    }
+
+    if (data === this.data) {
+      return this
+    }
+
+    if (this.children?.length) {
+      for (let i = 0, { length } = this.children, target: TreeNode<T> | null = null; i < length; i++) {
+        target = this.children[i]!.find(data)
+        if (target) {
+          return target
+        }
+      }
+    }
+
+    return null
+  }
+
+  get leaves(): TreeNode<T>[] {
+    if (!this.children || this.children.length === 0) {
+      // this is a leaf
+      return [this]
+    }
+
+    // if not a leaf, return all children's leaves recursively
+    const leaves: TreeNode<T>[] = []
+    if (this.children) {
+      for (let i = 0, { length } = this.children; i < length; i++) {
+        // eslint-disable-next-line prefer-spread
+        leaves.push.apply(leaves, this.children[i]!.leaves)
+      }
+    }
+    return leaves
+  }
+
+  get root(): TreeNode<T> {
+    if (!this.parent) {
+      return this
+    }
+    return this.parent.root
+  }
+
+  forEach(callback: (treeNode: TreeNode<T>) => void): this {
+    if (typeof callback !== 'function') {
+      throw new TypeError('forEach() callback must be a function')
+    }
+
+    // run this node through function
+    callback(this)
+
+    // do the same for all children
+    if (this.children) {
+      for (let i = 0, { length } = this.children; i < length; i++) {
+        this.children[i]!.forEach(callback)
+      }
+    }
+
+    return this
+  }
+
+  public static build<T = unknown>(path: string, options: TreeNodeOptions = {}): TreeNode<T> | null {
+    try {
+      const exclude = Array.isArray(options.exclude) ? options.exclude : [options.exclude].filter(Boolean)
+      const filteredTree = dirTree(path, { extensions: options.extensions, exclude: [/node_modules/, ...exclude] })
+
+      if (!filteredTree) {
+        return null
+      }
+
+      const treeNode = new TreeNode({ name: filteredTree.name, path: filteredTree.path, type: filteredTree.type || FileManager.getMode(filteredTree.path) })
+
+      const recurse = (node: typeof treeNode, item: DirectoryTree) => {
+        const subNode = node.addChild({ name: item.name, path: item.path, type: item.type || FileManager.getMode(item.path) })
+
+        if (item.children?.length) {
+          item.children?.forEach((child) => {
+            recurse(subNode, child)
+          })
+        }
+      }
+
+      filteredTree.children?.forEach((child) => recurse(treeNode, child))
+
+      return treeNode as TreeNode<T>
+    } catch (e) {
+      throw new Error('Something went wrong with creating index files with the TreehNode class', { cause: e })
+    }
+  }
+}

package/src/utils/URLPath.ts

@@ -0,0 +1,133 @@
+import { camelCase, camelCaseTransformMerge } from 'change-case'
+
+export type URLObject = {
+  url: string
+  params?: Record<string, string>
+}
+
+type ObjectOptions = {
+  type?: 'path' | 'template'
+  replacer?: (pathParam: string) => string
+  stringify?: boolean
+}
+
+export class URLPath {
+  path: string
+
+  constructor(path: string) {
+    this.path = path
+
+    return this
+  }
+
+  /**
+   * Convert Swagger path to URLPath(syntax of Express)
+   * @example /pet/{petId} => /pet/:petId
+   */
+  get URL(): string {
+    return this.toURLPath()
+  }
+  get isURL(): boolean {
+    try {
+      const url = new URL(this.path)
+      if (url?.href) {
+        return true
+      }
+    } catch (error) {
+      return false
+    }
+    return false
+  }
+
+  /**
+   * Convert Swagger path to template literals/ template strings(camelcase)
+   * @example /pet/{petId} => `/pet/${petId}`
+   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
+   * @example /account/userID => `/account/${userId}`
+   */
+  get template(): string {
+    return this.toTemplateString()
+  }
+  get object(): URLObject | string {
+    return this.toObject()
+  }
+  get params(): Record<string, string> | undefined {
+    return this.getParams()
+  }
+
+  toObject({ type = 'path', replacer, stringify }: ObjectOptions = {}): URLObject | string {
+    const object = {
+      url: type === 'path' ? this.toURLPath() : this.toTemplateString(replacer),
+      params: this.getParams(),
+    }
+
+    if (stringify) {
+      if (type === 'template') {
+        return JSON.stringify(object).replaceAll("'", '').replaceAll(`"`, '')
+      }
+
+      if (object.params) {
+        return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", '').replaceAll(`"`, '')} }`
+      }
+
+      return `{ url: '${object.url}' }`
+    }
+
+    return object
+  }
+
+  /**
+   * Convert Swagger path to template literals/ template strings(camelcase)
+   * @example /pet/{petId} => `/pet/${petId}`
+   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
+   * @example /account/userID => `/account/${userId}`
+   */
+  toTemplateString(replacer?: (pathParam: string) => string): string {
+    const regex = /{(\w|-)*}/g
+    const found = this.path.match(regex)
+    let newPath = this.path.replaceAll('{', '${')
+
+    if (found) {
+      newPath = found.reduce((prev, curr) => {
+        const pathParam = replacer
+          ? replacer(camelCase(curr, { delimiter: '', transform: camelCaseTransformMerge }))
+          : camelCase(curr, { delimiter: '', transform: camelCaseTransformMerge })
+        const replacement = `\${${pathParam}}`
+
+        return prev.replace(curr, replacement)
+      }, this.path)
+    }
+
+    return `\`${newPath}\``
+  }
+
+  getParams(replacer?: (pathParam: string) => string): Record<string, string> | undefined {
+    const regex = /{(\w|-)*}/g
+    const found = this.path.match(regex)
+
+    if (!found) {
+      return undefined
+    }
+
+    const params: Record<string, string> = {}
+    found.forEach((item) => {
+      item = item.replaceAll('{', '').replaceAll('}', '')
+
+      const pathParam = replacer
+        ? replacer(camelCase(item, { delimiter: '', transform: camelCaseTransformMerge }))
+        : camelCase(item, { delimiter: '', transform: camelCaseTransformMerge })
+
+      params[pathParam] = pathParam
+    }, this.path)
+
+    return params
+  }
+
+  /**
+   * Convert Swagger path to URLPath(syntax of Express)
+   * @example /pet/{petId} => /pet/:petId
+   */
+  toURLPath(): string {
+    return this.path.replaceAll('{', ':').replaceAll('}', '')
+  }
+}

package/src/utils/cache.ts

@@ -0,0 +1,35 @@
+import type { PluginCache } from '../types.ts'
+
+export interface Cache<TStore extends object = object> {
+  delete(id: keyof TStore): boolean
+  get(id: keyof TStore): TStore[keyof TStore] | null
+  has(id: keyof TStore): boolean
+  set(id: keyof TStore, value: unknown): void
+}
+
+export function createPluginCache<TStore extends PluginCache>(Store: TStore = Object.create(null) as TStore): Cache<TStore> {
+  return {
+    set(id, value): void {
+      Store[id] = [0, value] as TStore[keyof TStore]
+    },
+    get(id): TStore[keyof TStore] | null {
+      const item = Store[id]
+      if (!item) {
+        return null
+      }
+      item[0] = 0
+      return item[1] as TStore[keyof TStore]
+    },
+    has(id): boolean {
+      const item = Store[id]
+      if (!item) {
+        return false
+      }
+      item[0] = 0
+      return true
+    },
+    delete(id: keyof TStore): boolean {
+      return delete Store[id]
+    },
+  }
+}

package/src/utils/clean.ts

@@ -0,0 +1,5 @@
+import { remove } from 'fs-extra'
+
+export async function clean(path: string): Promise<void> {
+  return remove(path)
+}

package/src/utils/executeStrategies.ts

@@ -0,0 +1,83 @@
+/* eslint-disable unused-imports/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+type PromiseFunc<T = unknown, T2 = never> = (state?: T) => T2 extends never ? Promise<T> : Promise<T> | T2
+
+export type ValueOfPromiseFuncArray<TInput extends Array<unknown>> = TInput extends Array<PromiseFunc<infer X, infer Y>> ? X | Y : never
+
+export function noReturn(): void {}
+
+type SeqOutput<TInput extends Array<PromiseFunc<TValue, null>>, TValue> = Array<Awaited<ValueOfPromiseFuncArray<TInput>>>
+
+/**
+ * Chains promises
+ */
+export function hookSeq<TInput extends Array<PromiseFunc<TValue, null>>, TValue, TOutput = SeqOutput<TInput, TValue>>(
+  promises: TInput,
+): TOutput {
+  return promises.filter(Boolean).reduce(
+    (promise, func) => {
+      if (typeof func !== 'function') {
+        throw new Error('HookSeq needs a function that returns a promise `() => Promise<unknown>`')
+      }
+
+      return promise.then((state) => {
+        const calledFunc = func(state as TValue)
+
+        if (calledFunc) {
+          return calledFunc.then(Array.prototype.concat.bind(state))
+        }
+      })
+    },
+    Promise.resolve([] as unknown),
+  ) as TOutput
+}
+
+type HookFirstOutput<TInput extends Array<PromiseFunc<TValue, null>>, TValue = unknown> = ValueOfPromiseFuncArray<TInput>
+
+/**
+ * Chains promises, first non-null result stops and returns
+ */
+export function hookFirst<TInput extends Array<PromiseFunc<TValue, null>>, TValue = unknown, TOutput = HookFirstOutput<TInput, TValue>>(
+  promises: TInput,
+  nullCheck = (state: any) => state !== null,
+): TOutput {
+  let promise: Promise<unknown> = Promise.resolve(null) as Promise<unknown>
+
+  for (const func of promises.filter(Boolean)) {
+    promise = promise.then((state) => {
+      if (nullCheck(state)) {
+        return state
+      }
+
+      const calledFunc = func(state as TValue)
+
+      return calledFunc
+    })
+  }
+
+  return promise as TOutput
+}
+
+type HookParallelOutput<TInput extends Array<PromiseFunc<TValue, null>>, TValue> = Promise<PromiseSettledResult<Awaited<ValueOfPromiseFuncArray<TInput>>>[]>
+
+/**
+ * Run promises in parallel with allSettled
+ */
+export function hookParallel<TInput extends Array<PromiseFunc<TValue, null>>, TValue = unknown, TOutput = HookParallelOutput<TInput, TValue>>(
+  promises: TInput,
+): TOutput {
+  return Promise.allSettled(promises.filter(Boolean).map(promise => promise())) as TOutput
+}
+
+export type Strategy = 'seq' | 'first' | 'parallel'
+
+export type StrategySwitch<TStrategy extends Strategy, TInput extends Array<PromiseFunc<TValue, null>>, TValue> = TStrategy extends 'first'
+  ? HookFirstOutput<TInput, TValue>
+  : TStrategy extends 'seq' ? SeqOutput<TInput, TValue>
+  : TStrategy extends 'parallel' ? HookParallelOutput<TInput, TValue>
+  : never
+
+// tests
+
+type test = ValueOfPromiseFuncArray<Array<PromiseFunc<number, null>>>
+//    ^?

package/src/utils/index.ts

@@ -0,0 +1,19 @@
+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 './transformers/index.ts'
+export * from './TreeNode.ts'
+export * from './uniqueName.ts'
+export * from './URLPath.ts'
+export * from './write.ts'

package/src/utils/logger.ts

@@ -0,0 +1,76 @@
+import pc from 'picocolors'
+
+import type { Ora } from 'ora'
+
+export const LogLevel = {
+  silent: 'silent',
+  info: 'info',
+  debug: 'debug',
+} as const
+
+export type LogLevel = keyof typeof LogLevel
+
+export type Logger = {
+  /**
+   * Optional config name to show in CLI output
+   */
+  name?: string
+  logLevel: LogLevel
+  log: (message: string | null) => void
+  error: (message: string | null) => void
+  info: (message: string | null) => void
+  warn: (message: string | null) => void
+  spinner?: Ora
+  logs: string[]
+}
+
+type Props = {
+  name?: string
+  logLevel: LogLevel
+  spinner?: Ora
+}
+
+export function createLogger({ logLevel, name, spinner }: Props): Logger {
+  const logs: string[] = []
+  const log: Logger['log'] = (message) => {
+    if (message && spinner) {
+      spinner.text = message
+      logs.push(message)
+    }
+  }
+
+  const error: Logger['error'] = (message) => {
+    if (message) {
+      throw new Error(message || 'Something went wrong')
+    }
+  }
+
+  const warn: Logger['warn'] = (message) => {
+    if (message && spinner) {
+      spinner.warn(pc.yellow(message))
+      logs.push(message)
+    }
+  }
+
+  const info: Logger['warn'] = (message) => {
+    if (message && spinner && logLevel !== LogLevel.silent) {
+      spinner.info(message)
+      logs.push(message)
+    }
+  }
+
+  const logger: Logger = {
+    name,
+    logLevel,
+    log,
+    error,
+    warn,
+    info,
+    spinner,
+    logs,
+  }
+
+  return logger
+}
+
+export { default as pc } from 'picocolors'