@kubb/core 0.11.1 → 0.13.0

package/dist/index.d.ts

@@ -18,11 +18,24 @@ declare class Emitter<TValue = unknown, TTopics = unknown> {
 }
 
 interface EmittedFile {
+    /**
+     *  equal to importee when getting passed through resolveId
+     */
     id: string;
-    source: string | undefined;
-    name: string | undefined;
-    code: string | undefined;
-    meta?: Record<string, any>;
+    /**
+     * The importer is the fully resolved id of the importing module.
+     */
+    importer?: string;
+    /**
+     * Name to be used to dynamicly create the fileName(based on input.path)
+     */
+    name?: string;
+    /**
+     * FileName will be the end result so no input.path will not be added
+     */
+    fileName?: string;
+    source?: string;
+    options?: Record<string, any>;
 }
 type EmitFile = (emittedFile: EmittedFile) => void;
 type Topics = 'new' | 'delete' | 'end';
@@ -38,17 +51,6 @@ declare class FileEmitter {
     getEmittedFile: (fileReferenceId?: string | null) => EmittedFile | undefined;
 }
 
-interface SerializablePluginCache {
-    [key: string]: [number, any];
-}
-interface Cache<TCache = any> {
-    delete(id: string): boolean;
-    get<T = TCache>(id: string): T;
-    has(id: string): boolean;
-    set<T = TCache>(id: string, value: T): void;
-}
-declare function createPluginCache(cache: SerializablePluginCache): Cache;
-
 /**
  * Get the type of the first argument in a function.
  * @example Arg0<(a: string, b: number) => void> -> string
@@ -56,16 +58,16 @@ declare function createPluginCache(cache: SerializablePluginCache): Cache;
 type Argument0<H extends keyof PluginLifecycle> = Parameters<PluginLifecycle[H]>[0];
 declare const hooks: [keyof PluginLifecycle];
 declare class PluginDriver {
-    private readonly pluginContexts;
     plugins: Plugin[];
     readonly fileEmitter: FileEmitter;
     private readonly logger?;
     private readonly config;
-    private readonly sortedPlugins;
-    constructor(config: Api['config'], pluginCache: Record<string, SerializablePluginCache> | undefined, options: {
-        logger: BuildContext['logger'];
+    readonly core: Plugin<CorePluginOptions> & {
+        api: CorePluginOptions['api'];
+    };
+    constructor(config: Api['config'], options: {
+        logger: BuildOptions['logger'];
     });
-    get api(): PluginContext;
     emitFile(...params: Parameters<FileEmitter['emitFile']>): Promise<EmittedFile>;
     resolveId: (source: string, importer: string, meta: Record<string, any> | undefined) => Promise<string | null | undefined>;
     load: (id: string) => Promise<TransformResult>;
@@ -80,7 +82,7 @@ declare class PluginDriver {
      * @param args Arguments passed to the plugin hook.
      * @param plugin The actual pluginObject to run.
      */
-    private runHook;
+    private run;
     /**
      * Run a sync plugin hook and return the result.
      * @param hookName Name of the plugin hook. Must be in `PluginHooks`.
@@ -88,21 +90,20 @@ declare class PluginDriver {
      * @param plugin The acutal plugin
      * @param replaceContext When passed, the plugin context can be overridden.
      */
-    private runHookSync;
+    private runSync;
+}
+
+interface Cache<TCache = any> {
+    delete(id: string): boolean;
+    get<T = TCache>(id: string): T;
+    has(id: string): boolean;
+    set<T = TCache>(id: string, value: T): void;
 }
+declare function createPluginCache(cache: any): Cache;
 
 declare const format: (text: string) => string;
 
