@kubb/core 4.3.1 → 4.4.1

package/src/fs/types.ts

@@ -1,132 +0,0 @@
-type BasePath<T extends string = string> = `${T}/`
-
-export type Import = {
-  /**
-   * Import name to be used
-   * @example ["useState"]
-   * @example "React"
-   */
-  name:
-    | string
-    | Array<
-        | string
-        | {
-            propertyName: string
-            name?: string
-          }
-      >
-  /**
-   * Path for the import
-   * @example '@kubb/core'
-   */
-  path: string
-  /**
-   * Add `type` prefix to the import, this will result in: `import type { Type } from './path'`.
-   */
-  isTypeOnly?: boolean
-
-  isNameSpace?: boolean
-  /**
-   * When root is set it will get the path with relative getRelativePath(root, path).
-   */
-  root?: string
-}
-
-export type Source = {
-  name?: string
-  value?: string
-  isTypeOnly?: boolean
-  /**
-   * Has const or type 'export'
-   * @default false
-   */
-  isExportable?: boolean
-  /**
-   * When set, barrel generation will add this
-   * @default false
-   */
-  isIndexable?: boolean
-}
-
-export type Export = {
-  /**
-   * Export name to be used.
-   * @example ["useState"]
-   * @example "React"
-   */
-  name?: string | Array<string>
-  /**
-   * Path for the import.
-   * @example '@kubb/core'
-   */
-  path: string
-  /**
-   * Add `type` prefix to the export, this will result in: `export type { Type } from './path'`.
-   */
-  isTypeOnly?: boolean
-  /**
-   * Make it possible to override the name, this will result in: `export * as aliasName from './path'`.
-   */
-  asAlias?: boolean
-}
-
-export type Extname = '.ts' | '.js' | '.tsx' | '.json' | `.${string}`
-
-export type Mode = 'single' | 'split'
-
-/**
- * Name to be used to dynamicly create the baseName(based on input.path)
- * Based on UNIX basename
- * @link https://nodejs.org/api/path.html#pathbasenamepath-suffix
- */
-export type BaseName = `${string}.${string}`
-
-/**
- * Path will be full qualified path to a specified file
- */
-export type Path = string
-
-export type AdvancedPath<T extends BaseName = BaseName> = `${BasePath}${T}`
-
-export type OptionalPath = Path | undefined | null
-
-export type File<TMeta extends object = object> = {
-  /**
-   * Name to be used to create the path
-   * Based on UNIX basename, `${name}.extname`
-   * @link https://nodejs.org/api/path.html#pathbasenamepath-suffix
-   */
-  baseName: BaseName
-  /**
-   * Path will be full qualified path to a specified file
-   */
-  path: AdvancedPath<BaseName> | Path
-  sources: Array<Source>
-  imports?: Array<Import>
-  exports?: Array<Export>
-  /**
-   * Use extra meta, this is getting used to generate the barrel/index files.
-   */
-  meta?: TMeta
-  banner?: string
-  footer?: string
-}
-
-export type ResolvedImport = Import
-
-export type ResolvedExport = Export
-
-export type ResolvedFile<TMeta extends object = object> = File<TMeta> & {
-  /**
-   * @default object-hash
-   */
-  id: string
-  /**
-   * Contains the first part of the baseName, generated based on baseName
-   * @link  https://nodejs.org/api/path.html#pathformatpathobject
-   */
-  name: string
-  extname: Extname
-  imports: Array<ResolvedImport>
-  exports: Array<ResolvedExport>
-}

package/src/fs/unlink.ts

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

package/src/mocks/index.ts

@@ -1,82 +0,0 @@
-import path from 'node:path'
-import { createFile, FileProcessor } from '@kubb/fabric-core'
-import { format } from '../../mocks/format.ts'
-import type { File, ResolvedFile } from '../fs/types.ts'
-import type { Logger } from '../logger'
-import type { PluginManager } from '../PluginManager.ts'
-import { camelCase, pascalCase } from '../transformers/casing.ts'
-import type { Plugin } from '../types.ts'
-import { typescriptParser } from '@kubb/fabric-core/parsers/typescript'
-
-export const mockedLogger = {
-  emit(_type, _message) {},
-  on(_type, _message) {},
-  consola: {},
-} as Logger
-
-export const createMockedPluginManager = (name?: string) =>
-  ({
-    resolveName: (result) => {
-      if (result.type === 'file') {
-        return camelCase(name || result.name)
-      }
-
-      if (result.type === 'type') {
-        return pascalCase(result.name)
-      }
-
-      if (result.type === 'function') {
-        return camelCase(result.name)
-      }
-
-      return camelCase(result.name)
-    },
-    config: {
-      output: {
-        path: './path',
-      },
-    },
-    resolvePath: ({ baseName }) => baseName,
-    logger: {
-      emit(message) {
-        console.log(message)
-      },
-      on(_eventName, _args) {},
-      logLevel: 3,
-    },
-    getPluginByKey: (_pluginKey: Plugin['key']) => {
-      return undefined
-    },
-    getFile: ({ name, extname, pluginKey }) => {
-      const baseName = `${name}${extname}`
-
-      return {
-        path: baseName,
-        baseName,
-        meta: {
-          pluginKey,
-        },
-      }
-    },
-  }) as PluginManager
-
-export const mockedPluginManager = createMockedPluginManager('')
-
-export async function matchFiles(files: Array<ResolvedFile | File> | undefined, pre?: string) {
-  if (!files) {
-    return undefined
-  }
-
-  const fileProcessor = new FileProcessor()
-  const parsers = new Set<any>([typescriptParser])
-
-  for await (const file of files) {
-    const source = await fileProcessor.parse(createFile(file), { parsers })
-    let code = source
-    if (!file.baseName.endsWith('.json')) {
-      code = await format(source)
-    }
-
-    await expect(code).toMatchFileSnapshot(path.join(...['__snapshots__', pre, file.path].filter(Boolean)))
-  }
-}