@kubb/core 2.0.0-alpha.3 → 2.0.0-alpha.4

package/src/utils/URLPath.ts

@@ -0,0 +1,128 @@
+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') {
+        throw new Error('Type should be `template` when using stringiyf')
+      }
+      return JSON.stringify(object).replaceAll("'", '').replaceAll(`"`, '')
+    }
+
+    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,71 @@
+/* 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
+}
+
+export type Strategy = 'seq' | 'first'
+
+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>
+  : 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) {
+      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'

package/src/utils/promise.ts

@@ -0,0 +1,13 @@
+type PossiblePromise<T> = Promise<T> | T
+
+export function isPromise<T>(result: PossiblePromise<T>): result is Promise<T> {
+  return !!result && typeof (result as Promise<unknown>)?.then === 'function'
+}
+
+export function isPromiseFulfilledResult<T = unknown>(result: PromiseSettledResult<unknown>): result is PromiseFulfilledResult<T> {
+  return result.status === 'fulfilled'
+}
+
+export function isPromiseRejectedResult<T>(result: PromiseSettledResult<unknown>): result is Omit<PromiseRejectedResult, 'reason'> & { reason: T } {
+  return result.status === 'rejected'
+}

package/src/utils/randomColour.ts

@@ -0,0 +1,39 @@
+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/read.ts

@@ -0,0 +1,68 @@
+import { basename, extname, relative } from 'node:path'
+
+import fs from 'fs-extra'
+import { switcher } from 'js-runtime'
+
+function slash(path: string, platform: 'windows' | 'mac' | 'linux' = 'linux') {
+  const isWindowsPath = /^\\\\\?\\/.test(path)
+
+  if (['linux', 'mac'].includes(platform) && !isWindowsPath) {
+    // linux and mac
+    return path.replaceAll(/\\/g, '/').replace('../', '').trimEnd()
+  }
+
+  // windows
+  return path.replaceAll(/\\/g, '/').replace('../', '').trimEnd()
+}
+
+export function getRelativePath(rootDir?: string | null, filePath?: string | null, platform: 'windows' | 'mac' | 'linux' = 'linux'): string {
+  if (!rootDir || !filePath) {
+    throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir || ''} ${filePath || ''}`)
+  }
+
+  const relativePath = relative(rootDir, filePath)
+
+  // On Windows, paths are separated with a "\"
+  // However, web browsers use "/" no matter the platform
+  const slashedPath = slash(relativePath, platform)
+
+  if (slashedPath.startsWith('../')) {
+    return slashedPath.replace(basename(slashedPath), basename(slashedPath, extname(filePath)))
+  }
+
+  return `./${slashedPath.replace(basename(slashedPath), basename(slashedPath, extname(filePath)))}`
+}
+
+const reader = switcher(
+  {
+    node: async (path: string) => {
+      return fs.readFile(path, { encoding: 'utf8' })
+    },
+    bun: async (path: string) => {
+      const file = Bun.file(path)
+
+      return file.text()
+    },
+  },
+  'node',
+)
+
+const syncReader = switcher(
+  {
+    node: (path: string) => {
+      return fs.readFileSync(path, { encoding: 'utf8' })
+    },
+    bun: () => {
+      throw new Error('Bun cannot read sync')
+    },
+  },
+  'node',
+)
+
+export async function read(path: string): Promise<string> {
+  return reader(path)
+}
+
+export function readSync(path: string): string {
+  return syncReader(path)
+}

package/src/utils/renderTemplate.ts

@@ -0,0 +1,31 @@
+export function renderTemplate<TData extends Record<string, unknown> = Record<string, unknown>>(template: string, data: TData | undefined = undefined): string {
+  if (!data || !Object.keys(data).length) {
+    return template.replace(/{{(.*?)}}/g, '')
+  }
+
+  const matches = template.match(/{{(.*?)}}/g)
+
+  return (
+    matches?.reduce((prev, curr) => {
+      const index = curr.split(/{{|}}/).filter(Boolean)[0]?.trim()
+      if (index === undefined) {
+        return prev
+      }
+      const value = data[index]
+
+      if (value === undefined) {
+        return prev
+      }
+
+      return prev
+        .replace(curr, () => {
+          if (typeof value === 'boolean') {
+            return `${value.toString()}` || 'false'
+          }
+
+          return (value as string) || ''
+        })
+        .trim()
+    }, template) || ''
+  )
+}

package/src/utils/throttle.ts

@@ -0,0 +1,30 @@
+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)
+    },
+  ]
+}

package/src/utils/timeout.ts

@@ -0,0 +1,7 @@
+export async function timeout(ms: number): Promise<unknown> {
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      resolve(true)
+    }, ms)
+  })
+}

package/src/utils/transformers/combineCodes.ts

@@ -0,0 +1,3 @@
+export function combineCodes(codes: string[]): string {
+  return codes.join('\n')
+}

package/src/utils/transformers/createJSDocBlockText.ts

@@ -0,0 +1,15 @@
+export function createJSDocBlockText({ comments, newLine }: { comments: Array<string>; newLine?: boolean }): string {
+  const filteredComments = comments.filter(Boolean)
+
+  if (!filteredComments.length) {
+    return ''
+  }
+
+  const source = `/**\n * ${filteredComments.join('\n * ')}\n */`
+
+  if (newLine) {
+    return `${source}\n`
+  }
+
+  return source
+}

package/src/utils/transformers/escape.ts

@@ -0,0 +1,31 @@
+export function escape(text?: string): string {
+  return text ? text.replaceAll('`', '\\`') : ''
+}
+
+/**
+ * Escape all characters not included in SingleStringCharacters and DoubleStringCharacters on
+ * @link http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
+ * @link https://github.com/joliss/js-string-escape/blob/master/index.js
+ */
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+export function jsStringEscape(input: any): string {
+  return `${input}`.replace(/["'\\\n\r\u2028\u2029]/g, (character) => {
+    switch (character) {
+      case '"':
+      case "'":
+      case '\\':
+        return '\\' + character
+      // Four possible LineTerminator characters need to be escaped:
+      case '\n':
+        return '\\n'
+      case '\r':
+        return '\\r'
+      case '\u2028':
+        return '\\u2028'
+      case '\u2029':
+        return '\\u2029'
+      default:
+        return ''
+    }
+  })
+}

package/src/utils/transformers/indent.ts

@@ -0,0 +1,3 @@
+export function createIndent(size: number): string {
+  return Array.from({ length: size + 1 }).join(' ')
+}

package/src/utils/transformers/index.ts

@@ -0,0 +1,20 @@
+import { combineCodes } from './combineCodes.ts'
+import { createJSDocBlockText } from './createJSDocBlockText.ts'
+import { escape, jsStringEscape } from './escape.ts'
+import { createIndent } from './indent.ts'
+import { nameSorter } from './nameSorter.ts'
+import { searchAndReplace } from './searchAndReplace.ts'
+import { transformReservedWord } from './transformReservedWord.ts'
+
+export const transformers = {
+  combineCodes,
+  escape,
+  jsStringEscape,
+  createIndent,
+  transformReservedWord,
+  nameSorter,
+  searchAndReplace,
+  JSDoc: {
+    createJSDocBlockText,
+  },
+} as const

package/src/utils/transformers/nameSorter.ts

@@ -0,0 +1,9 @@
+export function nameSorter<T extends { name: string }>(a: T, b: T): 0 | 1 | -1 {
+  if (a.name < b.name) {
+    return -1
+  }
+  if (a.name > b.name) {
+    return 1
+  }
+  return 0
+}

package/src/utils/transformers/searchAndReplace.ts

@@ -0,0 +1,25 @@
+type Options = {
+  text: string
+  replaceBy: string
+  prefix?: string
+  key: string
+  searchValues?: (prefix: string, key: string) => Array<RegExp | string>
+}
+
+export function searchAndReplace(options: Options): string {
+  const { text, replaceBy, prefix = '', key } = options
+
+  const searchValues = options.searchValues?.(prefix, key) || [
+    `${prefix}["${key}"]`,
+    `${prefix}['${key}']`,
+    `${prefix}[\`${key}\`]`,
+    `${prefix}"${key}"`,
+    `${prefix}'${key}'`,
+    `${prefix}\`${key}\``,
+    new RegExp(`${prefix}${key}`, 'g'),
+  ]
+
+  return searchValues.reduce((prev, searchValue) => {
+    return prev.toString().replaceAll(searchValue, replaceBy)
+  }, text) as string
+}