@kubb/core 1.0.0-alpha.6 → 1.0.0-alpha.8

package/src/utils/cache.ts

@@ -0,0 +1,32 @@
+/* eslint-disable no-param-reassign */
+/* eslint-disable consistent-return */
+
+export interface Cache<T extends object = object> {
+  delete(id: keyof T): boolean
+  get(id: keyof T): T[keyof T] | null
+  has(id: keyof T): boolean
+  set(id: keyof T, value: unknown): void
+}
+
+export function createPluginCache<T extends Record<string, [number, unknown]>>(cache: T): Cache<T> {
+  return {
+    delete(id: keyof T) {
+      return delete cache[id]
+    },
+    get(id) {
+      const item = cache[id]
+      if (!item) return null
+      item[0] = 0
+      return item[1] as T[keyof T]
+    },
+    has(id) {
+      const item = cache[id]
+      if (!item) return false
+      item[0] = 0
+      return true
+    },
+    set(id, value) {
+      cache[id] = [0, value] as T[keyof T]
+    },
+  }
+}

package/src/utils/getUniqueName.ts

@@ -0,0 +1,10 @@
+/* eslint-disable no-param-reassign */
+export function getUniqueName(originalName: string, data: Record<string, number>) {
+  let used = data[originalName] || 0
+  if (used) {
+    data[originalName] = ++used
+    originalName += used
+  }
+  data[originalName] = 1
+  return originalName
+}

package/src/utils/index.ts

@@ -0,0 +1,11 @@
+export * from './isPromise'
+export * from './write'
+export * from './cache'
+export * from './read'
+export * from './isURL'
+export * from './objectToParameters'
+export * from './nameSorter'
+export * from './jsdoc'
+export * from './getUniqueName'
+export * from './timeout'
+export * from './queue'

package/src/utils/isPromise.ts

@@ -0,0 +1,5 @@
+import type { MaybePromise } from '../types'
+
+export function isPromise<T>(result: MaybePromise<T>): result is Promise<T> {
+  return typeof (result as Promise<unknown>)?.then === 'function'
+}

package/src/utils/isURL.ts

@@ -0,0 +1,11 @@
+export function isURL(data: string) {
+  try {
+    const url = new URL(data)
+    if (url?.href) {
+      return true
+    }
+  } catch (error) {
+    return false
+  }
+  return false
+}

package/src/utils/jsdoc.ts

@@ -0,0 +1,13 @@
+export function createJSDocBlockText({ comments }: { comments: Array<string | undefined> }) {
+  const filteredComments = comments.filter(Boolean)
+
+  if (!filteredComments.length) {
+    return undefined
+  }
+
+  const text = filteredComments.reduce((acc, comment) => {
+    return `${acc}\n* ${comment}`
+  }, '/**')
+
+  return `${text}\n*/`
+}

package/src/utils/nameSorter.ts

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

package/src/utils/objectToParameters.ts

@@ -0,0 +1,19 @@
+type Data = string[][]
+
+type Options = {
+  typed?: boolean
+}
+
+export function objectToParameters(data: Data, options: Options = {}) {
+  return data
+    .reduce((acc, [key, value]) => {
+      if (options.typed) {
+        acc.push(`${key}: ${value}["${key}"], `)
+      } else {
+        acc.push(`${key},`)
+      }
+
+      return acc
+    }, [] as string[])
+    .join('')
+}

package/src/utils/queue.ts

@@ -0,0 +1,46 @@
+/* eslint-disable no-cond-assign */
+
+export type QueueTask<T = unknown> = {
+  (...args: unknown[]): Promise<T>
+}
+
+interface QueueItem {
+  reject: <T>(reason?: T) => void
+  resolve: <T>(value: T | PromiseLike<T>) => void
+  task: QueueTask<unknown>
+}
+
+export class Queue {
+  private readonly queue: QueueItem[] = []
+
+  workerCount = 0
+
+  private maxParallel: number
+
+  constructor(maxParallel: number) {
+    this.maxParallel = maxParallel
+  }
+
+  run<T>(task: QueueTask<T>): Promise<T> {
+    return new Promise<T>((resolve, reject) => {
+      const item: QueueItem = { reject, resolve, task } as QueueItem
+      this.queue.push(item)
+      this.work()
+    })
+  }
+
+  private async work(): Promise<void> {
+    if (this.workerCount >= this.maxParallel) return
+    this.workerCount++
+
+    let entry: QueueItem | undefined
+    while ((entry = this.queue.shift())) {
+      const { reject, resolve, task } = entry
+      task()
+        .then((result) => resolve(result))
+        .catch((err) => reject(err))
+    }
+
+    this.workerCount--
+  }
+}

package/src/utils/read.ts

@@ -0,0 +1,48 @@
+import pathParser from 'path'
+import { promises as fs } from 'fs'
+
+function slash(path: string) {
+  const isExtendedLengthPath = /^\\\\\?\\/.test(path)
+
+  if (isExtendedLengthPath) {
+    return path
+  }
+
+  return path.replace(/\\/g, '/')
+}
+
+export function getRelativePath(rootDir?: string | null, filePath?: string | null) {
+  if (!rootDir || !filePath) {
+    throw new Error('Root and file should be filled in when retrieving the relativePath')
+  }
+
+  const relativePath = pathParser.relative(rootDir, filePath)
+
+  // On Windows, paths are separated with a "\"
+  // However, web browsers use "/" no matter the platform
+  const path = slash(relativePath).replace('../', '').trimEnd()
+
+  if (path.startsWith('../')) {
+    return path.replace(pathParser.basename(path), pathParser.basename(path, pathParser.extname(filePath)))
+  }
+
+  return `./${path.replace(pathParser.basename(path), pathParser.basename(path, pathParser.extname(filePath)))}`
+}
+
+export type PathMode = 'file' | 'directory'
+
+export function getPathMode(path: string | undefined | null): PathMode {
+  if (!path) {
+    return 'directory'
+  }
+  return pathParser.extname(path) ? 'file' : 'directory'
+}
+
+export async function read(path: string) {
+  try {
+    return fs.readFile(path, { encoding: 'utf8' })
+  } catch (err) {
+    console.error(err)
+    throw err
+  }
+}

package/src/utils/timeout.ts

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

package/src/utils/write.ts

@@ -0,0 +1,40 @@
+/* eslint-disable consistent-return */
+import { promises as fs } from 'fs'
+import pathParser from 'path'
+
+import rimraf from 'rimraf'
+
+async function safeWriteFileToPath(path: string, data: string) {
+  // resolve the full path and get just the directory, ignoring the file and extension
+  const passedPath = pathParser.dirname(pathParser.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 })
+  // write the file to the newly created directory
+  return fs.writeFile(pathParser.resolve(path), data, { encoding: 'utf-8' })
+}
+
+export async function write(data: string, path: string) {
+  try {
+    await fs.stat(path)
+    const oldContent = await fs.readFile(path, { encoding: 'utf-8' })
+    if (oldContent?.toString() === data) {
+      return
+    }
+  } catch (_err) {
+    return safeWriteFileToPath(path, data)
+  }
+
+  return safeWriteFileToPath(path, data)
+}
+
+export async function clean(path: string) {
+  return new Promise((resolve, reject) => {
+    rimraf(path, (err) => {
+      if (err) {
+        reject(err)
+      } else {
+        resolve(true)
+      }
+    })
+  })
+}