@kubb/fabric-core 0.1.5 → 0.1.7

package/src/App.ts

@@ -12,6 +12,13 @@ declare global {
 
 export type Component = any
 
+export type AppOptions = {
+  /**
+   * @default 'sequential'
+   */
+  mode?: AppMode
+}
+
 export type AppEvents = {
   /**
    * Called in the beginning of the app lifecycle.
@@ -49,7 +56,7 @@ export type AppEvents = {
       processed: number
       total: number
       percentage: number
-      source: string
+      source?: string
       file: KubbFile.ResolvedFile
     },
   ]
@@ -60,7 +67,7 @@ export type AppEvents = {
   'process:end': [{ files: KubbFile.ResolvedFile[] }]
 }
 
-export type AppContext<TOptions = unknown> = {
+export type AppContext<TOptions extends AppOptions> = {
   options?: TOptions
   events: AsyncEventEmitter<AppEvents>
   fileManager: FileManager
@@ -68,36 +75,32 @@ export type AppContext<TOptions = unknown> = {
   installedParsers: Set<Parser>
 }
 
-export type Install<TOptions = any[] | object | undefined> = TOptions extends any[]
-  ? (app: App, ...options: TOptions) => void
-  : TOptions extends object
-    ? (app: App, options?: TOptions) => void
-    : (app: App) => void
+export type AppMode = 'sequential' | 'parallel'
+
+type AllOptional<T> = {} extends T ? true : false
+
+export type Install<TOptions = unknown> = TOptions extends any[]
+  ? (app: App, ...options: TOptions) => void | Promise<void>
+  : AllOptional<TOptions> extends true
+    ? (app: App, options: TOptions | undefined) => void | Promise<void>
+    : (app: App, options: TOptions) => void | Promise<void>
 
-export type Inject<TOptions = any[] | object | undefined, TAppExtension extends Record<string, any> = {}> = TOptions extends any[]
+export type Inject<TOptions = unknown, TAppExtension extends Record<string, any> = {}> = TOptions extends any[]
   ? (app: App, ...options: TOptions) => Partial<TAppExtension>
-  : TOptions extends object
-    ? (app: App, options?: TOptions) => Partial<TAppExtension>
-    : (app: App) => Partial<TAppExtension>
+  : AllOptional<TOptions> extends true
+    ? (app: App, options: TOptions | undefined) => Partial<TAppExtension>
+    : (app: App, options: TOptions) => Partial<TAppExtension>
 
-export interface App<TOptions = unknown> extends Kubb.App {
+export interface App<TOptions extends AppOptions = AppOptions> extends Kubb.App {
   context: AppContext<TOptions>
   files: Array<KubbFile.ResolvedFile>
-  // sync
-  use<TOptions extends any[] | object = any, TMeta extends object = object, TAppExtension extends Record<string, any> = {}>(
-    pluginOrParser: Plugin<TOptions, TAppExtension> | Parser<TOptions, TMeta>,
-    ...options: TOptions extends any[] ? NoInfer<TOptions> : [NoInfer<TOptions>]
-  ): this & TAppExtension
-  use<TOptions extends any[] | object = any, TMeta extends object = object, TAppExtension extends Record<string, any> = {}>(
-    pluginOrParser: Plugin<TOptions, TAppExtension> | Parser<TOptions, TMeta>,
-  ): this & TAppExtension
-  // async
-  use<TOptions extends any[] | object = any, TMeta extends object = object, TAppExtension extends Record<string, any> = {}>(
-    pluginOrParser: Plugin<TOptions, TAppExtension> | Parser<TOptions, TMeta>,
-    ...options: TOptions extends any[] ? NoInfer<TOptions> : [NoInfer<TOptions>]
-  ): Promise<this & TAppExtension>
-  use<TOptions extends any[] | object = any, TMeta extends object = object, TAppExtension extends Record<string, any> = {}>(
-    pluginOrParser: Plugin<TOptions, TAppExtension> | Parser<TOptions, TMeta>,
-  ): Promise<this & TAppExtension>
+  use<TPluginOptions = unknown, TMeta extends object = object, TAppExtension extends Record<string, any> = {}>(
+    pluginOrParser: Plugin<TPluginOptions, TAppExtension> | Parser<TPluginOptions, TMeta>,
+    ...options: TPluginOptions extends any[]
+      ? NoInfer<TPluginOptions>
+      : AllOptional<TPluginOptions> extends true
+        ? [NoInfer<TPluginOptions>?] // Optional when all props are optional
+        : [NoInfer<TPluginOptions>] // Required otherwise
+  ): (this & TAppExtension) | Promise<this & TAppExtension>
   addFile(...files: Array<KubbFile.File>): Promise<void>
 }

package/src/FileManager.ts

@@ -22,10 +22,13 @@ type Options = {
 
 export class FileManager {
   #cache = new Cache<KubbFile.ResolvedFile>()
+  events: AsyncEventEmitter<AppEvents>
   processor: FileProcessor
 
   constructor({ events = new AsyncEventEmitter<AppEvents>() }: Options = {}) {
     this.processor = new FileProcessor({ events })
+
+    this.events = events
     return this
   }
 
@@ -86,6 +89,10 @@ export class FileManager {
   }
 
   async write(options: ProcessFilesProps): Promise<KubbFile.ResolvedFile[]> {
-    return this.processor.run(this.files, options)
+    const resolvedFiles = await this.processor.run(this.files, options)
+
+    this.clear()
+
+    return resolvedFiles
   }
 }

package/src/FileProcessor.ts

@@ -4,12 +4,16 @@ import pLimit from 'p-limit'
 import type { Parser } from './parsers/types.ts'
 import { defaultParser } from './parsers/defaultParser.ts'
 import { AsyncEventEmitter } from './utils/AsyncEventEmitter.ts'
-import type { AppEvents } from './App.ts'
+import type { AppEvents, AppMode } from './App.ts'
 
 export type ProcessFilesProps = {
   parsers?: Set<Parser>
   extension?: Record<KubbFile.Extname, KubbFile.Extname | ''>
   dryRun?: boolean
+  /**
+   * @default 'sequential'
+   */
+  mode?: AppMode
 }
 
 type GetParseOptions = {
@@ -31,9 +35,15 @@ export class FileProcessor {
     return this
   }
 
-  async parse(file: KubbFile.ResolvedFile, { parsers = new Set(), extension }: GetParseOptions = {}): Promise<string> {
+  async parse(file: KubbFile.ResolvedFile, { parsers, extension }: GetParseOptions = {}): Promise<string> {
     const parseExtName = extension?.[file.extname] || undefined
 
+    if (!parsers) {
+      console.warn('No parsers provided, using default parser. If you want to use a specific parser, please provide it in the options.')
+
+      return defaultParser.parse(file, { extname: parseExtName })
+    }
+
     if (!file.extname) {
       return defaultParser.parse(file, { extname: parseExtName })
     }
@@ -53,31 +63,51 @@ export class FileProcessor {
     return parser.parse(file, { extname: parseExtName })
   }
 
-  async run(files: Array<KubbFile.ResolvedFile>, { parsers, dryRun, extension }: ProcessFilesProps = {}): Promise<KubbFile.ResolvedFile[]> {
+  async run(
+    files: Array<KubbFile.ResolvedFile>,
+    { parsers, mode = 'sequential', dryRun, extension }: ProcessFilesProps = {},
+  ): Promise<KubbFile.ResolvedFile[]> {
     await this.events.emit('process:start', { files })
 
     let processed = 0
     const total = files.length
 
-    const promises = files.map((resolvedFile, index) =>
-      this.#limit(async () => {
-        await this.events.emit('file:start', { file: resolvedFile, index, total })
+    const processOne = async (resolvedFile: KubbFile.ResolvedFile, index: number) => {
+      const percentage = (processed / total) * 100
 
-        if (!dryRun) {
-          const source = await this.parse(resolvedFile, { extension, parsers })
-          const nextProcessed = processed + 1
-          const percentage = (nextProcessed / total) * 100
-          processed = nextProcessed
-          await this.events.emit('process:progress', { file: resolvedFile, source, processed, percentage, total })
-        }
+      await this.events.emit('file:start', { file: resolvedFile, index, total })
+
+      const source = dryRun ? undefined : await this.parse(resolvedFile, { extension, parsers })
+
+      await this.events.emit('process:progress', {
+        file: resolvedFile,
+        source,
+        processed,
+        percentage,
+        total,
+      })
 
-        await this.events.emit('file:end', { file: resolvedFile, index, total })
+      processed++
 
-        processed++
-      }),
-    )
+      await this.events.emit('file:end', { file: resolvedFile, index, total })
+    }
+
+    if (mode === 'sequential') {
+      async function* asyncFiles() {
+        for (let index = 0; index < files.length; index++) {
+          yield [files[index], index] as const
+        }
+      }
 
-    await Promise.all(promises)
+      for await (const [file, index] of asyncFiles()) {
+        if (file) {
+          await processOne(file, index)
+        }
+      }
+    } else {
+      const promises = files.map((resolvedFile, index) => this.#limit(() => processOne(resolvedFile, index)))
+      await Promise.all(promises)
+    }
 
     await this.events.emit('process:end', { files })
 

package/src/defineApp.ts

@@ -3,19 +3,19 @@ import { isFunction } from 'remeda'
 import type { Plugin } from './plugins/types.ts'
 import type { Parser } from './parsers/types.ts'
 import { AsyncEventEmitter } from './utils/AsyncEventEmitter.ts'
-import type { AppContext, Component, AppEvents } from './App.ts'
+import type { AppContext, AppEvents, AppOptions } from './App.ts'
 
 import type { App } from './index.ts'
 
 type RootRenderFunction<TApp extends App> = (app: TApp) => void | Promise<void>
 
-export type DefineApp<TOptions> = (rootComponent?: Component, options?: TOptions) => App
+export type DefineApp<TOptions> = (options?: TOptions) => App
 
-export function defineApp<TOptions = unknown>(instance?: RootRenderFunction<App<TOptions>>): DefineApp<TOptions> {
+export function defineApp<TOptions extends AppOptions>(instance?: RootRenderFunction<App<TOptions>>): DefineApp<TOptions> {
   function createApp(options?: TOptions): App {
     const events = new AsyncEventEmitter<AppEvents>()
-    const installedPlugins = new Set<Plugin>()
-    const installedParsers = new Set<Parser>()
+    const installedPlugins = new Set<Plugin<any>>()
+    const installedParsers = new Set<Parser<any>>()
     const fileManager = new FileManager({ events })
     const context = {
       events,
@@ -68,15 +68,10 @@ export function defineApp<TOptions = unknown>(instance?: RootRenderFunction<App<
       },
     } as App<TOptions>
 
-    // start
-    events.emit('start')
     if (instance) {
       instance(app)
     }
 
-    // end
-    events.emit('end')
-
     return app
   }
 

package/src/parsers/createParser.ts

@@ -1,6 +1,6 @@
 import type { Parser, UserParser } from './types.ts'
 
-export function createParser<TOptions = any[], TMeta extends object = any>(parser: UserParser<TOptions, TMeta>): Parser<TOptions, TMeta> {
+export function createParser<TOptions = unknown, TMeta extends object = any>(parser: UserParser<TOptions, TMeta>): Parser<TOptions, TMeta> {
   return {
     type: 'parser',
     ...parser,

package/src/parsers/types.ts

@@ -5,7 +5,7 @@ type PrintOptions = {
   extname?: KubbFile.Extname
 }
 
-export type Parser<TOptions = any[], TMeta extends object = any> = {
+export type Parser<TOptions = unknown, TMeta extends object = any> = {
   name: string
   type: 'parser'
   /**
@@ -19,4 +19,4 @@ export type Parser<TOptions = any[], TMeta extends object = any> = {
   parse(file: KubbFile.ResolvedFile<TMeta>, options: PrintOptions): Promise<string>
 }
 
-export type UserParser<TOptions = any[], TMeta extends object = any> = Omit<Parser<TOptions, TMeta>, 'type'>
+export type UserParser<TOptions = unknown, TMeta extends object = any> = Omit<Parser<TOptions, TMeta>, 'type'>

package/src/plugins/barrelPlugin.ts

@@ -0,0 +1,207 @@
+/** biome-ignore-all lint/suspicious/useIterableCallbackReturn: not needed */
+
+import { createPlugin } from './createPlugin.ts'
+import type * as KubbFile from '../KubbFile.ts'
+import { TreeNode } from '../utils/TreeNode.ts'
+import path, { resolve } from 'node:path'
+import { getRelativePath } from '../utils/getRelativePath.ts'
+import { createFile } from '../createFile.ts'
+
+type Mode = 'all' | 'named' | 'propagate' | false
+
+type Options = {
+  root: string
+  mode: Mode
+  dryRun?: boolean
+}
+
+type WriteEntryOptions = {
+  root: string
+  mode: Mode
+}
+
+type ExtendOptions = {
+  writeEntry(options: WriteEntryOptions): Promise<void>
+}
+
+// biome-ignore lint/suspicious/noTsIgnore: production ready
+// @ts-ignore
+declare module '@kubb/fabric-core' {
+  interface App {
+    writeEntry(options: WriteEntryOptions): Promise<void>
+  }
+}
+
+declare global {
+  namespace Kubb {
+    interface App {
+      writeEntry(options: WriteEntryOptions): Promise<void>
+    }
+  }
+}
+
+type GetBarrelFilesOptions = {
+  files: KubbFile.File[]
+  root: string
+  mode: Mode
+}
+
+export function getBarrelFiles({ files, root, mode }: GetBarrelFilesOptions): Array<KubbFile.File> {
+  // Do not generate when propagating or disabled
+  if (mode === 'propagate' || mode === false) {
+    return []
+  }
+
+  const cachedFiles = new Map<KubbFile.Path, KubbFile.File>()
+  const dedupe = new Map<KubbFile.Path, Set<string>>()
+
+  const tree = TreeNode.fromFiles(files, root)
+  tree?.forEach((node) => {
+    // Only create a barrel for directory-like nodes that have a parent with a path
+    if (!node?.children || !node.parent?.data.path) {
+      return
+    }
+
+    const parentPath = node.parent.data.path as KubbFile.Path
+    const barrelPath = path.join(parentPath, 'index.ts') as KubbFile.Path
+
+    let barrelFile = cachedFiles.get(barrelPath)
+    if (!barrelFile) {
+      barrelFile = createFile({
+        path: barrelPath,
+        baseName: 'index.ts',
+        exports: [],
+        sources: [],
+      })
+      cachedFiles.set(barrelPath, barrelFile)
+      dedupe.set(barrelPath, new Set<string>())
+    }
+
+    const seen = dedupe.get(barrelPath)!
+
+    // Collect all leaves under the current directory node
+    node.leaves.forEach((leaf) => {
+      const file = leaf.data.file
+      if (!file) {
+        return
+      }
+
+      const sources = file.sources || []
+      sources.forEach((source) => {
+        if (!file.path || !source.isIndexable || !source.name) {
+          return
+        }
+
+        const key = `${source.name}|${source.isTypeOnly ? '1' : '0'}`
+        if (seen.has(key)) {
+          return
+        }
+        seen.add(key)
+
+        // Always compute relative path from the parent directory to the file path
+        barrelFile!.exports!.push({
+          name: [source.name],
+          path: getRelativePath(parentPath, file.path),
+          isTypeOnly: source.isTypeOnly,
+        })
+
+        barrelFile!.sources.push({
+          name: source.name,
+          isTypeOnly: source.isTypeOnly,
+          value: '', // TODO use parser to generate import
+          isExportable: mode === 'all' || mode === 'named',
+          isIndexable: mode === 'all' || mode === 'named',
+        })
+      })
+    })
+  })
+
+  const result = [...cachedFiles.values()]
+
+  if (mode === 'all') {
+    return result.map((file) => ({
+      ...file,
+      exports: file.exports?.map((e) => ({ ...e, name: undefined })),
+    }))
+  }
+
+  return result
+}
+
+export const barrelPlugin = createPlugin<Options, ExtendOptions>({
+  name: 'barrel',
+  install(app, options) {
+    if (!options) {
+      throw new Error('Barrel plugin requires options.root and options.mode')
+    }
+
+    if (!options.mode) {
+      return undefined
+    }
+
+    app.context.events.onOnce('process:end', async ({ files }) => {
+      const root = options.root
+      const barrelFiles = getBarrelFiles({ files, root, mode: options.mode })
+
+      await app.context.fileManager.add(...barrelFiles)
+
+      await app.context.fileManager.write({
+        mode: app.context.options?.mode,
+        dryRun: options.dryRun,
+        parsers: app.context.installedParsers,
+      })
+    })
+  },
+  inject(app, options) {
+    if (!options) {
+      throw new Error('Barrel plugin requires options.root and options.mode')
+    }
+
+    return {
+      async writeEntry({ root, mode }) {
+        if (!mode || mode === 'propagate') {
+          return undefined
+        }
+
+        const rootPath = resolve(root, 'index.ts')
+
+        const barrelFiles = app.files.filter((file) => {
+          return file.sources.some((source) => source.isIndexable)
+        })
+
+        const entryFile = createFile({
+          path: rootPath,
+          baseName: 'index.ts',
+          exports: barrelFiles
+            .flatMap((file) => {
+              const containsOnlyTypes = file.sources.every((source) => source.isTypeOnly)
+
+              return file.sources
+                ?.map((source) => {
+                  if (!file.path || !source.isIndexable) {
+                    return undefined
+                  }
+
+                  return {
+                    name: mode === 'all' ? undefined : [source.name],
+                    path: getRelativePath(rootPath, file.path),
+                    isTypeOnly: mode === 'all' ? containsOnlyTypes : source.isTypeOnly,
+                  } as KubbFile.Export
+                })
+                .filter(Boolean)
+            })
+            .filter(Boolean),
+          sources: [],
+        })
+
+        await app.context.fileManager.add(entryFile)
+
+        await app.context.fileManager.write({
+          mode: app.context.options?.mode,
+          dryRun: options.dryRun,
+          parsers: app.context.installedParsers,
+        })
+      },
+    }
+  },
+})

package/src/plugins/createPlugin.ts

@@ -1,6 +1,6 @@
 import type { Plugin, UserPlugin } from './types.ts'
 
-export function createPlugin<Options = any[], TAppExtension extends Record<string, any> = {}>(
+export function createPlugin<Options = unknown, TAppExtension extends Record<string, any> = {}>(
   plugin: UserPlugin<Options, TAppExtension>,
 ): Plugin<Options, TAppExtension> {
   return {

package/src/plugins/fsPlugin.ts

@@ -6,15 +6,15 @@ import type * as KubbFile from '../KubbFile.ts'
 
 type WriteOptions = {
   extension?: Record<KubbFile.Extname, KubbFile.Extname | ''>
-  dryRun?: boolean
 }
 
 type Options = {
+  dryRun?: boolean
   /**
    * Optional callback that is invoked whenever a file is written by the plugin.
    * Useful for tests to observe write operations without spying on internal functions.
    */
-  onWrite?: (path: string, data: string) => void | Promise<void>
+  onBeforeWrite?: (path: string, data: string | undefined) => void | Promise<void>
   clean?: {
     path: string
   }
@@ -24,13 +24,14 @@ type ExtendOptions = {
   write(options?: WriteOptions): Promise<void>
 }
 
-export async function write(path: string, data: string, options: { sanity?: boolean } = {}): Promise<string | undefined> {
-  if (data.trim() === '') {
-    return undefined
-  }
+export async function write(path: string, data: string | undefined, options: { sanity?: boolean } = {}): Promise<string | undefined> {
   return switcher(
     {
-      node: async (path: string, data: string, { sanity }: { sanity?: boolean }) => {
+      node: async (path, data: string | undefined, { sanity }: { sanity?: boolean }) => {
+        if (!data || data?.trim() === '') {
+          return undefined
+        }
+
         try {
           const oldContent = await fs.readFile(resolve(path), {
             encoding: 'utf-8',
@@ -42,7 +43,7 @@ export async function write(path: string, data: string, options: { sanity?: bool
           /* empty */
         }
 
-        await fs.outputFile(resolve(path), data, { encoding: 'utf-8' })
+        await fs.outputFile(resolve(path), data.trim(), { encoding: 'utf-8' })
 
         if (sanity) {
           const savedData = await fs.readFile(resolve(path), {
@@ -58,29 +59,29 @@ export async function write(path: string, data: string, options: { sanity?: bool
 
         return data
       },
-      bun: async (path: string, data: string, { sanity }: { sanity?: boolean }) => {
-        try {
-          await Bun.write(resolve(path), data)
+      bun: async (path: string, data: string | undefined, { sanity }: { sanity?: boolean }) => {
+        if (!data || data?.trim() === '') {
+          return undefined
+        }
 
-          if (sanity) {
-            const file = Bun.file(resolve(path))
-            const savedData = await file.text()
+        await Bun.write(resolve(path), data.trim())
 
-            if (savedData?.toString() !== data?.toString()) {
-              throw new Error(`Sanity check failed for ${path}\n\nData[${path.length}]:\n${path}\n\nSaved[${savedData.length}]:\n${savedData}\n`)
-            }
+        if (sanity) {
+          const file = Bun.file(resolve(path))
+          const savedData = await file.text()
 
-            return savedData
+          if (savedData?.toString() !== data?.toString()) {
+            throw new Error(`Sanity check failed for ${path}\n\nData[${path.length}]:\n${path}\n\nSaved[${savedData.length}]:\n${savedData}\n`)
           }
 
-          return data
-        } catch (e) {
-          console.error(e)
+          return savedData
         }
+
+        return data
       },
     },
     'node',
-  )(path, data.trim(), options)
+  )(path, data, options)
 }
 
 // biome-ignore lint/suspicious/noTsIgnore: production ready
@@ -101,31 +102,29 @@ declare global {
 
 export const fsPlugin = createPlugin<Options, ExtendOptions>({
   name: 'fs',
-  async install(app, options) {
+  install(app, options = {}) {
+    if (options.clean) {
+      fs.removeSync(options.clean.path)
+    }
+
     app.context.events.on('process:progress', async ({ file, source }) => {
-      if (options?.onWrite) {
-        await options.onWrite(file.path, source)
+      if (options.onBeforeWrite) {
+        await options.onBeforeWrite(file.path, source)
       }
       await write(file.path, source, { sanity: false })
     })
-
-    app.context.events.on('start', async () => {
-      if (options?.clean) {
-        await fs.remove(options.clean.path)
-      }
-    })
   },
-  inject(app) {
+  inject(app, { dryRun } = {}) {
     return {
       async write(
         options = {
           extension: { '.ts': '.ts' },
-          dryRun: false,
         },
       ) {
         await app.context.fileManager.write({
+          mode: app.context.options?.mode,
           extension: options.extension,
-          dryRun: options.dryRun,
+          dryRun,
           parsers: app.context.installedParsers,
         })
       },

package/src/plugins/index.ts

@@ -1,3 +1,5 @@
 export { createPlugin } from './createPlugin.ts'
 
 export { fsPlugin } from './fsPlugin.ts'
+export { barrelPlugin } from './barrelPlugin.ts'
+export { progressPlugin } from './progressPlugin.ts'