@kubb/plugin-faker 5.1.7 → 5.1.10

package/dist/index.d.cts

@@ -0,0 +1,304 @@
+import { Exclude, Group, Include, Output, OutputOptions, Override, PluginType, Resolver, ResolverPatch, ast } from "kubb/kit";
+import { KubbReactNode } from "kubb/jsx";
+//#region src/types.d.ts
+/**
+ * Resolver for Faker that provides naming methods for mock functions.
+ *
+ * The top-level `name` and `file` apply the plugin's `create` prefix. Composite
+ * operation naming is grouped into the `param` and `response` namespaces.
+ */
+type ResolverFaker = Resolver & {
+  /**
+   * Naming for operation parameters, keyed by their location.
+   */
+  param: {
+    /**
+     * Resolves the faker function name for an individual parameter.
+     *
+     * @example Individual parameter name
+     * `resolver.param.name(node, param) // -> 'showPetByIdPathPetId'`
+     */
+    name(node: ast.OperationNode, param: ast.ParameterNode): string;
+    /**
+     * Resolves the faker function name for an operation's grouped path parameters.
+     *
+     * @example Grouped path parameters name
+     * `resolver.param.path(node, param) // -> 'createShowPetByIdPath'`
+     */
+    path(node: ast.OperationNode, param: ast.ParameterNode): string;
+    /**
+     * Resolves the faker function name for an operation's grouped query parameters.
+     *
+     * @example Grouped query parameters name
+     * `resolver.param.query(node, param) // -> 'createListPetsQuery'`
+     */
+    query(node: ast.OperationNode, param: ast.ParameterNode): string;
+    /**
+     * Resolves the faker function name for an operation's grouped header parameters.
+     *
+     * @example Grouped header parameters name
+     * `resolver.param.headers(node, param) // -> 'createDeletePetHeaders'`
+     */
+    headers(node: ast.OperationNode, param: ast.ParameterNode): string;
+  };
+  /**
+   * Naming for operation request bodies and responses.
+   */
+  response: {
+    /**
+     * Resolves the faker function name for a response by status code.
+     *
+     * @example Response status name
+     * `resolver.response.status(node, 200) // -> 'listPetsStatus200'`
+     */
+    status(node: ast.OperationNode, statusCode: ast.StatusCode): string;
+    /**
+     * Resolves the faker function name for a request body.
+     *
+     * @example Request body name
+     * `resolver.response.body(node) // -> 'createPetsBody'`
+     */
+    body(node: ast.OperationNode): string;
+    /**
+     * Resolves the faker function name for the response union.
+     *
+     * @example Response union name
+     * `resolver.response.response(node) // -> 'listPetsResponse'`
+     */
+    response(node: ast.OperationNode): string;
+    /**
+     * Resolves the faker function name for the response collection.
+     *
+     * @example Responses collection name
+     * `resolver.response.responses(node) // -> 'listPetsResponses'`
+     */
+    responses(node: ast.OperationNode): string;
+  };
+};
+/**
+ * Where the generated mock factories are written and how they are exported, plus the optional
+ * `group` strategy. The `group` option organizes `output.mode: 'directory'` output into per-tag or per-path subdirectories.
+ *
+ * @default { path: 'mocks', barrel: { type: 'named' } }
+ */
+type Options = OutputOptions & {
+  /**
+   * Skip operations matching at least one entry in the list.
+   */
+  exclude?: Array<Exclude>;
+  /**
+   * Restrict generation to operations matching at least one entry in the list.
+   */
+  include?: Array<Include>;
+  /**
+   * Apply a different options object to operations matching a pattern.
+   */
+  override?: Array<Override<ResolvedOptions>>;
+  /**
+   * Type object factories from generated values and overrides (`'inferred'`) or
+   * from the declared API model (`'schema'`).
+   *
+   * @default 'inferred'
+   */
+  typeMode?: 'inferred' | 'schema';
+  /**
+   * Library used to format string-represented date, time, and datetime fields.
+   * Any library exporting a default function works; Kubb adds the import for you.
+   *
+   * @default 'faker'
+   */
+  dateParser?: 'faker' | 'dayjs' | 'moment' | (string & {});
+  /**
+   * Library used to generate strings that satisfy a regex `pattern` keyword.
+   * - `'faker'` uses `faker.helpers.fromRegExp`. No extra dependency. Faker does not support
+   *   shorthand classes such as `\d`, `\w`, or `\s`; use `'randexp'` for those patterns.
+   * - `'randexp'` uses the `randexp` package. Supports a wider regex grammar.
+   *
+   * @default 'faker'
+   */
+  regexGenerator?: 'faker' | 'randexp';
+  /**
+   * Faker locale code. Switches the named import to `fakerXX` from `@faker-js/faker`
+   * so names, addresses, and phone numbers reflect the target region.
+   *
+   * @default 'en'
+   * @example German
+   * `locale: 'de'`
+   * @example Austrian German
+   * `locale: 'de_AT'`
+   * @see https://fakerjs.dev/api/localization.html
+   */
+  locale?: string;
+  /**
+   * Value passed to `faker.seed(...)`. Set this for deterministic mock output,
+   * which is useful for snapshot tests.
+   */
+  seed?: number | Array<number>;
+  /**
+   * Override the naming of generated factory helpers. Common use: append `Mock` or
+   * `Factory` so helpers do not clash with imported types.
+   */
+  resolver?: ResolverPatch<ResolverFaker>;
+  /**
+   * Macros applied to schema and operation nodes before printing.
+   */
+  macros?: Array<ast.Macro>;
+  /**
+   * Replace the Faker handler for a specific schema type (`'integer'`, `'date'`, ...).
+   * Each handler returns the Faker expression as a string.
+   */
+  printer?: {
+    nodes?: PrinterFakerNodes;
+  };
+};
+type ResolvedOptions = {
+  output: Output;
+  group: Group | null;
+  exclude: NonNullable<Options['exclude']>;
+  include: Options['include'];
+  override: NonNullable<Options['override']>;
+  typeMode: NonNullable<Options['typeMode']>;
+  dateParser: NonNullable<Options['dateParser']>;
+  regexGenerator: NonNullable<Options['regexGenerator']>;
+  seed: NonNullable<Options['seed']> | undefined;
+  locale: Options['locale'];
+  printer: Options['printer'];
+};
+type PluginFaker = PluginType<'plugin-faker', Options, ResolvedOptions, ResolverFaker>;
+declare global {
+  namespace Kubb {
+    interface PluginRegistry {
+      'plugin-faker': PluginFaker;
+    }
+  }
+}
+//#endregion
+//#region src/printers/printerFaker.d.ts
+/**
+ * Partial map of node-type overrides for the Faker printer. Each key is a
+ * `SchemaType` (`'string'`, `'date'`, ...) and each handler returns the
+ * Faker expression for that schema as a string. Use `this.transform` to
+ * recurse into nested schema nodes, `this.base` to reuse the built-in handler,
+ * and `this.options` to read printer options.
+ *
+ * @example Override the integer handler
+ * ```ts
+ * pluginFaker({
+ *   printer: {
+ *     nodes: {
+ *       integer() {
+ *         return 'faker.number.float()'
+ *       },
+ *     },
+ *   },
+ * })
+ * ```
+ */
+type PrinterFakerNodes = ast.PrinterPartial<string, PrinterFakerOptions>;
+/**
+ * Options passed to the Faker printer at instantiation: the parser library
+ * for date strings, the regex generator, and the resolver used to compute
+ * identifiers.
+ */
+type PrinterFakerOptions = {
+  dateParser?: PluginFaker['resolvedOptions']['dateParser'];
+  regexGenerator?: PluginFaker['resolvedOptions']['regexGenerator'];
+  resolver: ResolverFaker;
+  typeName?: string;
+  schemaName?: string;
+  nestedInObject?: boolean;
+  /**
+   * Set while printing the members of a union (`oneOf`). Object properties then index their
+   * type as `(NonNullable<T> & Record<K, unknown>)[K]` instead of `NonNullable<T>[K]`, so a key
+   * carried by only some branches stays valid (a plain index would be a TS2339).
+   */
+  nestedInUnion?: boolean;
+  nodes?: PrinterFakerNodes;
+  /**
+   * Names of schemas that participate in a circular dependency chain.
+   * Properties whose schema transitively references one of these are emitted
+   * as lazy getters so that user overrides via the `data` parameter prevent
+   * the recursive faker call from ever executing (avoiding stack overflow).
+   */
+  cyclicSchemas?: ReadonlySet<string>;
+};
+/**
+ * Factory options for the Faker printer, defining input/output types and configuration.
+ */
+type PrinterFakerFactory = ast.PrinterFactoryOptions<'faker', PrinterFakerOptions, string, string>;
+/**
+ * Creates a Faker printer that generates mock data generation code from schema nodes.
+ * Handles circular references gracefully by emitting memoizing getters for cyclic properties.
+ */
+export declare const printerFaker: (options: PrinterFakerOptions) => ast.Printer<PrinterFakerFactory>;
+//#endregion
+//#region src/components/Faker.d.ts
+type Props = {
+  name: string;
+  typeName: string;
+  node: ast.SchemaNode;
+  printer: ast.Printer<PrinterFakerFactory>;
+  description?: string;
+  canOverride: boolean;
+  typeMode?: PluginFaker['resolvedOptions']['typeMode'];
+};
+export declare function Faker({ node, description, name, typeName, printer, canOverride, typeMode }: Props): KubbReactNode;
+//#endregion
+//#region src/generators/fakerGenerator.d.ts
+/**
+ * Built-in generator for `@kubb/plugin-faker`. Emits one `createX` factory
+ * per schema in the spec plus per-operation request/response factories. Each
+ * factory returns a value matching the corresponding TypeScript type from
+ * `@kubb/plugin-ts`.
+ */
+export declare const fakerGenerator: import("kubb/kit").Generator<PluginFaker, unknown>;
+//#endregion
+//#region src/plugin.d.ts
+/**
+ * Canonical plugin name for `@kubb/plugin-faker`. Used for driver lookups and
+ * cross-plugin dependency references.
+ */
+export declare const pluginFakerName = "plugin-faker";
+/**
+ * Generates one mock-data factory per OpenAPI schema using Faker.js. Call
+ * `createPet()` to get a realistic `Pet` object. Useful for tests, Storybook,
+ * and local development without a running backend.
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from 'kubb/config'
+ * import { pluginTs } from '@kubb/plugin-ts'
+ * import { pluginFaker } from '@kubb/plugin-faker'
+ *
+ * export default defineConfig({
+ *   input: './petStore.yaml',
+ *   output: { path: './src/gen' },
+ *   plugins: [
+ *     pluginTs(),
+ *     pluginFaker({
+ *       output: { path: './mocks' },
+ *       seed: [100],
+ *     }),
+ *   ],
+ * })
+ * ```
+ */
+export declare const pluginFaker: import("kubb/kit").PluginFactory<PluginFaker>;
+//#endregion
+//#region src/resolvers/resolverFaker.d.ts
+/**
+ * Default resolver used by `@kubb/plugin-faker`. Decides the names and file
+ * paths for every generated mock factory. Functions and files are prefixed
+ * with `create` so `Pet` becomes `createPet`.
+ *
+ * @example Resolve a factory name
+ * ```ts
+ * import { resolverFaker } from '@kubb/plugin-faker'
+ *
+ * resolverFaker.name('list pets') // 'createListPets'
+ * ```
+ */
+export declare const resolverFaker: ResolverFaker;
+//#endregion
+export { type PluginFaker, type PrinterFakerFactory, type PrinterFakerNodes, type PrinterFakerOptions, type ResolverFaker, pluginFaker as default };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
 import { Exclude, Group, Include, Output, OutputOptions, Override, PluginType, Resolver, ResolverPatch, ast } from "kubb/kit";
 import { KubbReactNode } from "kubb/jsx";
 //#region src/types.d.ts

