@kubb/plugin-faker 5.1.9 → 5.1.11

package/dist/index.js

@@ -1,5 +1,5 @@
 import { posix } from "node:path";
-import { Diagnostics, Resolver, addGenerator, assertPluginOption, ast, containsCircularRef, createResolver, defineExtension, defineGenerator, setMacros, setResolver } from "kubb/kit";
+import { Diagnostics, Resolver, addGenerator, 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";
@@ -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.
@@ -398,6 +396,12 @@ const NON_INLINABLE_RESPONSE_TYPES = /* @__PURE__ */ new Set([
 function canOverrideSchema(node) {
 	return !NON_OVERRIDABLE_TYPES.has(node.type);
 }
+/**
+* Follows a ref, including alias chains, to the schema it resolves to. Unresolved refs are returned as is.
+*/
+function resolveRefTarget(node) {
+	return node.type === "ref" && node.schema ? resolveRefTarget(node.schema) : node;
+}
 function shouldInlineSingleResponseSchema(schema) {
 	return !NON_INLINABLE_RESPONSE_TYPES.has(schema.type);
 }
@@ -488,7 +492,7 @@ function resolveFakerTypeUsage(node, typeName, canOverride) {
 	return {
 		dataType,
 		returnType,
-		usesTypeName: dataType.includes(typeName) || Boolean(returnType?.includes(typeName))
+		usesTypeName: canOverride && dataType.includes(typeName) || Boolean(returnType?.includes(typeName))
 	};
 }
 //#endregion
@@ -520,7 +524,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 +554,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,
@@ -892,18 +896,22 @@ function parseEnumValue(value) {
 	return value;
 }
 /**
-* Reads the discriminator literal off a variant, or `undefined` when it can't be determined.
+* Reads the discriminator literal off a variant, with whether its property is required, or
+* `undefined` when it can't be determined.
 *
 * A variant carries exactly one discriminator value, so a property resolving to several literals
 * (a `ref` to the enum shared by every branch, say) identifies no branch and narrows nothing.
 */
-function getDiscriminatorValue(member, discriminatorPropertyName) {
+function getDiscriminator(member, discriminatorPropertyName) {
 	for (const property of ast.resolveSchemaProperties({
 		node: member,
 		propertyName: discriminatorPropertyName
 	})) {
 		const values = ast.getSchemaLiteralValues(property.schema);
-		if (values.length === 1) return values[0];
+		if (values.length === 1) return {
+			value: values[0],
+			required: property.required
+		};
 	}
 }
 /**
@@ -975,7 +983,7 @@ const printerFaker = ast.createPrinter((options) => {
 				});
 				if (this.options.schemaName && refName === this.options.schemaName) return this.options.typeName ? `undefined as unknown as ${this.options.typeName}` : "undefined as unknown";
 				const resolvedName = node.ref ? this.options.resolver.name(refName) : refName;
-				if (!this.options.nestedInObject) return `${resolvedName}(data)`;
+				if (!this.options.nestedInObject && canOverrideSchema(resolveRefTarget(node))) return `${resolvedName}(data)`;
 				return `${resolvedName}()`;
 			},
 			enum(node) {
@@ -986,9 +994,10 @@ const printerFaker = ast.createPrinter((options) => {
 				const { discriminatorPropertyName } = node;
 				const baseTypeName = this.options.typeName;
 				return `faker.helpers.arrayElement([${mapSchemaMembers(node, (member) => {
-					const value = discriminatorPropertyName ? getDiscriminatorValue(member, discriminatorPropertyName) : void 0;
-					if (baseTypeName && value !== void 0) {
-						const typeName = `Extract<NonNullable<${baseTypeName}>, { ${JSON.stringify(discriminatorPropertyName)}: ${parseEnumValue(value)} }>`;
+					const discriminator = discriminatorPropertyName ? getDiscriminator(member, discriminatorPropertyName) : void 0;
+					if (baseTypeName && discriminator) {
+						const key = `${JSON.stringify(discriminatorPropertyName)}${discriminator.required ? "" : "?"}`;
+						const typeName = `Extract<NonNullable<${baseTypeName}>, { ${key}: ${parseEnumValue(discriminator.value)} }>`;
 						return printNested(member, {
 							typeName,
 							nestedInObject: true,
@@ -1398,7 +1407,7 @@ var compatibility = {
 };
 //#endregion
 //#region package.json
-var version = "5.1.9";
+var version = "5.1.11";
 //#endregion
 //#region src/resolvers/resolverFaker.ts
 /**
@@ -1466,18 +1475,6 @@ const pluginFaker = defineExtension({
 			path: "mocks",
 			barrel: { type: "named" }
 		}, seed, locale = "en", group, exclude = [], include, override = [], typeMode = "inferred", dateParser = "faker", regexGenerator = "faker", printer, resolver: userResolver, macros: userMacros } = options;
-		assertPluginOption({
-			plugin: pluginFakerName,
-			option: "typeMode",
-			value: typeMode,
-			allowed: ["inferred", "schema"]
-		});
-		assertPluginOption({
-			plugin: pluginFakerName,
-			option: "regexGenerator",
-			value: regexGenerator,
-			allowed: ["faker", "randexp"]
-		});
 		setResolver(userResolver ? Resolver.merge(resolverFaker, userResolver) : resolverFaker);
 		if (userMacros?.length) setMacros(userMacros);
 		addGenerator(fakerGenerator);