@kubb/fabric-core 0.1.0 → 0.1.2

package/src/FileProcessor.ts

@@ -0,0 +1,89 @@
+import type * as KubbFile from './KubbFile.ts'
+import pLimit from 'p-limit'
+import path from 'node:path'
+
+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 { 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 GetParseOptions = {
+  parsers?: Set<Parser>
+  extname?: KubbFile.Extname
+}
+
+type Options = {
+  events?: AsyncEventEmitter<AppEvents>
+}
+
+export class FileProcessor {
+  #limit = pLimit(100)
+  events: AsyncEventEmitter<AppEvents>
+
+  constructor({ events = new AsyncEventEmitter<AppEvents>() }: Options = {}) {
+    this.events = events
+
+    return this
+  }
+
+  get #defaultParser(): Set<Parser> {
+    console.warn(`[parser] using default parsers, please consider using the "use" method to add custom parsers.`)
+
+    return new Set<Parser>([typescriptParser, tsxParser, 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 })
+    }
+
+    const parser = [...parsers].find((item) => item.extNames?.includes(extname))
+
+    if (!parser) {
+      console.warn(`[parser] No parser found for ${extname}, default parser will be used`)
+
+      return defaultParser.parse(file, { extname })
+    }
+
+    return parser.parse(file, { extname })
+  }
+
+  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, index) =>
+      this.#limit(async () => {
+        const extname = extension?.[resolvedFile.extname] || (path.extname(resolvedFile.path) as KubbFile.Extname)
+
+        await this.events.emit('file:start', { file: resolvedFile, index, total })
+
+        if (!dryRun) {
+          const source = await this.parse(resolvedFile, { extname, parsers })
+          await this.events.emit('process:progress', { file: resolvedFile, source, processed, percentage: (processed / total) * 100, total })
+        }
+
+        await this.events.emit('file:end', { file: resolvedFile, index, total })
+
+        processed++
+      }),
+    )
+
+    await Promise.all(promises)
+
+    await this.events.emit('process:end', { files })
+
+    return files
+  }
+}

package/src/createFile.ts