package/dist/index.js

@@ -1,9 +1,9 @@
-import "./rolldown-runtime-C0LytTxp.js";
 import { posix } from "node:path";
 import { Diagnostics, Resolver, addGenerator, assertPluginOption, ast, containsCircularRef, createResolver, defineExtension, defineGenerator, setMacros, setResolver } from "kubb/kit";
 import { File, Function, jsxRenderer } from "kubb/jsx";
 import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
 import { buildParams, enumTypeName, pluginTsName } from "@kubb/plugin-ts";
+//#endregion
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -12,12 +12,23 @@ import { buildParams, enumTypeName, pluginTsName } from "@kubb/plugin-ts";
 *
 * When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
 */
-function toCamelOrPascal(text, pascal) {
+function convert(text, pascal) {
 	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
 		if (word.length > 1 && word === word.toUpperCase()) return word;
 		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
 	}).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
+const cache = /* @__PURE__ */ new Map();
+const cacheLimit = 1e4;
+function toCamelOrPascal(text, pascal) {
+	const key = `${pascal ? "P" : "c"}${text}`;
+	const cached = cache.get(key);
+	if (cached !== void 0) return cached;
+	const result = convert(text, pascal);
+	if (cache.size >= cacheLimit) cache.clear();
+	cache.set(key, result);
+	return result;
+}
 /**
 * Converts `text` to camelCase.
 *
@@ -220,29 +231,16 @@ function stringify(value) {
 	return `'${JSON.stringify(trimQuotes(value.toString())).slice(1, -1).replace(/\\"/g, "\"").replace(/'/g, "\\'")}'`;
 }
 /**
-* Escapes characters that are not allowed inside JS string literals, covering quotes, backslashes,
-* and the Unicode line terminators U+2028 and U+2029.
-*
-* @see http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
+* Escapes an `@` at the start of a line, so a multi-line description can't start a new JSDoc tag.
+* Editors render `\@` as `@` in hovers.
 *
 * @example
 * ```ts
-* jsStringEscape('say "hi"\nbye') // 'say \\"hi\\"\\nbye'
+* jsDocEscape('intro\n@example value') // 'intro\n\\@example value'
 * ```
 */
