@kubb/core 5.0.0-alpha.3 → 5.0.0-alpha.31

package/src/build.ts

@@ -1,41 +1,72 @@
 import { dirname, relative, resolve } from 'node:path'
-import { AsyncEventEmitter, exists, formatMs, getElapsedMs, getRelativePath, URLPath } from '@internals/utils'
-import type { KubbFile } from '@kubb/fabric-core/types'
-import type { Fabric } from '@kubb/react-fabric'
+import { AsyncEventEmitter, BuildError, exists, formatMs, getElapsedMs, getRelativePath, URLPath } from '@internals/utils'
+import { transform, walk } from '@kubb/ast'
+import type { OperationNode } from '@kubb/ast/types'
+import type { Fabric as FabricType } from '@kubb/fabric-core/types'
 import { createFabric } from '@kubb/react-fabric'
-import { typescriptParser } from '@kubb/react-fabric/parsers'
 import { fsPlugin } from '@kubb/react-fabric/plugins'
-import { isInputPath } from './config.ts'
 import { BARREL_FILENAME, DEFAULT_BANNER, DEFAULT_CONCURRENCY, DEFAULT_EXTENSION, DEFAULT_STUDIO_URL } from './constants.ts'
-import { BuildError } from './errors.ts'
-import { PluginManager } from './PluginManager.ts'
+import { defineParser } from './defineParser.ts'
+import type * as KubbFile from './KubbFile.ts'
+import { PluginDriver } from './PluginDriver.ts'
+import { applyHookResult } from './renderNode.tsx'
 import { fsStorage } from './storages/fsStorage.ts'
-import type { AdapterSource, Config, DefineStorage, KubbEvents, Output, Plugin, UserConfig } from './types.ts'
+import type { AdapterSource, Config, KubbEvents, Plugin, PluginContext, Storage, UserConfig } from './types.ts'
 import { getDiagnosticInfo } from './utils/diagnostics.ts'
 import type { FileMetaBase } from './utils/getBarrelFiles.ts'
+import { getBarrelFiles } from './utils/getBarrelFiles.ts'
+import { isInputPath } from './utils/isInputPath.ts'
 
 type BuildOptions = {
   config: UserConfig
   events?: AsyncEventEmitter<KubbEvents>
 }
 
+/**
+ * Full output produced by a successful or failed build.
+ */
 type BuildOutput = {
+  /**
+   * Plugins that threw during installation, paired with the caught error.
+   */
   failedPlugins: Set<{ plugin: Plugin; error: Error }>
-  fabric: Fabric
+  fabric: FabricType
   files: Array<KubbFile.ResolvedFile>
-  pluginManager: PluginManager
+  driver: PluginDriver
+  /**
+   * Elapsed time in milliseconds for each plugin, keyed by plugin name.
+   */
   pluginTimings: Map<string, number>
   error?: Error
+  /**
+   * Raw generated source, keyed by absolute file path.
+   */
   sources: Map<KubbFile.Path, string>
 }
 
+/**
+ * Intermediate result returned by {@link setup} and accepted by {@link safeBuild}.
+ */
 type SetupResult = {
   events: AsyncEventEmitter<KubbEvents>
-  fabric: Fabric
-  pluginManager: PluginManager
+  fabric: FabricType
+  driver: PluginDriver
   sources: Map<KubbFile.Path, string>
+  config: Config
 }
 
+/**
+ * Initializes all Kubb infrastructure for a build without executing any plugins.
+ *
+ * - Validates the input path (when applicable).
+ * - Applies config defaults (`root`, `output.*`, `devtools`).
+ * - Creates the Fabric instance and wires storage, format, and lint hooks.
+ * - Runs the adapter (if configured) to produce the universal `RootNode`.
+ *   When no adapter is supplied and `@kubb/adapter-oas` is installed as an
+ *
+ * Pass the returned {@link SetupResult} directly to {@link safeBuild} or {@link build}
+ * via the `overrides` argument to reuse the same infrastructure across multiple runs.
+ */
 export async function setup(options: BuildOptions): Promise<SetupResult> {
   const { config: userConfig, events = new AsyncEventEmitter<KubbEvents>() } = options
 
@@ -87,9 +118,15 @@ export async function setup(options: BuildOptions): Promise<SetupResult> {
     }
   }
 
