@kubb/core 1.1.7 → 1.1.9

package/src/utils/TreeNode.ts

@@ -1,5 +1,7 @@
 import dirTree from 'directory-tree'
 
+import { getPathMode } from '../utils/read.ts'
+
 import type { DirectoryTree, DirectoryTreeOptions } from 'directory-tree'
 
 export type TreeNodeOptions = DirectoryTreeOptions
@@ -26,13 +28,17 @@ export class TreeNode<T = unknown> {
     return child
   }
 
-  find(data: T) {
+  find(data?: T): TreeNode<T> | null {
+    if (!data) {
+      return null
+    }
+
     if (data === this.data) {
       return this
     }
 
-    if (this.children) {
-      for (let i = 0, { length } = this.children, target: unknown = null; i < length; i++) {
+    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
@@ -43,7 +49,7 @@ export class TreeNode<T = unknown> {
     return null
   }
 
-  leaves(): TreeNode<T>[] {
+  get leaves(): TreeNode<T>[] {
     if (!this.children || this.children.length === 0) {
       // this is a leaf
       return [this]
@@ -54,17 +60,17 @@ export class TreeNode<T = unknown> {
     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())
+        leaves.push.apply(leaves, this.children[i].leaves)
       }
     }
     return leaves
   }
 
-  root(): TreeNode<T> {
+  get root(): TreeNode<T> {
     if (!this.parent) {
       return this
     }
-    return this.parent.root()
+    return this.parent.root
   }
 
   forEach(callback: (treeNode: TreeNode<T>) => void): this {
@@ -86,26 +92,31 @@ export class TreeNode<T = unknown> {
   }
 
   public static build<T = unknown>(path: string, options: TreeNodeOptions = {}): TreeNode<T> | null {
-    const filteredTree = dirTree(path, { extensions: options?.extensions, exclude: options.exclude })
+    try {
+      const exclude = Array.isArray(options.exclude) ? options.exclude : ([options.exclude].filter(Boolean) as RegExp[])
+      const filteredTree = dirTree(path, { extensions: options.extensions, exclude: [/node_modules/, ...exclude] })
 
-    if (!filteredTree) {
-      return null
-    }
+      if (!filteredTree) {
+        return null
+      }
 
-    const treeNode = new TreeNode({ name: filteredTree.name, path: filteredTree.path, type: filteredTree.type })
+      const treeNode = new TreeNode({ name: filteredTree.name, path: filteredTree.path, type: filteredTree.type || getPathMode(filteredTree.path) })
 
-    const recurse = (node: typeof treeNode, item: DirectoryTree) => {
-      const subNode = node.addChild({ name: item.name, path: item.path, type: item.type })
+      const recurse = (node: typeof treeNode, item: DirectoryTree) => {
+        const subNode = node.addChild({ name: item.name, path: item.path, type: item.type || getPathMode(item.path) })
 
-      if (item.children?.length) {
-        item.children?.forEach((child) => {
-          recurse(subNode, child)
-        })
+        if (item.children?.length) {
+          item.children?.forEach((child) => {
+            recurse(subNode, child)
+          })
+        }
       }
-    }
 
-    filteredTree.children?.forEach((child) => recurse(treeNode, child))
+      filteredTree.children?.forEach((child) => recurse(treeNode, child))
 
-    return treeNode as TreeNode<T>
+      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/cache.ts

@@ -1,6 +1,3 @@
-/* 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
@@ -15,13 +12,17 @@ export function createPluginCache<T extends Record<string, [number, unknown]>>(c
     },
     get(id) {
       const item = cache[id]
-      if (!item) return null
+      if (!item) {
+        return null
+      }
       item[0] = 0
       return item[1] as T[keyof T]
     },
     has(id) {
       const item = cache[id]
-      if (!item) return false
+      if (!item) {
+        return false
+      }
       item[0] = 0
       return true
     },

package/src/utils/getStackTrace.ts

@@ -1,4 +1,5 @@
-// eslint-disable-next-line @typescript-eslint/ban-types, no-undef
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+// eslint-disable-next-line @typescript-eslint/ban-types
 export function getStackTrace(belowFn?: Function): NodeJS.CallSite[] {
   const oldLimit = Error.stackTraceLimit
   Error.stackTraceLimit = Infinity
@@ -15,5 +16,5 @@ export function getStackTrace(belowFn?: Function): NodeJS.CallSite[] {
   Error.prepareStackTrace = v8Handler
   Error.stackTraceLimit = oldLimit
 
-  return v8StackTrace
+  return v8StackTrace as NodeJS.CallSite[]
 }

package/src/utils/getUniqueName.ts

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

package/src/utils/index.ts

@@ -15,3 +15,4 @@ export * from './clean.ts'
 export * from './TreeNode.ts'
 export * from './transformReservedWord.ts'
 export * from './getStackTrace.ts'
+export * from './uniqueId.ts'

package/src/utils/read.ts

@@ -1,26 +1,28 @@
-import { promises as fs } from 'node:fs'
 import pathParser from 'node:path'
+import fs from 'fs-extra'
 
-function slash(path: string) {
-  const isExtendedLengthPath = /^\\\\\?\\/.test(path)
+function slash(path: string, platform: 'windows' | 'mac' | 'linux' = 'linux') {
+  const isWindowsPath = /^\\\\\?\\/.test(path)
 
-  if (isExtendedLengthPath) {
-    return path
+  if (['linux', 'mac'].includes(platform) && !isWindowsPath) {
+    // linux and mac
+    return path.replaceAll(/\\/g, '/').replace('../', '').trimEnd()
   }
 
-  return path.replace(/\\/g, '/')
+  // windows
+  return path.replaceAll(/\\/g, '/').replace('../', '').trimEnd()
 }
 
-export function getRelativePath(rootDir?: string | null, filePath?: string | null) {
+export function getRelativePath(rootDir?: string | null, filePath?: string | null, platform: 'windows' | 'mac' | 'linux' = 'linux') {
   if (!rootDir || !filePath) {
-    throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir} ${filePath}`)
+    throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir || ''} ${filePath || ''}`)
   }
 
   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()
+  const path = slash(relativePath, platform)
 
   if (path.startsWith('../')) {
     return path.replace(pathParser.basename(path), pathParser.basename(path, pathParser.extname(filePath)))
@@ -39,10 +41,5 @@ export function getPathMode(path: string | undefined | null): PathMode {
 }
 
 export async function read(path: string) {
-  try {
-    return fs.readFile(path, { encoding: 'utf8' })
-  } catch (err) {
-    console.error(err)
-    throw err
-  }
+  return fs.readFile(path, { encoding: 'utf8' })
 }

package/src/utils/uniqueId.ts

@@ -0,0 +1,5 @@
+export const uniqueId = (
+  (counter) =>
+  (str = '') =>
+    `${str}${++counter}`
+)(0)

package/src/utils/write.ts

@@ -1,5 +1,4 @@
-/* eslint-disable consistent-return */
-import { promises as fs } from 'node:fs'
+import fs from 'fs-extra'
 import pathParser from 'node:path'
 
 async function safeWriteFileToPath(path: string, data: string) {