@zimic/http 0.4.0-canary.0 → 0.4.0-canary.2

package/README.md

@@ -144,7 +144,7 @@ Check our [getting started guide](https://github.com/zimicjs/zimic/wiki/getting
      type UserListHeaders = Schema['/users']['GET']['request']['headers'];
 
      const headers = new HttpHeaders<UserListHeaders>({
-       authorization: 'Bearer token',
+       authorization: 'Bearer my-token',
      });
 
      type UserListSearchParams = Schema['/users']['GET']['request']['searchParams'];

package/dist/{chunk-IJVT4RDC.mjs → chunk-KVTV4E5K.mjs}

@@ -153,15 +153,6 @@ function isOperation(node) {
   return ts3.isPropertySignature(node) && (ts3.isIdentifier(node.name) || ts3.isStringLiteral(node.name)) && node.type !== void 0 && ts3.isTypeLiteralNode(node.type);
 }
 __name(isOperation, "isOperation");
-function wrapOperationType(type, context) {
-  context.typeImports.http.add("HttpSchema");
-  const httpSchemaMethodWrapper = ts3.factory.createQualifiedName(
-    ts3.factory.createIdentifier("HttpSchema"),
-    ts3.factory.createIdentifier("Method")
-  );
-  return ts3.factory.createTypeReferenceNode(httpSchemaMethodWrapper, [type]);
-}
-__name(wrapOperationType, "wrapOperationType");
 function normalizeOperation(operation, context) {
   if (!isOperation(operation)) {
     return void 0;
@@ -172,7 +163,7 @@ function normalizeOperation(operation, context) {
     operation.modifiers,
     operation.name,
     operation.questionToken,
-    wrapOperationType(newType, context)
+    newType
   );
 }
 __name(normalizeOperation, "normalizeOperation");
@@ -237,7 +228,7 @@ function isRequestHeaders(node) {
 }
 __name(isRequestHeaders, "isRequestHeaders");
 function isNormalizedRequestHeaders(node) {
-  return isRequestMember(node) && node.name.text === "headers" && ts3.isTypeReferenceNode(node.type) && node.type.typeArguments !== void 0 && node.type.typeArguments.length === 1 && ts3.isTypeLiteralNode(node.type.typeArguments[0]);
+  return isRequestMember(node) && node.name.text === "headers" && ts3.isTypeLiteralNode(node.type);
 }
 __name(isNormalizedRequestHeaders, "isNormalizedRequestHeaders");
 function isRequestParameters(node) {
@@ -283,21 +274,15 @@ function removeRedundantNullUnionIfNecessary(type) {
 __name(removeRedundantNullUnionIfNecessary, "removeRedundantNullUnionIfNecessary");
 function wrapFormDataContentType(type, context) {
   context.typeImports.http.add("HttpFormData");
-  context.typeImports.http.add("HttpFormDataSerialized");
   return ts3.factory.createTypeReferenceNode(ts3.factory.createIdentifier("HttpFormData"), [
-    ts3.factory.createTypeReferenceNode(ts3.factory.createIdentifier("HttpFormDataSerialized"), [
-      renameComponentReferences(type, context)
-    ])
+    renameComponentReferences(type, context)
   ]);
 }
 __name(wrapFormDataContentType, "wrapFormDataContentType");
 function wrapURLEncodedContentType(type, context) {
   context.typeImports.http.add("HttpSearchParams");
-  context.typeImports.http.add("HttpSearchParamsSerialized");
   return ts3.factory.createTypeReferenceNode(ts3.factory.createIdentifier("HttpSearchParams"), [
-    ts3.factory.createTypeReferenceNode(ts3.factory.createIdentifier("HttpSearchParamsSerialized"), [
-      renameComponentReferences(type, context)
-    ])
+    renameComponentReferences(type, context)
   ]);
 }
 __name(wrapURLEncodedContentType, "wrapURLEncodedContentType");
@@ -325,16 +310,7 @@ function normalizeRequestBodyMember(requestBodyMember, context, options) {
   };
 }
 __name(normalizeRequestBodyMember, "normalizeRequestBodyMember");
-function wrapHeadersType(type, context) {
-  context.typeImports.http.add("HttpHeadersSerialized");
-  const serializedWrapper = ts3.factory.createIdentifier("HttpHeadersSerialized");
-  return ts3.factory.createTypeReferenceNode(
-    serializedWrapper,
-    ts3.factory.createNodeArray([type])
-  );
-}
-__name(wrapHeadersType, "wrapHeadersType");
-function normalizeHeaders(headers, context) {
+function normalizeHeaders(headers) {
   const newHeaderMembers = headers.members.filter((header) => {
     if (ts3.isIndexSignatureDeclaration(header)) {
       return false;
@@ -347,15 +323,14 @@ function normalizeHeaders(headers, context) {
   if (newHeaderMembers.length === 0) {
     return void 0;
   }
-  const newHeaders = ts3.factory.updateTypeLiteralNode(headers, ts3.factory.createNodeArray(newHeaderMembers));
-  return wrapHeadersType(newHeaders, context);
+  return ts3.factory.updateTypeLiteralNode(headers, ts3.factory.createNodeArray(newHeaderMembers));
 }
 __name(normalizeHeaders, "normalizeHeaders");
-function normalizeRequestHeaders(requestHeader, context) {
+function normalizeRequestHeaders(requestHeader) {
   if (!isRequestHeaders(requestHeader)) {
     return void 0;
   }
-  const newType = normalizeHeaders(requestHeader.type, context);
+  const newType = normalizeHeaders(requestHeader.type);
   if (!newType) {
     return void 0;
   }
@@ -368,17 +343,14 @@ function normalizeRequestHeaders(requestHeader, context) {
   );
 }
 __name(normalizeRequestHeaders, "normalizeRequestHeaders");
-function createHeaderForUnionByContentType(existingHeader, contentTypeName, context) {
-  const existingHeaderMembers = existingHeader ? existingHeader.type.typeArguments[0].members : [];
+function createHeaderForUnionByContentType(existingHeader, contentTypeName) {
+  const existingHeaderMembers = existingHeader?.type.members ?? [];
   const contentTypeIdentifier = ts3.factory.createIdentifier('"content-type"');
   const contentTypeValue = ts3.factory.createLiteralTypeNode(ts3.factory.createStringLiteral(contentTypeName));
-  const newHeaderType = wrapHeadersType(
-    ts3.factory.createTypeLiteralNode([
-      ts3.factory.createPropertySignature(void 0, contentTypeIdentifier, void 0, contentTypeValue),
-      ...existingHeaderMembers
-    ]),
-    context
-  );
+  const newHeaderType = ts3.factory.createTypeLiteralNode([
+    ts3.factory.createPropertySignature(void 0, contentTypeIdentifier, void 0, contentTypeValue),
+    ...existingHeaderMembers
+  ]);
   return ts3.factory.createPropertySignature(
     existingHeader?.modifiers,
     ts3.factory.createIdentifier("headers"),
@@ -395,7 +367,7 @@ function normalizeContentType(contentType, context, options) {
   if (!ts3.isTypeLiteralNode(contentType)) {
     return contentType;
   }
-  const newHeader = contentType.members.map((member) => normalizeRequestHeaders(member, context)).find(isDefined_default);
+  const newHeader = contentType.members.map(normalizeRequestHeaders).find(isDefined_default);
   const newBodyMembers = contentType.members.flatMap((body) => {
     if (isContentPropertySignature(body)) {
       return body.type.members.map((member) => normalizeRequestBodyMember(member, context, { questionToken: bodyQuestionToken })).filter(isDefined_default);
@@ -407,7 +379,7 @@ function normalizeContentType(contentType, context, options) {
     return ts3.factory.updateTypeLiteralNode(contentType, ts3.factory.createNodeArray(newMembers));
   } else {
     const bodyMemberUnionTypes = newBodyMembers.map((bodyMember) => {
-      const headerMember = createHeaderForUnionByContentType(newHeader, bodyMember.contentTypeName, context);
+      const headerMember = createHeaderForUnionByContentType(newHeader, bodyMember.contentTypeName);
       return ts3.factory.createTypeLiteralNode([headerMember, bodyMember.propertySignature]);
     });
     return ts3.factory.createUnionTypeNode(bodyMemberUnionTypes);
@@ -426,22 +398,12 @@ function normalizeRequest(request, context) {
   return ts3.factory.updatePropertySignature(request, request.modifiers, newIdentifier, void 0, newType);
 }
 __name(normalizeRequest, "normalizeRequest");
-function wrapResponseType(type, context) {
-  context.typeImports.http.add("HttpSchema");
-  const httpSchemaResponseWrapper = ts3.factory.createQualifiedName(
-    ts3.factory.createIdentifier("HttpSchema"),
-    ts3.factory.createIdentifier("Response")
-  );
-  return ts3.factory.createTypeReferenceNode(httpSchemaResponseWrapper, [type]);
-}
-__name(wrapResponseType, "wrapResponseType");
 function normalizeResponseType(responseType, context, options) {
-  const { isComponent: isComponent2, questionToken } = options;
+  const { questionToken } = options;
   if (!ts3.isTypeLiteralNode(responseType)) {
     return responseType;
   }
-  const newType = normalizeContentType(responseType, context, { bodyQuestionToken: questionToken });
-  return isComponent2 ? wrapResponseType(newType, context) : newType;
+  return normalizeContentType(responseType, context, { bodyQuestionToken: questionToken });
 }
 __name(normalizeResponseType, "normalizeResponseType");
 var NON_NUMERIC_RESPONSE_STATUS_TO_MAPPED_TYPE = {
@@ -458,7 +420,6 @@ function normalizeResponse(response, context, options = {}) {
     return void 0;
   }
   const newType = normalizeResponseType(response.type, context, {
-    isComponent: isComponent2,
     questionToken: response.questionToken
   });
   const statusCodeOrComponentName = response.name.text;
@@ -566,15 +527,12 @@ function normalizeRequestQueryWithParameters(requestMember, context) {
   const newIdentifier = ts3.factory.createIdentifier("searchParams");
   const newQuestionToken = void 0;
   const newType = renameComponentReferences(requestMember.type, context);
-  context.typeImports.http.add("HttpSearchParamsSerialized");
-  const serializedWrapper = ts3.factory.createIdentifier("HttpSearchParamsSerialized");
-  const wrappedNewType = ts3.factory.createTypeReferenceNode(serializedWrapper, [newType]);
   return ts3.factory.updatePropertySignature(
     requestMember,
     requestMember.modifiers,
     newIdentifier,
     newQuestionToken,
-    wrappedNewType
+    newType
   );
 }
 __name(normalizeRequestQueryWithParameters, "normalizeRequestQueryWithParameters");
@@ -582,15 +540,12 @@ function normalizeRequestHeadersWithParameters(requestMember, context) {
   const newIdentifier = ts3.factory.createIdentifier("headers");
   const newQuestionToken = void 0;
   const newType = renameComponentReferences(requestMember.type, context);
-  context.typeImports.http.add("HttpHeadersSerialized");
-  const serializedWrapper = ts3.factory.createIdentifier("HttpHeadersSerialized");
-  const wrappedNewType = ts3.factory.createTypeReferenceNode(serializedWrapper, [newType]);
   return ts3.factory.updatePropertySignature(
     requestMember,
     requestMember.modifiers,
     newIdentifier,
     newQuestionToken,
-    wrappedNewType
+    newType
   );
 }
 __name(normalizeRequestHeadersWithParameters, "normalizeRequestHeadersWithParameters");
@@ -608,14 +563,9 @@ function normalizeRequestMemberWithParameters(requestMember, context) {
 }
 __name(normalizeRequestMemberWithParameters, "normalizeRequestMemberWithParameters");
 function mergeRequestHeadersMember(headers, otherHeaders) {
-  const headersTypeLiteral = headers.type.typeArguments[0];
-  const otherHeadersTypeLiteral = otherHeaders.type.typeArguments[0];
-  const newType = ts3.factory.updateTypeReferenceNode(
+  const newType = ts3.factory.updateTypeLiteralNode(
     headers.type,
-    headers.type.typeName,
-    ts3.factory.createNodeArray([
-      ts3.factory.createTypeLiteralNode([...otherHeadersTypeLiteral.members, ...headersTypeLiteral.members])
-    ])
+    ts3.factory.createNodeArray([...otherHeaders.type.members, ...headers.type.members])
   );
   return ts3.factory.updatePropertySignature(
     headers,
@@ -752,15 +702,6 @@ function normalizePathNameWithParameters(pathName) {
   return pathName.replace(/{([^}]+)}/g, ":$1");
 }
 __name(normalizePathNameWithParameters, "normalizePathNameWithParameters");
-function wrapComponentPathType(type, context) {
-  context.typeImports.http.add("HttpSchema");
-  const httpSchemaMethodsWrapper = ts3.factory.createQualifiedName(
-    ts3.factory.createIdentifier("HttpSchema"),
-    ts3.factory.createIdentifier("Methods")
-  );
-  return ts3.factory.createTypeReferenceNode(httpSchemaMethodsWrapper, [type]);
-}
-__name(wrapComponentPathType, "wrapComponentPathType");
 function normalizePath(path4, context, options = {}) {
   const { isComponent: isComponent2 = false } = options;
   if (!isPath(path4)) {
@@ -778,13 +719,7 @@ function normalizePath(path4, context, options = {}) {
   } else {
     newType = renameComponentReferences(path4.type, context);
   }
-  return ts3.factory.updatePropertySignature(
-    path4,
-    path4.modifiers,
-    newIdentifier,
-    path4.questionToken,
-    isComponent2 ? wrapComponentPathType(newType, context) : newType
-  );
+  return ts3.factory.updatePropertySignature(path4, path4.modifiers, newIdentifier, path4.questionToken, newType);
 }
 __name(normalizePath, "normalizePath");
 function wrapPathsType(type, context) {
@@ -956,15 +891,6 @@ function processPendingRequestComponentActions(component, context) {
   return { bodyQuestionToken };
 }
 __name(processPendingRequestComponentActions, "processPendingRequestComponentActions");
-function wrapRequestComponentType(type, context) {
-  context.typeImports.http.add("HttpSchema");
-  const httpSchemaRequestWrapper = ts3.factory.createQualifiedName(
-    ts3.factory.createIdentifier("HttpSchema"),
-    ts3.factory.createIdentifier("Request")
-  );
-  return ts3.factory.createTypeReferenceNode(httpSchemaRequestWrapper, [type]);
-}
-__name(wrapRequestComponentType, "wrapRequestComponentType");
 function normalizeRequestComponent(component, context) {
   if (!isRequestComponent(component)) {
     return void 0;
@@ -976,7 +902,7 @@ function normalizeRequestComponent(component, context) {
     component.modifiers,
     component.name,
     component.questionToken,
-    wrapRequestComponentType(newType, context)
+    newType
   );
 }
 __name(normalizeRequestComponent, "normalizeRequestComponent");
@@ -1403,5 +1329,5 @@ var generate_default = generateTypesFromOpenAPI;
  * The root import module is defined at build time. The fallback is not expected to be used. */
 
 export { __name, generate_default, logger };
-//# sourceMappingURL=chunk-IJVT4RDC.mjs.map
-//# sourceMappingURL=chunk-IJVT4RDC.mjs.map
+//# sourceMappingURL=chunk-KVTV4E5K.mjs.map
+//# sourceMappingURL=chunk-KVTV4E5K.mjs.map