@orval/mock 8.32.0 → 8.34.0

package/dist/index.d.mts

@@ -5,14 +5,14 @@ import { ClientMockGeneratorBuilder, ContextSpec, FakerMockOptions, FinalizeMock
  * imports from `msw`, so this only emits `import { faker } from '@faker-js/faker'`
  * (or the locale-scoped variant) plus any operation-specific imports.
  */
-declare const generateFakerImports: GenerateMockImports;
+export declare const generateFakerImports: GenerateMockImports;
 /**
  * Generates the faker-only mock output for a single operation. This reuses
  * the response-factory portion of {@link generateMSW} and strips out the
  * handler and aggregator entries so callers can write a standalone
  * `<file>.faker.ts` with no `msw` dependency.
  */
-declare function generateFaker(generatorVerbOptions: GeneratorVerbOptions, generatorOptions: GeneratorOptions): ClientMockGeneratorBuilder;
+export declare function generateFaker(generatorVerbOptions: GeneratorVerbOptions, generatorOptions: GeneratorOptions): ClientMockGeneratorBuilder;
 interface GenerateFakerForSchemasResult {
   implementation: string;
   imports: GeneratorImport[];
@@ -28,10 +28,10 @@ interface GenerateFakerForSchemasResult {
  * Returns the function bodies plus any `GeneratorImport` references the
  * factories need so the writer can hoist them into the file header.
  */
-declare function generateFakerForSchemas(schemas: GeneratorSchema[], context: ContextSpec, options: GlobalMockOptions): GenerateFakerForSchemasResult;
+export declare function generateFakerForSchemas(schemas: GeneratorSchema[], context: ContextSpec, options: GlobalMockOptions): GenerateFakerForSchemasResult;
 //#endregion
 //#region src/mock-types.d.ts
-declare function buildStrictMockTypeFileHeader(schemaTypeNames: Iterable<string>, kinds?: Readonly<Record<string, StrictMockSchemaKind$1>>): string;
+export declare function buildStrictMockTypeFileHeader(schemaTypeNames: Iterable<string>, kinds?: Readonly<Record<string, StrictMockSchemaKind$1>>): string;
 /**
  * Prepends shared strict-mock helper types and each `{Schema}Mock` alias once at
  * the top of a mock file. Generators pass `strictSchemaTypeNames`; no scraping.
@@ -39,34 +39,34 @@ declare function buildStrictMockTypeFileHeader(schemaTypeNames: Iterable<string>
  * Not idempotent — callers must invoke this exactly once per aggregated mock
  * file (writers and `writeFakerSchemaMocks`), not from import hooks.
  */
-declare function dedupeStrictMockTypeDeclarations(implementation: string, options?: FinalizeMockImplementationOptions): string;
+export declare function dedupeStrictMockTypeDeclarations(implementation: string, options?: FinalizeMockImplementationOptions): string;
 //#endregion
 //#region src/msw/index.d.ts
-declare const generateMSWImports: GenerateMockImports;
-declare function generateMSW(generatorVerbOptions: GeneratorVerbOptions, generatorOptions: GeneratorOptions): ClientMockGeneratorBuilder;
+export declare const generateMSWImports: GenerateMockImports;
+export declare function generateMSW(generatorVerbOptions: GeneratorVerbOptions, generatorOptions: GeneratorOptions): ClientMockGeneratorBuilder;
 //#endregion
 //#region src/index.d.ts
-declare const DEFAULT_MSW_OPTIONS: MswMockOptions;
-declare const DEFAULT_FAKER_OPTIONS: FakerMockOptions;
+export declare const DEFAULT_MSW_OPTIONS: MswMockOptions;
+export declare const DEFAULT_FAKER_OPTIONS: FakerMockOptions;
 /**
  * Returns the default GlobalMockOptions for a given mock type. Used when
  * normalizing user-provided entries in `output.mock.generators` so callers
  * can omit the per-type defaults.
  */
-declare const getDefaultMockOptionsForType: (type: GlobalMockOptions["type"]) => GlobalMockOptions;
+export declare const getDefaultMockOptionsForType: (type: GlobalMockOptions["type"]) => GlobalMockOptions;
 /**
  * Dispatches mock-file imports generation to the appropriate generator based
  * on the `OutputMockType` discriminator on the mock options.
  */
-declare const generateMockImports: GenerateMockImports;
+export declare const generateMockImports: GenerateMockImports;
 /**
  * Dispatches per-operation mock generation to the appropriate generator
  * based on the `OutputMockType` discriminator. Each entry in
  * `output.mock.generators` is dispatched here individually.
  */
-declare function generateMock(generatorVerbOptions: GeneratorVerbOptions, generatorOptions: Omit<GeneratorOptions, 'mock'> & {
+export declare function generateMock(generatorVerbOptions: GeneratorVerbOptions, generatorOptions: Omit<GeneratorOptions, 'mock'> & {
   mock: GlobalMockOptions;
 }): import("@orval/core").ClientMockGeneratorBuilder;
 //#endregion
-export { DEFAULT_FAKER_OPTIONS, DEFAULT_MSW_OPTIONS, type GenerateFakerForSchemasResult, buildStrictMockTypeFileHeader, dedupeStrictMockTypeDeclarations, generateFaker, generateFakerForSchemas, generateFakerImports, generateMSW, generateMSWImports, generateMock, generateMockImports, getDefaultMockOptionsForType };
+export type { GenerateFakerForSchemasResult };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -45,7 +45,7 @@ function isComposedObjectSchema(schema) {
 function getStrictMockTypeDeclaration(typeName, kind = "object", options) {
 	const mockTypeName = getStrictMockTypeName(typeName);
 	if (kind === "alias") return `export type ${mockTypeName} = ${typeName};`;
-	if (kind === "binary") return `export type ${mockTypeName} = ArrayBuffer;`;
+	if (kind === "binary") return `export type ${mockTypeName} = Blob;`;
 	const mappedType = `{\n  [K in keyof Required<NonNullable<${typeName}>>]: NonNullable<Required<NonNullable<${typeName}>>[K]>;\n}`;
 	return `export type ${mockTypeName} = ${options?.schemaNullableAtRoot ? `${mappedType} | null` : mappedType};`;
 }
@@ -316,7 +316,7 @@ const isFakerVersionV9 = (packageJson) => {
 //#region src/faker/constants.ts
 const DEFAULT_FORMAT_MOCK = {
 	bic: "faker.finance.bic()",
-	binary: "new ArrayBuffer(faker.number.int({ min: 1, max: 64 }))",
+	binary: "new Blob([new Uint8Array(faker.number.int({ min: 1, max: 64 }))])",
 	city: "faker.location.city()",
 	country: "faker.location.country()",
 	date: "faker.date.past().toISOString().slice(0, 10)",
@@ -894,7 +894,7 @@ function getMockScalar({ item, imports, mockOptions, operationId, tags, combine,
 		overrided: false,
 		nullWrapped
 	};
-	if (item.format && ALL_FORMAT[item.format]) {
+	if (item.format && Object.hasOwn(ALL_FORMAT, item.format)) {
 		let value = ALL_FORMAT[item.format];
 		if (["date", "date-time"].includes(item.format) && context.output.override.useDates) value = `new Date(${value})`;
 		return {
@@ -1826,23 +1826,20 @@ function generateDefinition(name, route, getResponseMockFunctionNameBase, handle
 	const isTextResponse = isExactlyStringReturnType && hasTextLikeContentType || contentTypesByPreference.some((ct) => isTextLikeContentType(ct));
 	const isSchemaBinary = (r) => r.originalSchema?.format === "binary" || r.originalSchema?.contentMediaType === "application/octet-stream" && !r.originalSchema.contentEncoding;
 	const isBinaryResponse = preferredContentTypeMatch ? responsesByPreference.some((r) => isSchemaBinary(r)) : contentTypesByPreference.some((ct) => isBinaryLikeContentType(ct)) || responsesByPreference.some((r) => isSchemaBinary(r));
-	const binaryRefNames = responsesByPreference.filter((r) => isSchemaBinary(r)).flatMap((r) => r.imports.flatMap((imp) => imp.alias ? [imp.name, imp.alias] : [imp.name]));
 	const isReturnHttpResponse = value && value !== "undefined";
 	const getResponseMockFunctionName = `${getResponseMockFunctionNameBase}${pascal(name)}`;
 	const handlerName = `${handlerNameBase}${pascal(name)}`;
 	const addedSplitMockImplementations = splitMockImplementations.slice(oldSplitMockImplementations.length);
 	splitMockImplementations.push(...addedSplitMockImplementations);
 	const mockImplementations = addedSplitMockImplementations.length > 0 ? `${addedSplitMockImplementations.join("\n\n")}\n\n` : "";
-	const binaryTypeRewriteRegex = new RegExp(String.raw`\b(?:${["Blob", ...binaryRefNames].map((n) => escapeRegExp(n)).join("|")})\b`, "g");
-	const mockReturnType = isBinaryResponse ? returnType.replaceAll(binaryTypeRewriteRegex, "ArrayBuffer") : returnType;
-	const isVoidUnionType = mockReturnType !== "void" && mockReturnType.split("|").some((part) => part.trim() === "void");
+	const isVoidUnionType = returnType !== "void" && returnType.split("|").some((part) => part.trim() === "void");
 	const noContentStatusCode = isVoidUnionType ? assertSafeStatusCode(responses.find((r) => r.value === "void")?.key ?? "204") : void 0;
-	const nonVoidMockReturnType = isVoidUnionType ? mockReturnType.split("|").filter((part) => part.trim() !== "void").join(" | ").trim() : mockReturnType;
+	const nonVoidMockReturnType = isVoidUnionType ? returnType.split("|").filter((part) => part.trim() !== "void").join(" | ").trim() : returnType;
 	const hasJsonContentType = contentTypesByPreference.some((ct) => ct.includes("json") || ct.includes("+json"));
-	const hasStringReturnType = isTypeExactlyString(mockReturnType) || isUnionContainingString(mockReturnType);
+	const hasStringReturnType = isTypeExactlyString(returnType) || isUnionContainingString(returnType);
 	const overrideResponseType = `Partial<Extract<${nonVoidMockReturnType}, object>>`;
 	const shouldPreferJsonResponse = hasJsonContentType && !hasStringReturnType;
-	const needsRuntimeContentTypeSwitch = isTextResponse && hasJsonContentType && hasStringReturnType && mockReturnType !== "string";
+	const needsRuntimeContentTypeSwitch = isTextResponse && hasJsonContentType && hasStringReturnType && returnType !== "string";
 	const mockOptionsFromOverride = override.mock;
 	const strictMock = isStrictMock(mockOptionsFromOverride);
 	const schemaTypeNames = strictMock ? getSchemaTypeNamesFromResponses(responses) : [];
@@ -1890,10 +1887,7 @@ function generateDefinition(name, route, getResponseMockFunctionNameBase, handle
 	if (!isReturnHttpResponse) responseBody = `new HttpResponse(null,
       { status: ${statusCode}
       })`;
-	else if (isBinaryResponse) responseBody = `HttpResponse.arrayBuffer(
-      binaryBody instanceof ArrayBuffer
-        ? binaryBody
-        : new ArrayBuffer(0),
+	else if (isBinaryResponse) responseBody = `new HttpResponse(binaryBody,
       { status: ${statusCode},
         headers: { 'Content-Type': '${jsStringLiteralEscape(binaryContentType)}' }
       })`;
@@ -1920,7 +1914,7 @@ function generateDefinition(name, route, getResponseMockFunctionNameBase, handle
       })`;
 	const infoType = `Parameters<Parameters<typeof http.${verb}>[1]>[0]`;
 	const handlerImplementation = `
-export const ${handlerName} = (overrideResponse?: ${mockReturnType} | ((${infoParam}: ${infoType}) => Promise<${mockReturnType}> | ${mockReturnType}), options?: RequestHandlerOptions) => {
+export const ${handlerName} = (overrideResponse?: ${returnType} | ((${infoParam}: ${infoType}) => Promise<${returnType}> | ${returnType}), options?: RequestHandlerOptions) => {
   return http.${verb}('${route}', async (${infoParam}: ${infoType}) => {${delay === false ? "" : `await delay(${isFunction(delay) ? `(${String(delay)})()` : String(delay)});`}
   ${isReturnHttpResponse ? "" : `if (typeof overrideResponse === 'function') {await overrideResponse(info); }`}
   ${responsePrelude}