-  const definedConfig: Config = {
+  if (!userConfig.adapter) {
+    throw new Error('Adapter should be defined')
+  }
+
+  const config: Config = {
     root: userConfig.root || process.cwd(),
     ...userConfig,
+    parsers: userConfig.parsers ?? [],
+    adapter: userConfig.adapter,
     output: {
       write: true,
       barrelType: 'named',
@@ -110,19 +147,35 @@ export async function setup(options: BuildOptions): Promise<SetupResult> {
   // storage or fall back to fsStorage (backwards-compatible default).
   // Keys are root-relative (e.g. `src/gen/api/getPets.ts`) so fsStorage()
   // needs no configuration — it resolves them against process.cwd().
-  const storage: DefineStorage | null = definedConfig.output.write === false ? null : (definedConfig.output.storage ?? fsStorage())
+  const storage: Storage | null = config.output.write === false ? null : (config.output.storage ?? fsStorage())
 
-  if (definedConfig.output.clean) {
+  if (config.output.clean) {
     await events.emit('debug', {
       date: new Date(),
-      logs: ['Cleaning output directories', `  • Output: ${definedConfig.output.path}`],
+      logs: ['Cleaning output directories', `  • Output: ${config.output.path}`],
     })
-    await storage?.clear(resolve(definedConfig.root, definedConfig.output.path))
+    await storage?.clear(resolve(config.root, config.output.path))
   }
 
   const fabric = createFabric()
   fabric.use(fsPlugin)
-  fabric.use(typescriptParser)
+
+  for (const parser of config.parsers) {
+    fabric.use(parser)
+  }
+  // Catch-all fallback: joins all source values for any unhandled extension
+  fabric.use(
+    defineParser({
+      name: 'fallback',
+      extNames: undefined,
+      parse(file) {
+        return file.sources
+          .map((item) => item.value)
+          .filter((value): value is string => value != null)
+          .join('\n\n')
+      },
+    }),
+  )
 
   fabric.context.on('files:processing:start', (files) => {
     events.emit('files:processing:start', files)
@@ -136,13 +189,13 @@ export async function setup(options: BuildOptions): Promise<SetupResult> {
     const { file, source } = params
     await events.emit('file:processing:update', {
       ...params,
-      config: definedConfig,
+      config: config,
       source,
     })
 
     if (source) {
       // Key is root-relative so it's meaningful for any backend (fs, S3, Redis…)
-      const key = relative(resolve(definedConfig.root), file.path)
+      const key = relative(resolve(config.root), file.path)
       await storage?.setItem(key, source)
       sources.set(file.path, source)
     }
@@ -158,51 +211,57 @@ export async function setup(options: BuildOptions): Promise<SetupResult> {
 
   await events.emit('debug', {
     date: new Date(),
-    logs: [
-      '✓ Fabric initialized',
-      `  • Storage: ${storage ? storage.name : 'disabled (dry-run)'}`,
-      `  • Barrel type: ${definedConfig.output.barrelType || 'none'}`,
-    ],
+    logs: ['✓ Fabric initialized', `  • Storage: ${storage ? storage.name : 'disabled (dry-run)'}`, `  • Barrel type: ${config.output.barrelType || 'none'}`],
   })
 
-  const pluginManager = new PluginManager(definedConfig, {
+  const driver = new PluginDriver(config, {
     fabric,
     events,
     concurrency: DEFAULT_CONCURRENCY,
   })
 
-  // Run the adapter (if provided) to produce the universal RootNode
-  if (definedConfig.adapter) {
-    const source = inputToAdapterSource(definedConfig)
+  // Run the adapter to produce the universal RootNode.
 
-    await events.emit('debug', {
-      date: new Date(),
-      logs: [`Running adapter: ${definedConfig.adapter.name}`],
-    })
+  const adapter = config.adapter
+  if (!adapter) {
+    throw new Error('No adapter configured. Please provide an adapter in your kubb.config.ts.')
+  }
+  const source = inputToAdapterSource(config)
 
-    pluginManager.adapter = definedConfig.adapter
-    pluginManager.rootNode = await definedConfig.adapter.parse(source)
+  await events.emit('debug', {
+    date: new Date(),
+    logs: [`Running adapter: ${adapter.name}`],
+  })
 
-    await events.emit('debug', {
-      date: new Date(),
-      logs: [
-        `✓ Adapter '${definedConfig.adapter.name}' resolved RootNode`,
-        `  • Schemas: ${pluginManager.rootNode.schemas.length}`,
-        `  • Operations: ${pluginManager.rootNode.operations.length}`,
-      ],
-    })
-  }
+  driver.adapter = adapter
+  driver.rootNode = await adapter.parse(source)
+
+  await events.emit('debug', {
+    date: new Date(),
+    logs: [
+      `✓ Adapter '${adapter.name}' resolved RootNode`,
+      `  • Schemas: ${driver.rootNode.schemas.length}`,
+      `  • Operations: ${driver.rootNode.operations.length}`,
+    ],
+  })
 
   return {
+    config,
     events,
     fabric,
-    pluginManager,
+    driver,
     sources,
   }
 }
 
+/**
+ * Runs a full Kubb build and throws on any error or plugin failure.
+ *
+ * Internally delegates to {@link safeBuild} and rethrows collected errors.
+ * Pass an existing {@link SetupResult} via `overrides` to skip the setup phase.
+ */
 export async function build(options: BuildOptions, overrides?: SetupResult): Promise<BuildOutput> {
-  const { fabric, files, pluginManager, failedPlugins, pluginTimings, error, sources } = await safeBuild(options, overrides)
+  const { fabric, files, driver, failedPlugins, pluginTimings, error, sources } = await safeBuild(options, overrides)
 
   if (error) {
     throw error
@@ -218,27 +277,88 @@ export async function build(options: BuildOptions, overrides?: SetupResult): Pro
     failedPlugins,
     fabric,
     files,
-    pluginManager,
+    driver,
     pluginTimings,
     error: undefined,
     sources,
   }
 }
 
+/**
+ * Walks the AST and dispatches nodes to a plugin's direct AST hooks
+ * (`schema`, `operation`, `operations`).
+ *
+ * - Each hook accepts a single handler **or an array** — all entries are called in sequence.
+ * - Nodes that are excluded by `exclude`/`include` plugin options are skipped automatically.
+ * - Return values are handled via `applyHookResult`: React elements are rendered,
+ *   `KubbFile.File[]` are written via upsert, and `void` is a no-op (manual handling).
+ * - Barrel files are generated automatically when `output.barrelType` is set.
+ */
+async function runPluginAstHooks(plugin: Plugin, context: PluginContext): Promise<void> {
+  const { adapter, rootNode, resolver, fabric } = context
+  const { exclude, include, override } = plugin.options
+
+  if (!adapter || !rootNode) {
+    throw new Error(`[${plugin.name}] No adapter found. Add an OAS adapter (e.g. pluginOas()) before this plugin in your Kubb config.`)
+  }
+
+  const collectedOperations: Array<OperationNode> = []
+
+  await walk(rootNode, {
+    depth: 'shallow',
+    async schema(node) {
+      if (!plugin.schema) return
+      const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node
+      const options = resolver.resolveOptions(transformedNode, { options: plugin.options, exclude, include, override })
+      if (options === null) return
+      const result = await plugin.schema.call(context, transformedNode, options)
+
+      await applyHookResult(result, fabric)
+    },
+    async operation(node) {
+      const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node
+      const options = resolver.resolveOptions(transformedNode, { options: plugin.options, exclude, include, override })
+      if (options !== null) {
+        collectedOperations.push(transformedNode)
+        if (plugin.operation) {
+          const result = await plugin.operation.call(context, transformedNode, options)
+          await applyHookResult(result, fabric)
+        }
+      }
+    },
+  })
+
+  if (plugin.operations && collectedOperations.length > 0) {
+    const result = await plugin.operations.call(context, collectedOperations, plugin.options)
+
+    await applyHookResult(result, fabric)
+  }
+}
+
+/**
+ * Runs a full Kubb build and captures errors instead of throwing.
+ *
+ * - Installs each plugin in order, recording failures in `failedPlugins`.
+ * - Generates the root barrel file when `output.barrelType` is set.
+ * - Writes all files through Fabric.
+ *
+ * Returns a {@link BuildOutput} even on failure — inspect `error` and
+ * `failedPlugins` to determine whether the build succeeded.
+ */
 export async function safeBuild(options: BuildOptions, overrides?: SetupResult): Promise<BuildOutput> {
-  const { fabric, pluginManager, events, sources } = overrides ? overrides : await setup(options)
+  const { fabric, driver, events, sources } = overrides ? overrides : await setup(options)
 
   const failedPlugins = new Set<{ plugin: Plugin; error: Error }>()
   // in ms
   const pluginTimings = new Map<string, number>()
-  const config = pluginManager.config
+  const config = driver.config
 
   try {
-    for (const plugin of pluginManager.plugins) {
-      const context = pluginManager.getContext(plugin)
+    for (const plugin of driver.plugins.values()) {
+      const context = driver.getContext(plugin)
       const hrStart = process.hrtime()
-
-      const installer = plugin.install.bind(context)
+      const { output } = plugin.options ?? {}
+      const root = resolve(config.root, config.output.path)
 
       try {
         const timestamp = new Date()
@@ -247,10 +367,26 @@ export async function safeBuild(options: BuildOptions, overrides?: SetupResult):
 
         await events.emit('debug', {
           date: timestamp,
-          logs: ['Installing plugin...', `  • Plugin Name: ${plugin.name}`],
+          logs: ['Starting plugin...', `  • Plugin Name: ${plugin.name}`],
         })
 
-        await installer(context)
+        // Call buildStart() for any custom plugin logic
+        await plugin.buildStart.call(context)
+
+        // Dispatch schema/operation/operations hooks (direct hooks or composed via composeGenerators)
+        if (plugin.schema || plugin.operation || plugin.operations) {
+          await runPluginAstHooks(plugin, context)
+        }
+
+        if (output) {
+          const barrelFiles = await getBarrelFiles(fabric.files, {
+            type: output.barrelType ?? 'named',
+            root,
+            output,
+            meta: { pluginName: plugin.name },
+          })
+          await context.upsertFile(...barrelFiles)
+        }
 
         const duration = getElapsedMs(hrStart)
         pluginTimings.set(plugin.name, duration)
@@ -259,7 +395,7 @@ export async function safeBuild(options: BuildOptions, overrides?: SetupResult):
 
         await events.emit('debug', {
           date: new Date(),
-          logs: [`✓ Plugin installed successfully (${formatMs(duration)})`],
+          logs: [`✓ Plugin started successfully (${formatMs(duration)})`],
         })
       } catch (caughtError) {
         const error = caughtError as Error
@@ -275,7 +411,7 @@ export async function safeBuild(options: BuildOptions, overrides?: SetupResult):
         await events.emit('debug', {
           date: errorTimestamp,
           logs: [
-            '✗ Plugin installation failed',
+            '✗ Plugin start failed',
             `  • Plugin Name: ${plugin.name}`,
             `  • Error: ${error.constructor.name} - ${error.message}`,
             '  • Stack Trace:',
@@ -314,7 +450,7 @@ export async function safeBuild(options: BuildOptions, overrides?: SetupResult):
       const rootFile: KubbFile.File = {
         path: rootPath,
         baseName: BARREL_FILENAME,
-        exports: buildBarrelExports({ barrelFiles, rootDir, existingExports, config, pluginManager }),
+        exports: buildBarrelExports({ barrelFiles, rootDir, existingExports, config, driver }),
         sources: [],
         imports: [],
         meta: {},
@@ -332,11 +468,19 @@ export async function safeBuild(options: BuildOptions, overrides?: SetupResult):
 
     await fabric.write({ extension: config.output.extension })
 
+    // Call buildEnd() on each plugin after all files are written
+    for (const plugin of driver.plugins.values()) {
+      if (plugin.buildEnd) {
+        const context = driver.getContext(plugin)
+        await plugin.buildEnd.call(context)
+      }
+    }
+
     return {
       failedPlugins,
       fabric,
       files,
-      pluginManager,
+      driver,
       pluginTimings,
       sources,
     }
@@ -345,7 +489,7 @@ export async function safeBuild(options: BuildOptions, overrides?: SetupResult):
       failedPlugins,
       fabric,
       files: [],
-      pluginManager,
+      driver,
       pluginTimings,
       error: error as Error,
       sources,
@@ -358,12 +502,12 @@ type BuildBarrelExportsParams = {
   rootDir: string
   existingExports: Set<string>
   config: Config
-  pluginManager: PluginManager
+  driver: PluginDriver
 }
 
-function buildBarrelExports({ barrelFiles, rootDir, existingExports, config, pluginManager }: BuildBarrelExportsParams): KubbFile.Export[] {
+function buildBarrelExports({ barrelFiles, rootDir, existingExports, config, driver }: BuildBarrelExportsParams): KubbFile.Export[] {
   const pluginNameMap = new Map<string, Plugin>()
-  for (const plugin of pluginManager.plugins) {
+  for (const plugin of driver.plugins.values()) {
     pluginNameMap.set(plugin.name, plugin)
   }
 
@@ -377,7 +521,7 @@ function buildBarrelExports({ barrelFiles, rootDir, existingExports, config, plu
 
       const meta = file.meta as FileMetaBase | undefined
       const plugin = meta?.pluginName ? pluginNameMap.get(meta.pluginName) : undefined
-      const pluginOptions = plugin?.options as { output?: Output<unknown> } | undefined
+      const pluginOptions = plugin?.options
 
       if (!pluginOptions || pluginOptions.output?.barrelType === false) {
         return []
@@ -407,7 +551,7 @@ function inputToAdapterSource(config: Config): AdapterSource {
   if (Array.isArray(config.input)) {
     return {
       type: 'paths',
-      paths: config.input.map((i) => resolve(config.root, i.path)),
+      paths: config.input.map((i) => (new URLPath(i.path).isURL ? i.path : resolve(config.root, i.path))),
     }
   }
 
@@ -415,6 +559,10 @@ function inputToAdapterSource(config: Config): AdapterSource {
     return { type: 'data', data: config.input.data }
   }
 
+  if (new URLPath(config.input.path).isURL) {
+    return { type: 'path', path: config.input.path }
+  }
+
   const resolved = resolve(config.root, config.input.path)
   return { type: 'path', path: resolved }
 }

package/src/constants.ts

@@ -1,21 +1,40 @@
-import type { KubbFile } from '@kubb/fabric-core/types'
+import type * as KubbFile from './KubbFile.ts'
 
+/**
+ * Base URL for the Kubb Studio web app.
+ */
 export const DEFAULT_STUDIO_URL = 'https://studio.kubb.dev' as const
 
-export const CORE_PLUGIN_NAME = 'core' as const
-
-export const DEFAULT_MAX_LISTENERS = 100
-
+/**
+ * Default number of plugins that may run concurrently during a build.
+ */
 export const DEFAULT_CONCURRENCY = 15
 
+/**
+ * File name used for generated barrel (index) files.
+ */
 export const BARREL_FILENAME = 'index.ts' as const
 
+/**
+ * Default banner style written at the top of every generated file.
+ */
 export const DEFAULT_BANNER = 'simple' as const
 
+/**
+ * Default file-extension mapping used when no explicit mapping is configured.
+ */
 export const DEFAULT_EXTENSION: Record<KubbFile.Extname, KubbFile.Extname | ''> = { '.ts': '.ts' }
 
-export const PATH_SEPARATORS = ['/', '\\'] as const
+/**
+ * Characters recognized as path separators on both POSIX and Windows.
+ */
+export const PATH_SEPARATORS = new Set(['/', '\\'] as const)
 
+/**
+ * Numeric log-level thresholds used internally to compare verbosity.
+ *
+ * Higher numbers are more verbose.
+ */
 export const logLevel = {
   silent: Number.NEGATIVE_INFINITY,
   error: 0,
@@ -25,6 +44,13 @@ export const logLevel = {
   debug: 5,
 } as const
 
+/**
+ * CLI command descriptors for each supported linter.
+ *
+ * Each entry contains the executable `command`, an `args` factory that maps an
+ * output path to the correct argument list, and an `errorMessage` shown when
+ * the linter is not found.
+ */
 export const linters = {
   eslint: {
     command: 'eslint',
@@ -43,6 +69,13 @@ export const linters = {
   },
 } as const
 
+/**
+ * CLI command descriptors for each supported code formatter.
+ *
+ * Each entry contains the executable `command`, an `args` factory that maps an
+ * output path to the correct argument list, and an `errorMessage` shown when
+ * the formatter is not found.
+ */
 export const formatters = {
   prettier: {
     command: 'prettier',

package/src/createAdapter.ts

@@ -0,0 +1,25 @@
+import type { Adapter, AdapterFactoryOptions } from './types.ts'
+
+/**
+ * Builder type for an {@link Adapter} — takes options and returns the adapter instance.
+ */
+type AdapterBuilder<T extends AdapterFactoryOptions> = (options: T['options']) => Adapter<T>
+
+/**
+ * Creates an adapter factory. Call the returned function with optional options to get the adapter instance.
+ *
+ * @example
+ * export const myAdapter = createAdapter<MyAdapter>((options) => {
+ *   return {
+ *     name: 'my-adapter',
+ *     options,
+ *     async parse(source) { ... },
+ *   }
+ * })
+ *
+ * // instantiate
+ * const adapter = myAdapter({ validate: true })
+ */
+export function createAdapter<T extends AdapterFactoryOptions = AdapterFactoryOptions>(build: AdapterBuilder<T>): (options?: T['options']) => Adapter<T> {
+  return (options) => build(options ?? ({} as T['options']))
+}

package/src/createPlugin.ts

@@ -0,0 +1,30 @@
+import type { PluginFactoryOptions, UserPluginWithLifeCycle } from './types.ts'
+
+/**
+ * Builder type for a {@link UserPluginWithLifeCycle} — takes options and returns the plugin instance.
+ */
+type PluginBuilder<T extends PluginFactoryOptions = PluginFactoryOptions> = (options: T['options']) => UserPluginWithLifeCycle<T>
+
+/**
+ * Creates a plugin factory. Call the returned function with optional options to get the plugin instance.
+ *
+ * @example
+ * ```ts
+ * export const myPlugin = createPlugin<MyPlugin>((options) => {
+ *   return {
+ *     name: 'my-plugin',
+ *     get options() { return options },
+ *     resolvePath(baseName) { ... },
+ *     resolveName(name, type) { ... },
+ *   }
+ * })
+ *
+ * // instantiate
+ * const plugin = myPlugin({ output: { path: 'src/gen' } })
+ * ```
+ */
+export function createPlugin<T extends PluginFactoryOptions = PluginFactoryOptions>(
+  build: PluginBuilder<T>,
+): (options?: T['options']) => UserPluginWithLifeCycle<T> {
+  return (options) => build(options ?? ({} as T['options']))
+}

package/src/createStorage.ts

@@ -0,0 +1,58 @@
+export type Storage = {
+  /**
+   * Identifier used for logging and debugging (e.g. `'fs'`, `'s3'`).
+   */
+  readonly name: string
+  /**
+   * Returns `true` when an entry for `key` exists in storage.
+   */
+  hasItem(key: string): Promise<boolean>
+  /**
+   * Returns the stored string value, or `null` when `key` does not exist.
+   */
+  getItem(key: string): Promise<string | null>
+  /**
+   * Persists `value` under `key`, creating any required structure.
+   */
+  setItem(key: string, value: string): Promise<void>
+  /**
+   *  Removes the entry for `key`. No-ops when the key does not exist.
+   */
+  removeItem(key: string): Promise<void>
+  /**
+   * Returns all keys, optionally filtered to those starting with `base`.
+   */
+  getKeys(base?: string): Promise<Array<string>>
+  /**
+   * Removes all entries, optionally scoped to those starting with `base`.
+   */
+  clear(base?: string): Promise<void>
+  /**
+   * Optional teardown hook called after the build completes.
+   */
+  dispose?(): Promise<void>
+}
+
+/**
+ * Creates a storage factory. Call the returned function with optional options to get the storage instance.
+ *
+ * @example
+ * export const memoryStorage = createStorage(() => {
+ *   const store = new Map<string, string>()
+ *   return {
+ *     name: 'memory',
+ *     async hasItem(key) { return store.has(key) },
+ *     async getItem(key) { return store.get(key) ?? null },
+ *     async setItem(key, value) { store.set(key, value) },
+ *     async removeItem(key) { store.delete(key) },
+ *     async getKeys(base) {
+ *       const keys = [...store.keys()]
+ *       return base ? keys.filter((k) => k.startsWith(base)) : keys
+ *     },
+ *     async clear(base) { if (!base) store.clear() },
+ *   }
+ * })
+ */
+export function createStorage<TOptions = Record<string, never>>(build: (options: TOptions) => Storage): (options?: TOptions) => Storage {
+  return (options) => build(options ?? ({} as TOptions))
+}