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

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,22 @@
+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'
+import { trim } from './trim.ts'
+
+export const transformers = {
+  combineCodes,
+  escape,
+  jsStringEscape,
+  createIndent,
+  transformReservedWord,
+  nameSorter,
+  searchAndReplace,
+  trim,
+  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
+}

package/src/utils/transformers/transformReservedWord.ts

@@ -0,0 +1,97 @@
+/**
+ * @link https://github.com/jonschlinkert/reserved/blob/master/index.js
+ */
+const reservedWords = [
+  'abstract',
+  'arguments',
+  'boolean',
+  'break',
+  'byte',
+  'case',
+  'catch',
+  'char',
+  'class',
+  'const',
+  'continue',
+  'debugger',
+  'default',
+  'delete',
+  'do',
+  'double',
+  'else',
+  'enum',
+  'eval',
+  'export',
+  'extends',
+  'false',
+  'final',
+  'finally',
+  'float',
+  'for',
+  'function',
+  'goto',
+  'if',
+  'implements',
+  'import',
+  'in',
+  'instanceof',
+  'int',
+  'interface',
+  'let',
+  'long',
+  'native',
+  'new',
+  'null',
+  'package',
+  'private',
+  'protected',
+  'public',
+  'return',
+  'short',
+  'static',
+  'super',
+  'switch',
+  'synchronized',
+  'this',
+  'throw',
+  'throws',
+  'transient',
+  'true',
+  'try',
+  'typeof',
+  'var',
+  'void',
+  'volatile',
+  'while',
+  'with',
+  'yield',
+
+  'Array',
+  'Date',
+  'eval',
+  'function',
+  'hasOwnProperty',
+  'Infinity',
+  'isFinite',
+  'isNaN',
+  'isPrototypeOf',
+  'length',
+  'Math',
+  'name',
+  'NaN',
+  'Number',
+  'Object',
+  'prototype',
+  'String',
+  'toString',
+  'undefined',
+  'valueOf',
+]
+
+export function transformReservedWord(word: string): string {
+  if ((word && reservedWords.includes(word)) || word?.match(/^\d/)) {
+    return `_${word}`
+  }
+
+  return word
+}

package/src/utils/transformers/trim.ts

@@ -0,0 +1,3 @@
+export function trim(text: string): string {
+  return text.replaceAll(/\n/g, '').trim()
+}

package/src/utils/uniqueName.ts

@@ -0,0 +1,20 @@
+export function getUniqueName(originalName: string, data: Record<string, number>): string {
+  let used = data[originalName] || 0
+  if (used) {
+    data[originalName] = ++used
+    originalName += used
+  }
+  data[originalName] = 1
+  return originalName
+}
+
+export function setUniqueName(originalName: string, data: Record<string, number>): string {
+  let used = data[originalName] || 0
+  if (used) {
+    data[originalName] = ++used
+
+    return originalName
+  }
+  data[originalName] = 1
+  return originalName
+}

package/src/utils/write.ts

@@ -0,0 +1,63 @@
+import { dirname, resolve } from 'node:path'
+
+import fs from 'fs-extra'
+import { switcher } from 'js-runtime'
+
+async function saveCreateDirectory(path: string): Promise<void> {
+  // resolve the full path and get just the directory, ignoring the file and extension
+  const passedPath = dirname(resolve(path))
+  // make the directory, recursively. Theoretically, if every directory in the path exists, this won't do anything.
+  await fs.mkdir(passedPath, { recursive: true })
+}
+
+const writer = switcher(
+  {
+    node: async (path: string, data: string) => {
+      try {
+        await fs.stat(resolve(path))
+        const oldContent = await fs.readFile(resolve(path), { encoding: 'utf-8' })
+        if (oldContent?.toString() === data?.toString()) {
+          return
+        }
+      } catch (_err) {
+        /* empty */
+      }
+
+      await saveCreateDirectory(path)
+      await fs.writeFile(resolve(path), data, { encoding: 'utf-8' })
+
+      const savedData = await fs.readFile(resolve(path), { encoding: 'utf-8' })
+
+      if (savedData?.toString() !== data?.toString()) {
+        throw new Error(`Sanity check failed for ${path}\n\nData[${data.length}]:\n${data}\n\nSaved[${savedData.length}]:\n${savedData}\n`)
+      }
+
+      return savedData
+    },
+    bun: async (path: string, data: string) => {
+      try {
+        await saveCreateDirectory(path)
+        await Bun.write(resolve(path), data)
+
+        const file = Bun.file(resolve(path))
+        const savedData = await file.text()
+
+        if (savedData?.toString() !== data?.toString()) {
+          throw new Error(`Sanity check failed for ${path}\n\nData[${data.length}]:\n${data}\n\nSaved[${savedData.length}]:\n${savedData}\n`)
+        }
+
+        return savedData
+      } catch (e) {
+        console.log(e, resolve(path))
+      }
+    },
+  },
+  'node',
+)
+
+export async function write(data: string, path: string): Promise<string | undefined> {
+  if (data.trim() === '') {
+    return undefined
+  }
+  return writer(path, data.trim())
+}