@@ -0,0 +1,167 @@
+import type * as KubbFile from './KubbFile.ts'
+import { trimExtName } from './utils/trimExtName.ts'
+import { createHash } from 'node:crypto'
+import path from 'node:path'
+import { isDeepEqual, uniqueBy } from 'remeda'
+import { orderBy } from 'natural-orderby'
+
+function hashObject(obj: Record<string, unknown>): string {
+  const str = JSON.stringify(obj, Object.keys(obj).sort())
+  return createHash('sha256').update(str).digest('hex')
+}
+
+export function combineSources(sources: Array<KubbFile.Source>): Array<KubbFile.Source> {
+  return uniqueBy(sources, (obj) => [obj.name, obj.isExportable, obj.isTypeOnly] as const)
+}
+
+export function combineExports(exports: Array<KubbFile.Export>): Array<KubbFile.Export> {
+  return orderBy(exports, [
+    (v) => !!Array.isArray(v.name),
+    (v) => !v.isTypeOnly,
+    (v) => v.path,
+    (v) => !!v.name,
+    (v) => (Array.isArray(v.name) ? orderBy(v.name) : v.name),
+  ]).reduce(
+    (prev, curr) => {
+      const name = curr.name
+      const prevByPath = prev.findLast((imp) => imp.path === curr.path)
+      const prevByPathAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isDeepEqual(imp.name, name) && imp.isTypeOnly)
+
+      if (prevByPathAndIsTypeOnly) {
+        // we already have an export that has the same path but uses `isTypeOnly` (export type ...)
+        return prev
+      }
+
+      const uniquePrev = prev.findLast(
+        (imp) => imp.path === curr.path && isDeepEqual(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly && imp.asAlias === curr.asAlias,
+      )
+
+      // we already have an item that was unique enough or name field is empty or prev asAlias is set but current has no changes
+      if (uniquePrev || (Array.isArray(name) && !name.length) || (prevByPath?.asAlias && !curr.asAlias)) {
+        return prev
+      }
+
+      if (!prevByPath) {
+        return [
+          ...prev,
+          {
+            ...curr,
+            name: Array.isArray(name) ? [...new Set(name)] : name,
+          },
+        ]
+      }
+
+      // merge all names when prev and current both have the same isTypeOnly set
+      if (prevByPath && Array.isArray(prevByPath.name) && Array.isArray(curr.name) && prevByPath.isTypeOnly === curr.isTypeOnly) {
+        prevByPath.name = [...new Set([...prevByPath.name, ...curr.name])]
+
+        return prev
+      }
+
+      return [...prev, curr]
+    },
+    [] as Array<KubbFile.Export>,
+  )
+}
+
+export function combineImports(imports: Array<KubbFile.Import>, exports: Array<KubbFile.Export>, source?: string): Array<KubbFile.Import> {
+  return orderBy(imports, [
+    (v) => !!Array.isArray(v.name),
+    (v) => !v.isTypeOnly,
+    (v) => v.path,
+    (v) => !!v.name,
+    (v) => (Array.isArray(v.name) ? orderBy(v.name) : v.name),
+  ]).reduce(
+    (prev, curr) => {
+      let name = Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name
+
+      const hasImportInSource = (importName: string) => {
+        if (!source) {
+          return true
+        }
+
+        const checker = (name?: string) => {
+          return name && source.includes(name)
+        }
+
+        return checker(importName) || exports.some(({ name }) => (Array.isArray(name) ? name.some(checker) : checker(name)))
+      }
+
+      if (curr.path === curr.root) {
+        // root and path are the same file, remove the "./" import
+        return prev
+      }
+
+      // merge all names and check if the importName is being used in the generated source and if not filter those imports out
+      if (Array.isArray(name)) {
+        name = name.filter((item) => (typeof item === 'string' ? hasImportInSource(item) : hasImportInSource(item.propertyName)))
+      }
+
+      const prevByPath = prev.findLast((imp) => imp.path === curr.path && imp.isTypeOnly === curr.isTypeOnly)
+      const uniquePrev = prev.findLast((imp) => imp.path === curr.path && isDeepEqual(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly)
+      const prevByPathNameAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isDeepEqual(imp.name, name) && imp.isTypeOnly)
+
+      if (prevByPathNameAndIsTypeOnly) {
+        // we already have an export that has the same path but uses `isTypeOnly` (import type ...)
+        return prev
+      }
+
+      // already unique enough or name is empty
+      if (uniquePrev || (Array.isArray(name) && !name.length)) {
+        return prev
+      }
+
+      // new item, append name
+      if (!prevByPath) {
+        return [
+          ...prev,
+          {
+            ...curr,
+            name,
+          },
+        ]
+      }
+
+      // merge all names when prev and current both have the same isTypeOnly set
+      if (prevByPath && Array.isArray(prevByPath.name) && Array.isArray(name) && prevByPath.isTypeOnly === curr.isTypeOnly) {
+        prevByPath.name = [...new Set([...prevByPath.name, ...name])]
+
+        return prev
+      }
+
+      // no import was found in the source, ignore import
+      if (!Array.isArray(name) && name && !hasImportInSource(name)) {
+        return prev
+      }
+
+      return [...prev, curr]
+    },
+    [] as Array<KubbFile.Import>,
+  )
+}
+
+/**
+ * Helper to create a file with name and id set
+ */
+export function createFile<TMeta extends object = object>(file: KubbFile.File<TMeta>): KubbFile.ResolvedFile<TMeta> {
+  const extname = path.extname(file.baseName) as KubbFile.Extname
+  if (!extname) {
+    throw new Error(`No extname found for ${file.baseName}`)
+  }
+
+  const source = file.sources.map((item) => item.value).join('\n\n')
+  const exports = file.exports?.length ? combineExports(file.exports) : []
+  const imports = file.imports?.length && source ? combineImports(file.imports, exports, source) : []
+  const sources = file.sources?.length ? combineSources(file.sources) : []
+
+  return {
+    ...file,
+    id: hashObject({ path: file.path }),
+    name: trimExtName(file.baseName),
+    extname,
+    imports: imports,
+    exports: exports,
+    sources: sources,
+    meta: file.meta || ({} as TMeta),
+  }
+}

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>
-  getFiles(): Promise<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.getFiles()
-      },
+      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)) {
@@ -81,36 +43,49 @@ export function defineApp<THostElement, TContext extends AppContext>(instance: R
       async renderToString() {
         return renderToString()
       },
-      async getFiles() {
-        return fileManager.getFiles()
+      get files() {
+        return fileManager.files
       },
       waitUntilExit,
-      addFile: context.addFile,
-      async write(
-        options = {
-          extension: { '.ts': '.ts' },
-          dryRun: false,
-        },
-      ) {
-        await fileManager.processFiles({
-          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

@@ -1,4 +1,6 @@
 export { createApp } from './createApp.ts'
 export { defineApp } from './defineApp.ts'
 export { FileManager } from './FileManager.ts'
-export { parseFile } from './parsers/parser.ts'
+export { createFile } from './createFile.ts'
+export { FileProcessor } from './FileProcessor.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

@@ -0,0 +1,22 @@
+import type * as KubbFile from '../KubbFile.ts'
+import type { Install } from '../App.ts'
+
+type PrintOptions = {
+  extname?: KubbFile.Extname
+}
+
+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
+   */
+  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 './parser.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'