-function jsStringEscape(input) {
-	return `${input}`.replace(/["'\\\n\r\u2028\u2029]/g, (character) => {
-		switch (character) {
-			case "\"":
-			case "'":
-			case "\\": return `\\${character}`;
-			case "\n": return "\\n";
-			case "\r": return "\\r";
-			case "\u2028": return "\\u2028";
-			case "\u2029": return "\\u2029";
-			default: return "";
-		}
-	});
+function jsDocEscape(input) {
+	return `${input}`.replace(/^(\s*)@/gm, "$1\\@");
 }
 /**
 * Converts a pattern string into a `new RegExp(...)` constructor call or a regex literal string.
@@ -520,7 +518,7 @@ function Faker({ node, description, name, typeName, printer, canOverride, typeMo
 			children: /* @__PURE__ */ jsx(Function, {
 				export: true,
 				name,
-				JSDoc: { comments: description ? [`@description ${jsStringEscape(description)}`] : [] },
+				JSDoc: { comments: description ? [`@description ${jsDocEscape(description)}`] : [] },
 				params: canOverride ? paramsSignature : void 0,
 				returnType: returnType ?? void 0,
 				children: `return ${returnExpression}`
@@ -550,7 +548,7 @@ return {
 		children: /* @__PURE__ */ jsx(Function, {
 			export: true,
 			name,
-			JSDoc: { comments: description ? [`@description ${jsStringEscape(description)}`] : [] },
+			JSDoc: { comments: description ? [`@description ${jsDocEscape(description)}`] : [] },
 			generics: typeMode === "schema" ? void 0 : `TData extends Partial<${typeName}> = object`,
 			params: typeMode === "schema" ? `data?: Partial<${typeName}>` : "data?: TData",
 			returnType: typeMode === "schema" ? typeName : void 0,
@@ -1394,11 +1392,11 @@ const fakerGenerator = defineGenerator({
 //#region kubb-extension.json
 var compatibility = {
 	"kubb": ">=5.8.3",
-	"node": ">=22"
+	"node": ">=22.12"
 };
 //#endregion
 //#region package.json
-var version = "5.1.7";
+var version = "5.1.10";
 //#endregion
 //#region src/resolvers/resolverFaker.ts
 /**