@kubb/fabric-core 0.1.1 → 0.1.2

package/src/FileProcessor.ts

@@ -1,85 +1,88 @@
 import type * as KubbFile from './KubbFile.ts'
-import { EventEmitter } from './utils/EventEmitter.ts'
-import { write } from './fs.ts'
 import pLimit from 'p-limit'
+import path from 'node:path'
+
 import type { Parser } from './parsers/types.ts'
-import { typeScriptParser } from './parsers/typescript.ts'
-import { tsxParser } from './parsers/tsx.ts'
-import { defaultParser } from './parsers/default.ts'
-
-type FileProcessorEvents = {
-  start: [{ files: KubbFile.ResolvedFile[] }]
-  finish: [{ files: KubbFile.ResolvedFile[] }]
-  'file:start': [{ file: KubbFile.ResolvedFile }]
-  'file:finish': [{ file: KubbFile.ResolvedFile }]
-}
+import { defaultParser } from './parsers/defaultParser.ts'
+import { AsyncEventEmitter } from './utils/AsyncEventEmitter.ts'
+import type { AppEvents } from './App.ts'
+import { typescriptParser } from './parsers/typescriptParser.ts'
+import { tsxParser } from './parsers/tsxParser.ts'
 
 export type ProcessFilesProps = {
+  parsers?: Set<Parser>
   extension?: Record<KubbFile.Extname, KubbFile.Extname | ''>
   dryRun?: boolean
 }
 