-declare const getRelativePath: (from?: string | null, to?: string | null) => string | {
-    (searchValue: string | RegExp, replaceValue: string): string;
-    (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string;
-    (searchValue: {
-        [Symbol.replace](string: string, replaceValue: string): string;
-    }, replaceValue: string): string;
-    (searchValue: {
-        [Symbol.replace](string: string, replacer: (substring: string, ...args: any[]) => string): string;
-    }, replacer: (substring: string, ...args: any[]) => string): string;
-};
+declare const getRelativePath: (from?: string | null, to?: string | null) => string;
 
 type PluginOptions<UserOptions = unknown, Nested extends boolean = false, Api = any> = {
     userOptions: UserOptions;
@@ -110,48 +111,51 @@ type PluginOptions<UserOptions = unknown, Nested extends boolean = false, Api =
     api: Api;
 };
 type Plugin<TOptions extends PluginOptions = PluginOptions> = {
-    name: PluginName | Omit<string, PluginName>;
-    cacheKey?: string;
+    name: string;
     api?: TOptions['api'];
 } & Partial<PluginLifecycle>;
 type PluginFactory<TOptions extends PluginOptions = PluginOptions> = (options: TOptions['userOptions']) => TOptions['nested'] extends true ? Array<Plugin<TOptions>> : Plugin<TOptions>;
 declare function createPlugin<TOptions extends PluginOptions = PluginOptions>(factory: PluginFactory<TOptions>): (userOptions: TOptions['userOptions']) => TOptions["nested"] extends true ? Plugin<TOptions>[] : Plugin<TOptions>;
+type Options = {
+    config: Api['config'];
+    fileEmitter: FileEmitter;
+    resolveId: Api['resolveId'];
+    load: Api['load'];
+};
+type CorePluginOptions = PluginOptions<Options, false, Api>;
 
-interface ConfigEnv {
-    mode: string;
-}
 interface UserConfig {
     /**
      * Project root directory. Can be an absolute path, or a path relative from
      * the location of the config file itself.
      * @default process.cwd()
      */
-    root?: string;
+    root: string;
     mode?: 'single';
-    /**
-     * plugins means it will run context, buildStart, transform and buildEnd based on order of the plugins array
-     * Example of an order(plugin x does not have a buildEnd): [buildStart of plugin x, buildStart of plugin y, transform of plugin x, transform of plugin y, buildEnd of plugin y ]
-     * Default: plugins
-     */
-    lifeCycle?: 'plugins';
-    /**
-     *  Default: fifo
-     */
-    strategy?: 'fifo' | 'lifo';
     input: {
-        schema: string;
+        /**
+         * Path or link to the input file
+         */
+        path: string;
     };
     output: {
+        /**
+         * Path to export folder
+         */
         path: string;
     };
     /**
-     * Array of kubb plugins to use.
+     * Array of Kubb plugins to use.
      */
     plugins?: Plugin[];
+    /**
+     * Log level to report when using the CLI
+     */
     logLevel?: LogLevel;
 }
-type UserConfigFn = (env: ConfigEnv) => WithPromise<UserConfig>;
+type UserConfigFn = (options: BuildOptions) => WithPromise<UserConfig>;
 type UserConfigExport = WithPromise<UserConfig> | UserConfigFn;
+declare const defaultConfig: Partial<UserConfig>;
 /**
  * Type helper to make it easier to use kubb.config.ts
  * accepts a direct {@link UserConfig} object, or a function that returns it.
@@ -159,11 +163,10 @@ type UserConfigExport = WithPromise<UserConfig> | UserConfigFn;
  */
 declare function defineConfig(config: UserConfigExport): UserConfigExport;
 
-type PluginName = string;
 type PluginLifecycle = {
     validate: (this: PluginContext, plugins: Plugin[]) => WithPromise<ValidationResult>;
     buildStart: (this: PluginContext) => WithPromise<void>;
-    resolveId: (this: PluginContext, source: string, importer: string | undefined, meta: Record<string, any> | undefined) => string | null | undefined;
+    resolveId: (this: PluginContext, importee: string, importer?: string, options?: Record<string, any>) => string | null | undefined;
     load: (this: PluginContext, id: string) => WithPromise<TransformResult | null>;
     transform: (this: PluginContext, code: string, id: string) => WithPromise<TransformResult>;
     writeFile: (this: PluginContext, code: string | undefined, id: string) => WithPromise<void>;
@@ -171,25 +174,17 @@ type PluginLifecycle = {
 };
 type PluginLifecycleHooks = keyof PluginLifecycle;
 type Api = {
-    config: UserConfig & {
-        root: string;
-    };
-    schema: Schema;
+    config: UserConfig;
+    cache: Cache;
     emitFile: FileEmitter['emitFile'];
-    resolveId: (source: string, importer?: string, meta?: Record<string, any>) => WithPromise<string | null | undefined>;
+    resolveId: (importee: string, importer?: string, options?: Record<string, any>) => WithPromise<string | null | undefined>;
     load: (id: string) => WithPromise<TransformResult | void>;
-    getEmittedFile: FileEmitter['getEmittedFile'];
-    on: FileEmitter['on'];
-};
-type PluginContext = Api & {
-    cache: Cache;
 };
+type PluginContext = Api;
 type ValidationResult = true | {
     message: string;
 };
 type TransformResult = string | null;
-type Id = string;
-type Schema = string;
 type LogType = 'error' | 'warn' | 'info';
 type LogLevel = LogType | 'silent';
 
@@ -204,16 +199,14 @@ type Spinner = {
     text: string;
     info: (text: string) => Spinner;
 };
-type BuildContext = {
+type BuildOptions = {
+    config: Api['config'];
+    mode: 'development' | 'production';
     logger?: {
         log: (message: string, logLevel: LogLevel) => void;
         spinner?: Spinner;
     };
 };
-declare function build(this: BuildContext, userConfig: UserConfig, env: ConfigEnv): Promise<BuildOutput>;
-
-declare function getPluginContext(this: PluginDriver, plugin: Plugin, pluginCache: Record<string, SerializablePluginCache> | void): {
-    cache: Cache<any>;
-};
+declare function build(options: BuildOptions): Promise<BuildOutput>;
 
-export { Api, Argument0, BuildContext, Cache, ConfigEnv, EmitFile, EmittedFile, Emitter, FileEmitter, Id, Listener, LogLevel, LogType, Plugin, PluginContext, PluginDriver, PluginFactory, PluginLifecycle, PluginLifecycleHooks, PluginName, PluginOptions, Schema, SerializablePluginCache, TransformResult, UserConfig, UserConfigExport, UserConfigFn, ValidationResult, WithPromise, build, createPlugin, createPluginCache, build as default, defineConfig, format, getPluginContext, getRelativePath, hooks, isPromise, write };
+export { Api, Argument0, BuildOptions, Cache, EmitFile, EmittedFile, Emitter, FileEmitter, Listener, LogLevel, LogType, Plugin, PluginContext, PluginDriver, PluginFactory, PluginLifecycle, PluginLifecycleHooks, PluginOptions, TransformResult, UserConfig, UserConfigExport, UserConfigFn, ValidationResult, WithPromise, build, createPlugin, createPluginCache, build as default, defaultConfig, defineConfig, format, getRelativePath, hooks, isPromise, write };

package/dist/index.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var path2 = require('path');
-var fse2 = require('fs-extra');
+var path = require('path');
+var fse = require('fs-extra');
 var prettier = require('prettier');
 
 // src/build.ts
@@ -58,7 +58,7 @@ var FileEmitter = class {
     this.emitter.emit("new", emitedFile);
     return new Promise((resolve) => {
       const subscribe = this.emitter.on("delete", (deletedFile) => {
-        if (deletedFile?.id === emitedFile.id) {
+        if (deletedFile?.id && deletedFile?.id === emitedFile.id) {
           resolve(deletedFile);
           return subscribe();
         }
@@ -93,6 +93,38 @@ var FileEmitter = class {
   };
 };
 
+// src/utils/isPromise.ts
+var isPromise = (result) => {
+  return typeof result?.then === "function";
+};
+var formatOptions = {
+  tabWidth: 2,
+  printWidth: 160,
+  parser: "typescript",
+  singleQuote: true,
+  semi: false,
+  bracketSameLine: false,
+  endOfLine: "auto"
+};
+var format = (text) => {
+  return prettier.format(text, formatOptions);
+};
+
+// src/utils/write.ts
+var write = async (data, path4, options = { format: false }) => {
+  const formattedData = options.format ? format(data) : data;
+  try {
+    await fse.stat(path4);
+    const oldContent = await fse.readFile(path4, { encoding: "utf-8" });
+    if (oldContent?.toString() === formattedData) {
+      return;
+    }
+  } catch (_err) {
+    return fse.outputFile(path4, formattedData);
+  }
+  return fse.outputFile(path4, formattedData);
+};
+
 // src/utils/cache.ts
 function createPluginCache(cache) {
   return {
@@ -118,15 +150,15 @@ function createPluginCache(cache) {
     }
   };
 }
+var getRelativePath = (from, to) => {
+  if (!from || !to) {
+    throw new Error("From and to should be filled in when retrieving the relativePath");
+  }
+  const newPath = path.relative(from, to).replace("../", "").replace(".ts", "").trimEnd();
+  return `./${newPath}`;
+};
 
-// src/context.ts
-function getPluginContext(plugin, pluginCache) {
-  const cacheKey = plugin.cacheKey || plugin.name;
-  const cacheInstance = createPluginCache(pluginCache[cacheKey] || (pluginCache[cacheKey] = /* @__PURE__ */ Object.create(null)));
-  return {
-    cache: cacheInstance
-  };
-}
+// src/plugin.ts
 function createPlugin(factory) {
   return (userOptions) => {
     const plugin = factory(userOptions);
@@ -144,23 +176,31 @@ function createPlugin(factory) {
 var name = "core";
 var definePlugin = createPlugin((options) => {
   const { fileEmitter, resolveId, load } = options;
-  const schema = fse2.readFileSync(path2.resolve(options.config.root, options.config.input.schema), "utf-8");
   const api = {
     get config() {
       return options.config;
     },
-    get schema() {
-      return schema;
+    async emitFile(emittedFile) {
+      const resolvedId = await resolveId(emittedFile.id, emittedFile.importer, emittedFile.options);
+      const id = resolvedId || emittedFile.importer || emittedFile.id;
+      return fileEmitter.emitFile({
+        ...emittedFile,
+        id
+      });
     },
-    on: fileEmitter.on.bind(fileEmitter),
-    getEmittedFile: fileEmitter.getEmittedFile.bind(fileEmitter),
-    emitFile: fileEmitter.emitFile.bind(fileEmitter),
     resolveId,
-    load
+    load,
+    cache: createPluginCache(/* @__PURE__ */ Object.create(null))
   };
   return {
     name,
-    api
+    api,
+    resolveId(importee, importer) {
+      if (!importer) {
+        return null;
+      }
+      return path.resolve(importer, importee);
+    }
   };
 });
 
@@ -176,36 +216,17 @@ var hookNames = {
 };
 var hooks = Object.keys(hookNames);
 var PluginDriver = class {
-  pluginContexts;
   plugins;
-  fileEmitter;
+  fileEmitter = new FileEmitter();
   logger;
   config;
-  sortedPlugins = /* @__PURE__ */ new Map();
-  constructor(config, pluginCache, options) {
+  core;
+  constructor(config, options) {
     this.logger = options.logger;
     this.config = config;
-    this.fileEmitter = new FileEmitter();
     this.emitFile = this.fileEmitter.emitFile.bind(this.fileEmitter);
-    const corePlugin = definePlugin({ config, fileEmitter: this.fileEmitter, load: this.load, resolveId: this.resolveId });
-    this.plugins = [corePlugin, ...config.plugins || []];
-    const coreApi = corePlugin.api;
-    this.pluginContexts = new Map(
-      this.plugins.map((plugin) => {
-        const context = {
-          ...coreApi,
-          ...getPluginContext.call(this, plugin, pluginCache)
-        };
-        return [plugin, context];
-      })
-    );
-  }
-  get api() {
-    let context = {};
-    this.pluginContexts.forEach((value) => {
-      context = { ...context, ...value };
-    });
-    return context;
+    this.core = definePlugin({ config, fileEmitter: this.fileEmitter, load: this.load, resolveId: this.resolveId });
+    this.plugins = [this.core, ...config.plugins || []];
   }
   emitFile(...params) {
     return this.fileEmitter.emitFile(...params);
@@ -225,7 +246,7 @@ var PluginDriver = class {
       promise = promise.then((result) => {
         if (result != null)
           return result;
-        return this.runHook("hookFirst", hookName, parameters, plugin);
+        return this.run("hookFirst", hookName, parameters, plugin);
       });
     }
     return promise;
@@ -236,9 +257,9 @@ var PluginDriver = class {
       if (plugin[hookName]?.sequential) {
         await Promise.all(parallelPromises);
         parallelPromises.length = 0;
-        await this.runHook("hookParallel", hookName, parameters, plugin);
+        await this.run("hookParallel", hookName, parameters, plugin);
       } else {
-        const promise = this.runHook("hookParallel", hookName, parameters, plugin);
+        const promise = this.run("hookParallel", hookName, parameters, plugin);
         parallelPromises.push(promise);
       }
     }
@@ -248,8 +269,8 @@ var PluginDriver = class {
     let promise = Promise.resolve(argument0);
     for (const plugin of this.getSortedPlugins(hookName)) {
       promise = promise.then(
-        (argument02) => this.runHook("hookReduceArg0", hookName, [argument02, ...rest], plugin).then(
-          (result) => reduce.call(this.api, argument02, result, plugin)
+        (argument02) => this.run("hookReduceArg0", hookName, [argument02, ...rest], plugin).then(
+          (result) => reduce.call(this.core.api, argument02, result, plugin)
         )
       );
     }
@@ -258,14 +279,14 @@ var PluginDriver = class {
   hookSeq(hookName, parameters) {
     let promise = Promise.resolve();
     for (const plugin of this.getSortedPlugins(hookName)) {
-      promise = promise.then(() => this.runHook("hookSeq", hookName, parameters, plugin));
+      promise = promise.then(() => this.run("hookSeq", hookName, parameters, plugin));
     }
     return promise.then(noReturn);
   }
   getSortedPlugins(_hookName) {
     return [...this.plugins];
   }
-  runHook(strategy, hookName, parameters, plugin) {
+  run(strategy, hookName, parameters, plugin) {
     const hook = plugin[hookName];
     return Promise.resolve().then(() => {
       if (typeof hook !== "function") {
@@ -275,7 +296,7 @@ var PluginDriver = class {
         this.logger.spinner.text = `[${strategy}] ${hookName}: Excecuting task for plugin ${plugin.name} 
 `;
       }
-      const hookResult = hook.apply(this.api, parameters);
+      const hookResult = hook.apply(this.core.api, parameters);
       if (!hookResult?.then) {
         if (this.config.logLevel === "info" && this.logger?.spinner) {
           this.logger.spinner.succeed(`[${strategy}] ${hookName}: Excecuting task for plugin ${plugin.name} 
@@ -292,10 +313,10 @@ var PluginDriver = class {
       });
     });
   }
-  runHookSync(hookName, parameters, plugin) {
+  runSync(hookName, parameters, plugin) {
     const hook = plugin[hookName];
     try {
-      return hook.apply(this.api, parameters);
+      return hook.apply(this.core.api, parameters);
     } catch (error) {
       return error;
     }
@@ -304,6 +325,14 @@ var PluginDriver = class {
 function noReturn() {
 }
 
+// src/config.ts
+var defaultConfig = {
+  root: process.cwd()
+};
+function defineConfig(config) {
+  return config;
+}
+
 // src/build.ts
 async function transformReducer(previousCode, result, _plugin) {
   if (result === null) {
@@ -312,118 +341,65 @@ async function transformReducer(previousCode, result, _plugin) {
   return result;
 }
 async function buildImplementation(options, done) {
-  const { config } = options;
-  if (config.lifeCycle && config.lifeCycle !== "plugins") {
-    throw new Error("Only lifeCycle plugins possible");
-  }
-  if (config.strategy && config.strategy !== "lifo") {
-    throw new Error("Only strategy fifo possible");
-  }
-  const pluginCache = /* @__PURE__ */ Object.create(null);
-  const pluginDriver = new PluginDriver(config, pluginCache, { logger: this.logger });
+  const { config, logger } = options;
+  const pluginDriver = new PluginDriver(
+    {
+      ...defaultConfig,
+      ...config
+    },
+    { logger }
+  );
+  const input = fse.readFileSync(path.resolve(config.root, config.input.path), "utf-8");
   const validations = await pluginDriver.hookParallel("validate", [pluginDriver.plugins]);
   const validationsWithMessage = validations.filter(Boolean);
   if (validationsWithMessage.some((validation) => typeof validation !== "boolean")) {
     validationsWithMessage.forEach((validation) => {
       if (validation && typeof validation !== "boolean" && validation?.message) {
-        this.logger?.log(validation.message, "warn");
+        logger?.log(validation.message, "warn");
       }
     });
     return;
   }
   pluginDriver.fileEmitter.on("new", async (emittedFile) => {
-    if (!emittedFile?.source) {
+    if (!emittedFile) {
       return;
     }
-    const resolvedId = await pluginDriver.hookFirst("resolveId", [emittedFile.source, path2.resolve(emittedFile.source), emittedFile.meta]);
-    const id = resolvedId || emittedFile.source;
-    let { code } = emittedFile;
+    const { id } = emittedFile;
+    if (!id) {
+      throw new Error("No id could be transformed, please add id to emitFile or use resolveId");
+    }
+    let { source: code } = emittedFile;
     const loadedResult = await pluginDriver.hookFirst("load", [id]);
     if (loadedResult) {
       code = loadedResult;
     }
     if (code) {
-      const result = await pluginDriver.hookReduceArg0("transform", [code, id], transformReducer);
-      await pluginDriver.hookParallel("writeFile", [result, id]);
+      const transformedCode = await pluginDriver.hookReduceArg0("transform", [code, id], transformReducer);
+      await pluginDriver.hookParallel("writeFile", [transformedCode, id]);
       pluginDriver.fileEmitter.delete(emittedFile.id);
     }
   });
   await pluginDriver.hookParallel("buildStart");
   pluginDriver.emitFile({
-    id: path2.resolve(pluginDriver.api.config.root, pluginDriver.api.config.input.schema),
-    source: pluginDriver.api.config.input.schema,
+    id: config.input.path,
     name: void 0,
-    code: pluginDriver.api.schema
+    source: input
   });
   pluginDriver.fileEmitter.on("end", async () => {
     await pluginDriver.hookParallel("buildEnd");
     done();
   });
 }
-function build(userConfig, env) {
-  const config = {
-    ...userConfig,
-    root: userConfig.root || process.cwd()
-  };
-  return new Promise((resolve) => {
-    buildImplementation.call(
-      this,
-      {
-        config,
-        env
-      },
-      resolve
-    );
+function build(options) {
+  return new Promise((resolve, reject) => {
+    try {
+      buildImplementation(options, resolve);
+    } catch (e) {
+      reject(e);
+    }
   });
 }
 
-// src/config.ts
-function defineConfig(config) {
-  return config;
-}
-
-// src/utils/isPromise.ts
-var isPromise = (result) => {
-  return typeof result?.then === "function";
-};
-var formatOptions = {
-  tabWidth: 2,
-  printWidth: 160,
-  parser: "typescript",
-  singleQuote: true,
-  semi: false,
-  bracketSameLine: false,
-  endOfLine: "auto"
-};
-var format = (text) => {
-  return prettier.format(text, formatOptions);
-};
-
-// src/utils/write.ts
-var write = async (data, path4, options = { format: false }) => {
-  const formattedData = options.format ? format(data) : data;
-  try {
-    await fse2.stat(path4);
-    const oldContent = await fse2.readFile(path4, { encoding: "utf-8" });
-    if (oldContent?.toString() === formattedData) {
-      return;
-    }
-  } catch (_err) {
-    return fse2.outputFile(path4, formattedData);
-  }
-  return fse2.outputFile(path4, formattedData);
-};
-var getRelativePath = (from, to) => {
-  if (!from || !to) {
-    throw new Error("From and to should be filled in when retrieving the relativePath");
-  }
-  const newPath = path2.relative(from, to).replace("../", "").replace(".ts", "").trimEnd();
-  if (newPath.startsWith("./") || newPath.startsWith("../")) {
-    return newPath.replace;
-  }
-  return `./${newPath}`;
-};
-
 // src/index.ts
 var src_default = build;
 
@@ -434,9 +410,9 @@ exports.build = build;
 exports.createPlugin = createPlugin;
 exports.createPluginCache = createPluginCache;
 exports.default = src_default;
+exports.defaultConfig = defaultConfig;
 exports.defineConfig = defineConfig;
 exports.format = format;
-exports.getPluginContext = getPluginContext;
 exports.getRelativePath = getRelativePath;
 exports.hooks = hooks;
 exports.isPromise = isPromise;