-type GetSourceOptions = {
+type GetParseOptions = {
+  parsers?: Set<Parser>
   extname?: KubbFile.Extname
 }
 
-async function getParser<TMeta extends object = object>(extname: KubbFile.Extname | undefined): Promise<Parser<TMeta>> {
-  const parsers: Record<KubbFile.Extname, Parser<any>> = {
-    '.ts': typeScriptParser,
-    '.js': typeScriptParser,
-    '.jsx': tsxParser,
-    '.tsx': tsxParser,
-    '.json': defaultParser,
-  }
+type Options = {
+  events?: AsyncEventEmitter<AppEvents>
+}
+
+export class FileProcessor {
+  #limit = pLimit(100)
+  events: AsyncEventEmitter<AppEvents>
+
+  constructor({ events = new AsyncEventEmitter<AppEvents>() }: Options = {}) {
+    this.events = events
 
-  if (!extname) {
-    return defaultParser
+    return this
   }
 
-  const parser = parsers[extname]
+  get #defaultParser(): Set<Parser> {
+    console.warn(`[parser] using default parsers, please consider using the "use" method to add custom parsers.`)
 
-  if (!parser) {
-    console.warn(`[parser] No parser found for ${extname}, default parser will be used`)
+    return new Set<Parser>([typescriptParser, tsxParser, defaultParser])
   }
 
-  return parser || defaultParser
-}
+  async parse(file: KubbFile.ResolvedFile, { parsers = this.#defaultParser, extname }: GetParseOptions = {}): Promise<string> {
+    if (!extname) {
+      console.warn('[parser] No extname found, default parser will be used')
+      return defaultParser.parse(file, { extname })
+    }
 
-export async function parseFile(file: KubbFile.ResolvedFile, { extname }: GetSourceOptions = {}): Promise<string> {
-  const parser = await getParser(file.extname)
+    const parser = [...parsers].find((item) => item.extNames?.includes(extname))
 
-  return parser.print(file, { extname })
-}
+    if (!parser) {
+      console.warn(`[parser] No parser found for ${extname}, default parser will be used`)
 
-export class FileProcessor extends EventEmitter<FileProcessorEvents> {
-  #limit = pLimit(100)
+      return defaultParser.parse(file, { extname })
+    }
 
-  constructor(maxListener = 1000) {
-    super(maxListener)
-    return this
+    return parser.parse(file, { extname })
   }
 
-  async run(files: Array<KubbFile.ResolvedFile>, { dryRun, extension }: ProcessFilesProps): Promise<KubbFile.ResolvedFile[]> {
-    this.emit('start', { files })
+  async run(files: Array<KubbFile.ResolvedFile>, { parsers, 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) =>
+    const promises = files.map((resolvedFile, index) =>
       this.#limit(async () => {
-        const extname = extension?.[resolvedFile.extname] || undefined
+        const extname = extension?.[resolvedFile.extname] || (path.extname(resolvedFile.path) as KubbFile.Extname)
 
-        this.emit('file:start', { file: resolvedFile })
+        await this.events.emit('file:start', { file: resolvedFile, index, total })
 
         if (!dryRun) {
-          const source = await parseFile(resolvedFile, { extname })
-          await write(resolvedFile.path, source, { sanity: false })
+          const source = await this.parse(resolvedFile, { extname, parsers })
+          await this.events.emit('process:progress', { file: resolvedFile, source, processed, percentage: (processed / total) * 100, total })
         }
 
-        this.emit('file:finish', { file: resolvedFile })
+        await this.events.emit('file:end', { file: resolvedFile, index, total })
+
+        processed++
       }),
     )
 
     await Promise.all(promises)
 
-    this.emit('finish', { files })
+    await this.events.emit('process:end', { files })
 
     return files
   }

package/src/createFile.ts

@@ -1,5 +1,5 @@
 import type * as KubbFile from './KubbFile.ts'
-import { trimExtName } from './fs.ts'
+import { trimExtName } from './utils/trimExtName.ts'
 import { createHash } from 'node:crypto'
 import path from 'node:path'
 import { isDeepEqual, uniqueBy } from 'remeda'

package/src/defineApp.ts

@@ -1,17 +1,9 @@
-import type * as KubbFile from './KubbFile.ts'
 import { FileManager } from './FileManager.ts'
-import { isPromise } from 'remeda'
-
-const isFunction = (val: unknown): val is Function => typeof val === 'function'
-
-type Component = any
-
-type PluginInstallFunction<Options = any[]> = Options extends unknown[] ? (app: App, ...options: Options) => any : (app: App, options: Options) => any
-
-export type ObjectPlugin<Options = any[]> = {
-  install: PluginInstallFunction<Options>
-}
-export type FunctionPlugin<Options = any[]> = PluginInstallFunction<Options> & Partial<ObjectPlugin<Options>>
+import { isFunction, isPromise } from 'remeda'
+import type { Plugin } from './plugins/types.ts'
+import type { Parser } from './parsers/types.ts'
+import { AsyncEventEmitter } from './utils/AsyncEventEmitter.ts'
+import type { App, AppContext, Component, AppEvents } from './App.ts'
 
 type AppRenderer = {
   render(): Promise<void> | void
@@ -19,57 +11,27 @@ type AppRenderer = {
   waitUntilExit(): Promise<void>
 }
 
-export type AppContext<TOptions = unknown> = {
-  options?: TOptions
-  fileManager: FileManager
-  addFile(...files: Array<KubbFile.File>): Promise<void>
-  files: Array<KubbFile.ResolvedFile>
-  clear: () => void
-}
-
 type RootRenderFunction<THostElement, TContext extends AppContext> = (this: TContext, container: THostElement, context: TContext) => AppRenderer
 
-type Plugin<Options = any[], P extends unknown[] = Options extends unknown[] ? Options : [Options]> = FunctionPlugin<P> | ObjectPlugin<P>
-
-type WriteOptions = {
-  extension?: Record<KubbFile.Extname, KubbFile.Extname | ''>
-  dryRun?: boolean
-}
-
-export interface App {
-  _component: Component
-  render(): Promise<void>
-  renderToString(): Promise<string>
-  files: Array<KubbFile.ResolvedFile>
-  use<Options>(plugin: Plugin<Options>, options: NoInfer<Options>): this
-  write(options?: WriteOptions): Promise<void>
-  addFile(...files: Array<KubbFile.File>): Promise<void>
-  waitUntilExit(): Promise<void>
-}
-
 export type DefineApp<TContext extends AppContext> = (rootComponent?: Component, options?: TContext['options']) => App
 
 export function defineApp<THostElement, TContext extends AppContext>(instance: RootRenderFunction<THostElement, TContext>): DefineApp<TContext> {
   function createApp(rootComponent: Component, options?: TContext['options']): App {
-    const installedPlugins = new WeakSet()
-    const fileManager = new FileManager()
+    const events = new AsyncEventEmitter<AppEvents>()
+    const installedPlugins = new Set<Plugin>()
+    const installedParsers = new Set<Parser>()
+    const fileManager = new FileManager({ events })
     const context = {
+      events,
       options,
       fileManager,
-      async addFile(...newFiles) {
-        await fileManager.add(...newFiles)
-      },
-      clear() {
-        context.fileManager.clear()
-      },
-      get files() {
-        return fileManager.files
-      },
+      installedPlugins,
+      installedParsers,
     } as TContext
 
     const { render, renderToString, waitUntilExit } = instance.call(context, rootComponent, context)
 
-    const app: App = {
+    const app = {
       _component: rootComponent,
       async render() {
         if (isPromise(render)) {
@@ -85,32 +47,45 @@ export function defineApp<THostElement, TContext extends AppContext>(instance: R
         return fileManager.files
       },
       waitUntilExit,
-      addFile: context.addFile,
-      async write(
-        options = {
-          extension: { '.ts': '.ts' },
-          dryRun: false,
-        },
-      ) {
-        await fileManager.processor.run({
-          extension: options.extension,
-          dryRun: options.dryRun,
-        })
+      async addFile(...newFiles) {
+        await fileManager.add(...newFiles)
       },
-      use(plugin: Plugin, ...options: any[]) {
-        if (installedPlugins.has(plugin)) {
-          console.warn('Plugin has already been applied to target app.')
-        } else if (plugin && isFunction(plugin.install)) {
-          installedPlugins.add(plugin)
-          plugin.install(app, ...options)
-        } else if (isFunction(plugin)) {
-          installedPlugins.add(plugin)
-          plugin(app, ...options)
+      use(pluginOrParser, ...options) {
+        const args = Array.isArray(options) ? options : [options[0]]
+
+        if (pluginOrParser.type === 'plugin') {
+          if (installedPlugins.has(pluginOrParser)) {
+            console.warn('Plugin has already been applied to target app.')
+          } else {
+            installedPlugins.add(pluginOrParser)
+          }
+
+          if (pluginOrParser.override && isFunction(pluginOrParser.override)) {
+            const overrider = pluginOrParser.override
+
+            const extraApp = (overrider as any)(app, context, ...args)
+            Object.assign(app, extraApp)
+          }
+        }
+        if (pluginOrParser.type === 'parser') {
+          if (installedParsers.has(pluginOrParser)) {
+            console.warn('Parser has already been applied to target app.')
+          } else {
+            installedParsers.add(pluginOrParser)
+          }
+        }
+
+        if (pluginOrParser && isFunction(pluginOrParser.install)) {
+          const installer = pluginOrParser.install
+
+          ;(installer as any)(app, context, ...args)
         }
 
         return app
       },
-    }
+    } as App
+
+    events.emit('start', { app })
 
     return app
   }

package/src/index.ts

@@ -3,4 +3,4 @@ export { defineApp } from './defineApp.ts'
 export { FileManager } from './FileManager.ts'
 export { createFile } from './createFile.ts'
 export { FileProcessor } from './FileProcessor.ts'
-export { createFileParser } from './parsers/createFileParser.ts'
+export type { App } from './App.ts'

package/src/parsers/createParser.ts

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

package/src/parsers/defaultParser.ts

@@ -0,0 +1,10 @@
+import { createParser } from './createParser.ts'
+
+export const defaultParser = createParser({
+  name: 'default',
+  extNames: ['.json'],
+  install() {},
+  async parse(file) {
+    return file.sources.map((item) => item.value).join('\n\n')
+  },
+})

package/src/parsers/index.ts

@@ -0,0 +1,5 @@
+export { createParser } from './createParser.ts'
+
+export { defaultParser } from './defaultParser.ts'
+export { tsxParser } from './tsxParser.ts'
+export { typescriptParser } from './typescriptParser.ts'

package/src/parsers/tsxParser.ts

@@ -0,0 +1,11 @@
+import { typescriptParser } from './typescriptParser.ts'
+import { createParser } from './createParser.ts'
+
+export const tsxParser = createParser({
+  name: 'tsx',
+  extNames: ['.tsx', '.jsx'],
+  install() {},
+  async parse(file, options = { extname: '.tsx' }) {
+    return typescriptParser.parse(file, options)
+  },
+})

package/src/parsers/types.ts

@@ -1,12 +1,22 @@
 import type * as KubbFile from '../KubbFile.ts'
+import type { Install } from '../App.ts'
 
 type PrintOptions = {
   extname?: KubbFile.Extname
 }
 
-export type Parser<TMeta extends object = object> = {
+export type Parser<TOptions = any[], TMeta extends object = any> = {
+  name: string
+  type: 'parser'
+  /**
+   * Undefined is being used for the defaultParser
+   */
+  extNames: Array<KubbFile.Extname> | undefined
+  install: Install<TOptions>
   /**
    * Convert a file to string
    */
-  print: (file: KubbFile.ResolvedFile<TMeta>, options: PrintOptions) => Promise<string>
+  parse(file: KubbFile.ResolvedFile<TMeta>, options: PrintOptions): Promise<string>
 }
+
+export type UserParser<TOptions = any[], TMeta extends object = any> = Omit<Parser<TOptions, TMeta>, 'type'>

package/src/parsers/{typescript.ts → typescriptParser.ts}

@@ -1,7 +1,8 @@
 import ts from 'typescript'
-import { getRelativePath, trimExtName } from '../fs.ts'
+import { getRelativePath } from '../utils/getRelativePath.ts'
+import { trimExtName } from '../utils/trimExtName.ts'
 import path from 'node:path'
-import { createFileParser } from './createFileParser.ts'
+import { createParser } from './createParser.ts'
 
 const { factory } = ts
 
@@ -147,8 +148,11 @@ export function createExport({
   )
 }
 
-export const typeScriptParser = createFileParser({
-  async print(file, options = { extname: '.ts' }) {
+export const typescriptParser = createParser({
+  name: 'typescript',
+  extNames: ['.ts', '.js'],
+  install() {},
+  async parse(file, options = { extname: '.ts' }) {
     const source = file.sources.map((item) => item.value).join('\n\n')
 
     const importNodes = file.imports

package/src/plugins/createPlugin.ts

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

package/src/plugins/fsPlugin.ts

@@ -0,0 +1,112 @@
+import { createPlugin } from './createPlugin.ts'
+import { switcher } from 'js-runtime'
+import fs from 'fs-extra'
+import { resolve } from 'node:path'
+import type * as KubbFile from '../KubbFile.ts'
+
+type Options = {
+  /**
+   * 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>
+}
+
+export async function write(path: string, data: string, options: { sanity?: boolean } = {}): Promise<string | undefined> {
+  if (data.trim() === '') {
+    return undefined
+  }
+  return switcher(
+    {
+      node: async (path: string, data: string, { sanity }: { sanity?: boolean }) => {
+        try {
+          const oldContent = await fs.readFile(resolve(path), {
+            encoding: 'utf-8',
+          })
+          if (oldContent?.toString() === data?.toString()) {
+            return
+          }
+        } catch (_err) {
+          /* empty */
+        }
+
+        await fs.outputFile(resolve(path), data, { encoding: 'utf-8' })
+
+        if (sanity) {
+          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
+        }
+
+        return data
+      },
+      bun: async (path: string, data: string, { sanity }: { sanity?: boolean }) => {
+        try {
+          await Bun.write(resolve(path), data)
+
+          if (sanity) {
+            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[${path.length}]:\n${path}\n\nSaved[${savedData.length}]:\n${savedData}\n`)
+            }
+
+            return savedData
+          }
+
+          return data
+        } catch (e) {
+          console.error(e)
+        }
+      },
+    },
+    'node',
+  )(path, data.trim(), options)
+}
+
+type WriteOptions = {
+  extension?: Record<KubbFile.Extname, KubbFile.Extname | ''>
+  dryRun?: boolean
+}
+
+declare module '../index.ts' {
+  interface App {
+    write(options?: WriteOptions): Promise<void>
+  }
+}
+
+export const fsPlugin = createPlugin<Options, { write(options?: WriteOptions): Promise<void> }>({
+  name: 'fs',
+  scope: 'write',
+  async install(_app, context, options) {
+    context.events.on('process:progress', async ({ file, source }) => {
+      if (options?.onWrite) {
+        await options.onWrite(file.path, source)
+      }
+      await write(file.path, source, { sanity: false })
+    })
+  },
+  override(_app, context) {
+    return {
+      async write(
+        options = {
+          extension: { '.ts': '.ts' },
+          dryRun: false,
+        },
+      ) {
+        await context.fileManager.write({
+          extension: options.extension,
+          dryRun: options.dryRun,
+          parsers: context.installedParsers,
+        })
+      },
+    }
+  },
+})

package/src/plugins/index.ts

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

package/src/plugins/types.ts

@@ -0,0 +1,15 @@
+import type { Install, Override } from '../App.ts'
+
+export type Plugin<TOptions = any[], TAppExtension extends Record<string, any> = {}> = {
+  name: string
+  type: 'plugin'
+  scope?: 'write' | 'read' | (string & {})
+  install: Install<TOptions> | Promise<Install<TOptions>>
+  /**
+   * Runtime app overrides or extensions.
+   * Merged into the app instance after install.
+   */
+  override?: Override<TOptions, TAppExtension>
+}
+
+export type UserPlugin<TOptions = any[], TAppExtension extends Record<string, any> = {}> = Omit<Plugin<TOptions, TAppExtension>, 'type'>

package/src/types.ts

@@ -1,2 +1,5 @@
 export * as KubbFile from './KubbFile.ts'
-export type { DefineApp, AppContext, App } from './defineApp.ts'
+export type { DefineApp } from './defineApp.ts'
+export type { AppContext } from './App.ts'
+
+export type { App } from './App.ts'

package/src/utils/AsyncEventEmitter.ts

@@ -0,0 +1,37 @@
+import { EventEmitter as NodeEventEmitter } from 'node:events'
+
+export class AsyncEventEmitter<TEvents extends Record<string, any>> {
+  constructor(maxListener = 100) {
+    this.#emitter.setMaxListeners(maxListener)
+  }
+  #emitter = new NodeEventEmitter()
+
+  async emit<TEventName extends keyof TEvents & string>(eventName: TEventName, ...eventArgs: TEvents[TEventName]): Promise<void> {
+    const listeners = this.#emitter.listeners(eventName) as Array<(...args: TEvents[TEventName]) => any>
+
+    if (listeners.length === 0) {
+      return undefined
+    }
+
+    await Promise.all(
+      listeners.map(async (listener) => {
+        try {
+          return await listener(...eventArgs)
+        } catch (err) {
+          console.error(`Error in async listener for "${eventName}":`, err)
+        }
+      }),
+    )
+  }
+
+  on<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArg: TEvents[TEventName]) => void): void {
+    this.#emitter.on(eventName, handler as any)
+  }
+
+  off<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArg: TEvents[TEventName]) => void): void {
+    this.#emitter.off(eventName, handler as any)
+  }
+  removeAll(): void {
+    this.#emitter.removeAllListeners()
+  }
+}

package/src/utils/getRelativePath.ts

@@ -0,0 +1,32 @@
+import { normalize, relative } from 'node:path'
+
+function slash(path: string, platform: 'windows' | 'mac' | 'linux' = 'linux') {
+  const isWindowsPath = /^\\\\\?\\/.test(path)
+  const normalizedPath = normalize(path)
+
+  if (['linux', 'mac'].includes(platform) && !isWindowsPath) {
+    // linux and mac
+    return normalizedPath.replaceAll(/\\/g, '/').replace('../', '')
+  }
+
+  // windows
+  return normalizedPath.replaceAll(/\\/g, '/').replace('../', '')
+}
+
+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
+  }
+
+  return `./${slashedPath}`
+}

package/src/utils/trimExtName.ts

@@ -0,0 +1,3 @@
+export function trimExtName(text: string): string {
+  return text.replace(/\.[^/.]+$/, '')
+}