docusaurus-theme-openapi-docs 4.3.3 → 4.3.5

package/lib/index.js

@@ -11,7 +11,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = docusaurusThemeOpenAPI;
 const path_1 = __importDefault(require("path"));
-const NodePolyfillPlugin = require("node-polyfill-webpack-plugin");
 function docusaurusThemeOpenAPI() {
     return {
         name: "docusaurus-theme-openapi",
@@ -36,7 +35,19 @@ function docusaurusThemeOpenAPI() {
             // Avoid conflicts with docusaurus-plugin-sass
             if (sassLoaderRule.length === 0) {
                 return {
-                    plugins: [new NodePolyfillPlugin()],
+                    resolve: {
+                        fallback: {
+                            buffer: require.resolve("buffer/"),
+                            url: require.resolve("url/"),
+                        },
+                    },
+                    plugins: [
+                        new utils.currentBundler.instance.ProvidePlugin({
+                            process: require.resolve("process/browser"),
+                            Buffer: ["buffer", "Buffer"],
+                            URL: ["url", "URL"],
+                        }),
+                    ],
                     module: {
                         rules: [
                             {
@@ -55,7 +66,19 @@ function docusaurusThemeOpenAPI() {
                 };
             }
             return {
-                plugins: [new NodePolyfillPlugin()],
+                resolve: {
+                    fallback: {
+                        buffer: require.resolve("buffer/"),
+                        url: require.resolve("url/"),
+                    },
+                },
+                plugins: [
+                    new utils.currentBundler.instance.ProvidePlugin({
+                        process: require.resolve("process/browser"),
+                        Buffer: ["buffer", "Buffer"],
+                        URL: ["url", "URL"],
+                    }),
+                ],
             };
         },
     };

package/lib/markdown/schema.js

@@ -88,8 +88,8 @@ function getQualifierMessage(schema) {
         }
         qualifierGroups.push(lengthQualifier);
     }
-    if (schema.minimum ||
-        schema.maximum ||
+    if (schema.minimum != null ||
+        schema.maximum != null ||
         typeof schema.exclusiveMinimum === "number" ||
         typeof schema.exclusiveMaximum === "number") {
         let minmaxQualifier = "";
@@ -98,19 +98,19 @@ function getQualifierMessage(schema) {
         if (typeof schema.exclusiveMinimum === "number") {
             minimum = `\`> ${schema.exclusiveMinimum}\``;
         }
-        else if (schema.minimum && !schema.exclusiveMinimum) {
+        else if (schema.minimum != null && !schema.exclusiveMinimum) {
             minimum = `\`>= ${schema.minimum}\``;
         }
-        else if (schema.minimum && schema.exclusiveMinimum === true) {
+        else if (schema.minimum != null && schema.exclusiveMinimum === true) {
             minimum = `\`> ${schema.minimum}\``;
         }
         if (typeof schema.exclusiveMaximum === "number") {
             maximum = `\`< ${schema.exclusiveMaximum}\``;
         }
-        else if (schema.maximum && !schema.exclusiveMaximum) {
+        else if (schema.maximum != null && !schema.exclusiveMaximum) {
             maximum = `\`<= ${schema.maximum}\``;
         }
-        else if (schema.maximum && schema.exclusiveMaximum === true) {
+        else if (schema.maximum != null && schema.exclusiveMaximum === true) {
             maximum = `\`< ${schema.maximum}\``;
         }
         if (minimum && !maximum) {

package/lib/theme/ApiExplorer/ParamOptions/ParamFormItems/ParamArrayFormItem.js

@@ -78,7 +78,8 @@ const FormTextInput_1 = __importDefault(
 const slice_1 = require("@theme/ApiExplorer/ParamOptions/slice");
 const hooks_1 = require("@theme/ApiItem/hooks");
 const react_hook_form_1 = require("react-hook-form");
-function ArrayItem({ param, onChange }) {
+function ArrayItem({ param, onChange, initialValue }) {
+  const [value, setValue] = (0, react_1.useState)(initialValue || "");
   if (param.schema?.items?.type === "boolean") {
     return react_1.default.createElement(FormSelect_1.default, {
       options: ["---", "true", "false"],
@@ -90,7 +91,9 @@ function ArrayItem({ param, onChange }) {
   }
   return react_1.default.createElement(FormTextInput_1.default, {
     placeholder: param.description || param.name,
+    value: value,
     onChange: (e) => {
+      setValue(e.target.value);
       onChange(e.target.value);
     },
   });
@@ -122,6 +125,15 @@ function ParamArrayFormItem({ param }) {
     );
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [items]);
+  (0, react_1.useEffect)(() => {
+    if (param.schema?.example?.length > 0) {
+      const examplesWithIds = param.schema.example.map((item) => ({
+        id: (0, toolkit_1.nanoid)(),
+        value: item.toString(),
+      }));
+      setItems(examplesWithIds);
+    }
+  }, [param.schema.example, param.schema.length]);
   function handleDeleteItem(itemToDelete) {
     return () => {
       const newItems = items.filter((i) => i.id !== itemToDelete.id);
@@ -158,6 +170,7 @@ function ParamArrayFormItem({ param }) {
               react_1.default.createElement(ArrayItem, {
                 param: param,
                 onChange: handleChangeItem(item, onChange),
+                initialValue: item.value,
               }),
               react_1.default.createElement(
                 "button",

package/lib/theme/ApiExplorer/buildPostmanRequest.js

@@ -20,15 +20,79 @@ function setQueryParams(postman, queryParams) {
       if (!param.value) {
         return undefined;
       }
+      // Handle array values
       if (Array.isArray(param.value)) {
+        if (param.style === "spaceDelimited") {
+          return new postman_collection_1.default.QueryParam({
+            key: param.name,
+            value: param.value.join(" "),
+          });
+        } else if (param.style === "pipeDelimited") {
+          return new postman_collection_1.default.QueryParam({
+            key: param.name,
+            value: param.value.join("|"),
+          });
+        } else if (param.explode) {
+          return param.value.map(
+            (val) =>
+              new postman_collection_1.default.QueryParam({
+                key: param.name,
+                value: val,
+              })
+          );
+        } else {
+          return new postman_collection_1.default.QueryParam({
+            key: param.name,
+            value: param.value.join(","),
+          });
+        }
+      }
+      const decodedValue = decodeURI(param.value);
+      const tryJson = () => {
+        try {
+          return JSON.parse(decodedValue);
+        } catch (e) {
+          return false;
+        }
+      };
+      const jsonResult = tryJson();
+      // Handle object values
+      if (jsonResult && typeof jsonResult === "object") {
+        if (param.style === "deepObject") {
+          return Object.entries(jsonResult).map(
+            ([key, val]) =>
+              new postman_collection_1.default.QueryParam({
+                key: `${param.name}[${key}]`,
+                value: val,
+              })
+          );
+        } else if (param.explode) {
+          return Object.entries(jsonResult).map(
+            ([key, val]) =>
+              new postman_collection_1.default.QueryParam({
+                key: key,
+                value: val,
+              })
+          );
+        } else {
+          return new postman_collection_1.default.QueryParam({
+            key: param.name,
+            value: Object.entries(jsonResult)
+              .map(([key, val]) => `${key},${val}`)
+              .join(","),
+          });
+        }
+      }
+      // Handle boolean values
+      if (typeof decodedValue === "boolean") {
         return new postman_collection_1.default.QueryParam({
           key: param.name,
-          value: param.value.join(","),
+          value: decodedValue ? "true" : "false",
         });
       }
       // Parameter allows empty value: "/hello?extended"
       if (param.allowEmptyValue) {
-        if (param.value === "true") {
+        if (decodedValue === "true") {
           return new postman_collection_1.default.QueryParam({
             key: param.name,
             value: null,
@@ -41,16 +105,58 @@ function setQueryParams(postman, queryParams) {
         value: param.value,
       });
     })
+    .flat() // Flatten the array in case of nested arrays from map
     .filter((item) => item !== undefined);
   if (qp.length > 0) {
     postman.addQueryParams(qp);
   }
 }
-function setPathParams(postman, queryParams) {
-  const source = queryParams.map((param) => {
+function setPathParams(postman, pathParams) {
+  // Map through the path parameters
+  const source = pathParams.map((param) => {
+    if (!param.value) {
+      return undefined;
+    }
+    let serializedValue;
+    // Handle different styles
+    if (Array.isArray(param.value)) {
+      if (param.style === "label") {
+        serializedValue = `.${param.value.join(".")}`;
+      } else if (param.style === "matrix") {
+        serializedValue = `;${param.name}=${param.value.join(";")}`;
+      } else {
+        serializedValue = param.value.join(",");
+      }
+      return new postman_collection_1.default.Variable({
+        key: param.name,
+        value: serializedValue,
+      });
+    }
+    const decodedValue = decodeURI(param.value);
+    const tryJson = () => {
+      try {
+        return JSON.parse(decodedValue);
+      } catch (e) {
+        return false;
+      }
+    };
+    const jsonResult = tryJson();
+    if (typeof jsonResult === "object") {
+      if (param.style === "matrix") {
+        serializedValue = Object.entries(jsonResult)
+          .map(([key, val]) => `;${key}=${val}`)
+          .join("");
+      } else {
+        serializedValue = Object.entries(jsonResult)
+          .map(([key, val]) => `${key}=${val}`)
+          .join(",");
+      }
+    } else {
+      serializedValue = decodedValue || `:${param.name}`;
+    }
     return new postman_collection_1.default.Variable({
       key: param.name,
-      value: param.value || `:${param.name}`,
+      value: serializedValue,
     });
   });
   postman.url.variables.assimilate(source, false);
@@ -58,17 +164,49 @@ function setPathParams(postman, queryParams) {
 function buildCookie(cookieParams) {
   const cookies = cookieParams
     .map((param) => {
-      if (param.value && !Array.isArray(param.value)) {
-        return new postman_collection_1.default.Cookie({
-          // TODO: Is this right?
-          path: "",
-          domain: "",
-          key: param.name,
-          value: param.value,
-        });
+      if (param.value) {
+        const decodedValue = decodeURI(param.value);
+        const tryJson = () => {
+          try {
+            return JSON.parse(decodedValue);
+          } catch (e) {
+            return false;
+          }
+        };
+        const jsonResult = tryJson();
+        if (typeof jsonResult === "object") {
+          if (param.style === "form") {
+            // Handle form style
+            if (param.explode) {
+              // Serialize each key-value pair as a separate cookie
+              return Object.entries(jsonResult).map(
+                ([key, val]) =>
+                  new postman_collection_1.default.Cookie({
+                    key: key,
+                    value: val,
+                  })
+              );
+            } else {
+              // Serialize the object as a single cookie with key-value pairs joined by commas
+              return new postman_collection_1.default.Cookie({
+                key: param.name,
+                value: Object.entries(jsonResult)
+                  .map(([key, val]) => `${key},${val}`)
+                  .join(","),
+              });
+            }
+          }
+        } else {
+          // Handle scalar values
+          return new postman_collection_1.default.Cookie({
+            key: param.name,
+            value: param.value,
+          });
+        }
       }
       return undefined;
     })
+    .flat() // Flatten the array in case of nested arrays from map
     .filter((item) => item !== undefined);
   const list = new postman_collection_1.default.CookieList(null, cookies);
   return list.toString();
@@ -82,8 +220,52 @@ function setHeaders(postman, contentType, accept, cookie, headerParams, other) {
     postman.addHeader({ key: "Accept", value: accept });
   }
   headerParams.forEach((param) => {
-    if (param.value && !Array.isArray(param.value)) {
-      postman.addHeader({ key: param.name, value: param.value });
+    if (param.value) {
+      const decodedValue = decodeURI(param.value);
+      const tryJson = () => {
+        try {
+          return JSON.parse(decodedValue);
+        } catch (e) {
+          return false;
+        }
+      };
+      const jsonResult = tryJson();
+      if (Array.isArray(param.value)) {
+        if (param.style === "simple") {
+          if (param.explode) {
+            // Each item in the array is a separate header
+            jsonResult.forEach((val) => {
+              postman.addHeader({ key: param.name, value: val });
+            });
+          } else {
+            // Array values are joined by commas
+            postman.addHeader({
+              key: param.name,
+              value: param.value.join(","),
+            });
+          }
+        }
+      } else if (typeof jsonResult === "object") {
+        if (param.style === "simple") {
+          if (param.explode) {
+            // Each key-value pair in the object is a separate header
+            Object.entries(jsonResult).forEach(([key, val]) => {
+              postman.addHeader({ key: param.name, value: `${key}=${val}` });
+            });
+          } else {
+            // Object is serialized as a single header with key-value pairs joined by commas
+            postman.addHeader({
+              key: param.name,
+              value: Object.entries(jsonResult)
+                .map(([key, val]) => `${key},${val}`)
+                .join(","),
+            });
+          }
+        }
+      } else {
+        // Handle scalar values
+        postman.addHeader({ key: param.name, value: param.value });
+      }
     }
   });
   other.forEach((header) => {

package/lib/theme/ApiItem/index.js

@@ -12,7 +12,6 @@ var __importDefault =
   };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = ApiItem;
-const zlib_1 = __importDefault(require("zlib"));
 const react_1 = __importDefault(require("react"));
 const BrowserOnly_1 = __importDefault(require("@docusaurus/BrowserOnly"));
 const ExecutionEnvironment_1 = __importDefault(
@@ -31,12 +30,22 @@ const CodeBlock_1 = __importDefault(require("@theme/CodeBlock"));
 const Metadata_1 = __importDefault(require("@theme/DocItem/Metadata"));
 const SkeletonLoader_1 = __importDefault(require("@theme/SkeletonLoader"));
 const clsx_1 = __importDefault(require("clsx"));
+const pako_1 = require("pako");
 const react_redux_1 = require("react-redux");
 const store_1 = require("./store");
 let ApiExplorer = (_) => react_1.default.createElement("div", null);
 if (ExecutionEnvironment_1.default.canUseDOM) {
   ApiExplorer = require("@theme/ApiExplorer").default;
 }
+function base64ToUint8Array(base64) {
+  const binary = atob(base64);
+  const len = binary.length;
+  const bytes = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
 // @ts-ignore
 function ApiItem(props) {
   const docHtmlClassName = `docs-doc-id-${props.content.metadata.id}`;
@@ -50,7 +59,7 @@ function ApiItem(props) {
   if (api) {
     try {
       api = JSON.parse(
-        zlib_1.default.inflateSync(Buffer.from(api, "base64")).toString()
+        new TextDecoder().decode((0, pako_1.ungzip)(base64ToUint8Array(api)))
       );
     } catch {}
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "docusaurus-theme-openapi-docs",
   "description": "OpenAPI theme for Docusaurus.",
-  "version": "4.3.3",
+  "version": "4.3.5",
   "license": "MIT",
   "keywords": [
     "openapi",
@@ -33,8 +33,9 @@
     "@types/crypto-js": "^4.1.0",
     "@types/file-saver": "^2.0.5",
     "@types/lodash": "^4.14.176",
+    "@types/pako": "^2.0.3",
     "concurrently": "^5.2.0",
-    "docusaurus-plugin-openapi-docs": "^4.3.3",
+    "docusaurus-plugin-openapi-docs": "^4.3.5",
     "docusaurus-plugin-sass": "^0.2.3",
     "eslint-plugin-prettier": "^5.0.1"
   },
@@ -42,15 +43,17 @@
     "@hookform/error-message": "^2.0.1",
     "@reduxjs/toolkit": "^1.7.1",
     "allof-merge": "^0.6.6",
+    "buffer": "^6.0.3",
     "clsx": "^1.1.1",
     "copy-text-to-clipboard": "^3.1.0",
     "crypto-js": "^4.1.1",
     "file-saver": "^2.0.5",
     "lodash": "^4.17.20",
-    "node-polyfill-webpack-plugin": "^3.0.0",
+    "pako": "^2.1.0",
     "postman-code-generators": "^1.10.1",
     "postman-collection": "^4.4.0",
     "prism-react-renderer": "^2.3.0",
+    "process": "^0.11.10",
     "react-hook-form": "^7.43.8",
     "react-live": "^4.0.0",
     "react-magic-dropzone": "^1.0.1",
@@ -62,7 +65,7 @@
     "sass": "^1.80.4",
     "sass-loader": "^16.0.2",
     "unist-util-visit": "^5.0.0",
-    "webpack": "^5.61.0",
+    "url": "^0.11.1",
     "xml-formatter": "^2.6.1"
   },
   "peerDependencies": {
@@ -75,5 +78,5 @@
   "engines": {
     "node": ">=14"
   },
-  "gitHead": "4ec42960414d640952c235afc3757fd3245fb2d2"
+  "gitHead": "6b5c10430f8ae45faff3a01ca13b485a77d0742a"
 }

package/src/index.ts

@@ -9,8 +9,6 @@ import path from "path";
 
 import type { Plugin } from "@docusaurus/types";
 
-const NodePolyfillPlugin = require("node-polyfill-webpack-plugin");
-
 export default function docusaurusThemeOpenAPI(): Plugin<void> {
   return {
     name: "docusaurus-theme-openapi",
@@ -41,7 +39,19 @@ export default function docusaurusThemeOpenAPI(): Plugin<void> {
       // Avoid conflicts with docusaurus-plugin-sass
       if (sassLoaderRule.length === 0) {
         return {
-          plugins: [new NodePolyfillPlugin()],
+          resolve: {
+            fallback: {
+              buffer: require.resolve("buffer/"),
+              url: require.resolve("url/"),
+            },
+          },
+          plugins: [
+            new utils.currentBundler.instance.ProvidePlugin({
+              process: require.resolve("process/browser"),
+              Buffer: ["buffer", "Buffer"],
+              URL: ["url", "URL"],
+            }),
+          ],
           module: {
             rules: [
               {
@@ -60,7 +70,19 @@ export default function docusaurusThemeOpenAPI(): Plugin<void> {
         };
       }
       return {
-        plugins: [new NodePolyfillPlugin()],
+        resolve: {
+          fallback: {
+            buffer: require.resolve("buffer/"),
+            url: require.resolve("url/"),
+          },
+        },
+        plugins: [
+          new utils.currentBundler.instance.ProvidePlugin({
+            process: require.resolve("process/browser"),
+            Buffer: ["buffer", "Buffer"],
+            URL: ["url", "URL"],
+          }),
+        ],
       };
     },
   };

package/src/markdown/schema.ts

@@ -112,8 +112,8 @@ export function getQualifierMessage(schema?: SchemaObject): string | undefined {
   }
 
   if (
-    schema.minimum ||
-    schema.maximum ||
+    schema.minimum != null ||
+    schema.maximum != null ||
     typeof schema.exclusiveMinimum === "number" ||
     typeof schema.exclusiveMaximum === "number"
   ) {
@@ -122,16 +122,16 @@ export function getQualifierMessage(schema?: SchemaObject): string | undefined {
     let maximum;
     if (typeof schema.exclusiveMinimum === "number") {
       minimum = `\`> ${schema.exclusiveMinimum}\``;
-    } else if (schema.minimum && !schema.exclusiveMinimum) {
+    } else if (schema.minimum != null && !schema.exclusiveMinimum) {
       minimum = `\`>= ${schema.minimum}\``;
-    } else if (schema.minimum && schema.exclusiveMinimum === true) {
+    } else if (schema.minimum != null && schema.exclusiveMinimum === true) {
       minimum = `\`> ${schema.minimum}\``;
     }
     if (typeof schema.exclusiveMaximum === "number") {
       maximum = `\`< ${schema.exclusiveMaximum}\``;
-    } else if (schema.maximum && !schema.exclusiveMaximum) {
+    } else if (schema.maximum != null && !schema.exclusiveMaximum) {
       maximum = `\`<= ${schema.maximum}\``;
-    } else if (schema.maximum && schema.exclusiveMaximum === true) {
+    } else if (schema.maximum != null && schema.exclusiveMaximum === true) {
       maximum = `\`< ${schema.maximum}\``;
     }
 

package/src/theme/ApiExplorer/ParamOptions/ParamFormItems/ParamArrayFormItem.tsx

@@ -22,7 +22,10 @@ export interface ParamProps {
 function ArrayItem({
   param,
   onChange,
-}: ParamProps & { onChange(value?: string): any }) {
+  initialValue,
+}: ParamProps & { onChange(value?: string): any; initialValue?: string }) {
+  const [value, setValue] = useState(initialValue || "");
+
   if (param.schema?.items?.type === "boolean") {
     return (
       <FormSelect
@@ -38,7 +41,9 @@ function ArrayItem({
   return (
     <FormTextInput
       placeholder={param.description || param.name}
+      value={value}
       onChange={(e: React.ChangeEvent<HTMLInputElement>) => {
+        setValue(e.target.value);
         onChange(e.target.value);
       }}
     />
@@ -77,9 +82,21 @@ export default function ParamArrayFormItem({ param }: ParamProps) {
         value: values.length > 0 ? values : undefined,
       })
     );
+
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [items]);
 
+  useEffect(() => {
+    if (param.schema?.example?.length > 0) {
+      const examplesWithIds = param.schema.example.map((item: any) => ({
+        id: nanoid(),
+        value: item.toString(),
+      }));
+
+      setItems(examplesWithIds);
+    }
+  }, [param.schema.example, param.schema.length]);
+
   function handleDeleteItem(itemToDelete: { id: string }) {
     return () => {
       const newItems = items.filter((i) => i.id !== itemToDelete.id);
@@ -113,6 +130,7 @@ export default function ParamArrayFormItem({ param }: ParamProps) {
                 <ArrayItem
                   param={param}
                   onChange={handleChangeItem(item, onChange)}
+                  initialValue={item.value}
                 />
                 <button
                   className="openapi-explorer__delete-btn"

package/src/theme/ApiExplorer/buildPostmanRequest.ts

@@ -27,16 +27,84 @@ function setQueryParams(postman: sdk.Request, queryParams: Param[]) {
         return undefined;
       }
 
+      // Handle array values
       if (Array.isArray(param.value)) {
+        if (param.style === "spaceDelimited") {
+          return new sdk.QueryParam({
+            key: param.name,
+            value: param.value.join(" "),
+          });
+        } else if (param.style === "pipeDelimited") {
+          return new sdk.QueryParam({
+            key: param.name,
+            value: param.value.join("|"),
+          });
+        } else if (param.explode) {
+          return param.value.map(
+            (val) =>
+              new sdk.QueryParam({
+                key: param.name,
+                value: val,
+              })
+          );
+        } else {
+          return new sdk.QueryParam({
+            key: param.name,
+            value: param.value.join(","),
+          });
+        }
+      }
+
+      const decodedValue = decodeURI(param.value);
+      const tryJson = () => {
+        try {
+          return JSON.parse(decodedValue);
+        } catch (e) {
+          return false;
+        }
+      };
+
+      const jsonResult = tryJson();
+
+      // Handle object values
+      if (jsonResult && typeof jsonResult === "object") {
+        if (param.style === "deepObject") {
+          return Object.entries(jsonResult).map(
+            ([key, val]) =>
+              new sdk.QueryParam({
+                key: `${param.name}[${key}]`,
+                value: val,
+              })
+          );
+        } else if (param.explode) {
+          return Object.entries(jsonResult).map(
+            ([key, val]) =>
+              new sdk.QueryParam({
+                key: key,
+                value: val,
+              })
+          );
+        } else {
+          return new sdk.QueryParam({
+            key: param.name,
+            value: Object.entries(jsonResult)
+              .map(([key, val]) => `${key},${val}`)
+              .join(","),
+          });
+        }
+      }
+
+      // Handle boolean values
+      if (typeof decodedValue === "boolean") {
         return new sdk.QueryParam({
           key: param.name,
-          value: param.value.join(","),
+          value: decodedValue ? "true" : "false",
         });
       }
 
       // Parameter allows empty value: "/hello?extended"
       if (param.allowEmptyValue) {
-        if (param.value === "true") {
+        if (decodedValue === "true") {
           return new sdk.QueryParam({
             key: param.name,
             value: null,
@@ -50,38 +118,121 @@ function setQueryParams(postman: sdk.Request, queryParams: Param[]) {
         value: param.value,
       });
     })
-    .filter((item): item is sdk.QueryParam => item !== undefined);
+    .flat() // Flatten the array in case of nested arrays from map
+    .filter((item) => item !== undefined);
 
   if (qp.length > 0) {
     postman.addQueryParams(qp);
   }
 }
 
-function setPathParams(postman: sdk.Request, queryParams: Param[]) {
-  const source = queryParams.map((param) => {
+function setPathParams(postman: sdk.Request, pathParams: Param[]) {
+  // Map through the path parameters
+  const source = pathParams.map((param) => {
+    if (!param.value) {
+      return undefined;
+    }
+
+    let serializedValue;
+
+    // Handle different styles
+    if (Array.isArray(param.value)) {
+      if (param.style === "label") {
+        serializedValue = `.${param.value.join(".")}`;
+      } else if (param.style === "matrix") {
+        serializedValue = `;${param.name}=${param.value.join(";")}`;
+      } else {
+        serializedValue = param.value.join(",");
+      }
+      return new sdk.Variable({
+        key: param.name,
+        value: serializedValue,
+      });
+    }
+
+    const decodedValue = decodeURI(param.value);
+    const tryJson = () => {
+      try {
+        return JSON.parse(decodedValue);
+      } catch (e) {
+        return false;
+      }
+    };
+
+    const jsonResult = tryJson();
+
+    if (typeof jsonResult === "object") {
+      if (param.style === "matrix") {
+        serializedValue = Object.entries(jsonResult)
+          .map(([key, val]) => `;${key}=${val}`)
+          .join("");
+      } else {
+        serializedValue = Object.entries(jsonResult)
+          .map(([key, val]) => `${key}=${val}`)
+          .join(",");
+      }
+    } else {
+      serializedValue = decodedValue || `:${param.name}`;
+    }
+
     return new sdk.Variable({
       key: param.name,
-      value: param.value || `:${param.name}`,
+      value: serializedValue,
     });
   });
+
   postman.url.variables.assimilate(source, false);
 }
 
 function buildCookie(cookieParams: Param[]) {
   const cookies = cookieParams
     .map((param) => {
-      if (param.value && !Array.isArray(param.value)) {
-        return new sdk.Cookie({
-          // TODO: Is this right?
-          path: "",
-          domain: "",
-          key: param.name,
-          value: param.value,
-        });
+      if (param.value) {
+        const decodedValue = decodeURI(param.value as string);
+        const tryJson = () => {
+          try {
+            return JSON.parse(decodedValue);
+          } catch (e) {
+            return false;
+          }
+        };
+
+        const jsonResult = tryJson();
+        if (typeof jsonResult === "object") {
+          if (param.style === "form") {
+            // Handle form style
+            if (param.explode) {
+              // Serialize each key-value pair as a separate cookie
+              return Object.entries(jsonResult).map(
+                ([key, val]) =>
+                  new sdk.Cookie({
+                    key: key,
+                    value: val,
+                  })
+              );
+            } else {
+              // Serialize the object as a single cookie with key-value pairs joined by commas
+              return new sdk.Cookie({
+                key: param.name,
+                value: Object.entries(jsonResult)
+                  .map(([key, val]) => `${key},${val}`)
+                  .join(","),
+              });
+            }
+          }
+        } else {
+          // Handle scalar values
+          return new sdk.Cookie({
+            key: param.name,
+            value: param.value,
+          });
+        }
       }
       return undefined;
     })
-    .filter((item): item is sdk.Cookie => item !== undefined);
+    .flat() // Flatten the array in case of nested arrays from map
+    .filter((item) => item !== undefined);
+
   const list = new sdk.CookieList(null, cookies);
   return list.toString();
 }
@@ -95,15 +246,63 @@ function setHeaders(
   other: { key: string; value: string }[]
 ) {
   postman.headers.clear();
+
   if (contentType) {
     postman.addHeader({ key: "Content-Type", value: contentType });
   }
+
   if (accept) {
     postman.addHeader({ key: "Accept", value: accept });
   }
+
   headerParams.forEach((param) => {
-    if (param.value && !Array.isArray(param.value)) {
-      postman.addHeader({ key: param.name, value: param.value });
+    if (param.value) {
+      const decodedValue = decodeURI(param.value as string);
+      const tryJson = () => {
+        try {
+          return JSON.parse(decodedValue);
+        } catch (e) {
+          return false;
+        }
+      };
+
+      const jsonResult = tryJson();
+      if (Array.isArray(param.value)) {
+        if (param.style === "simple") {
+          if (param.explode) {
+            // Each item in the array is a separate header
+            jsonResult.forEach((val: any) => {
+              postman.addHeader({ key: param.name, value: val });
+            });
+          } else {
+            // Array values are joined by commas
+            postman.addHeader({
+              key: param.name,
+              value: param.value.join(","),
+            });
+          }
+        }
+      } else if (typeof jsonResult === "object") {
+        if (param.style === "simple") {
+          if (param.explode) {
+            // Each key-value pair in the object is a separate header
+            Object.entries(jsonResult).forEach(([key, val]) => {
+              postman.addHeader({ key: param.name, value: `${key}=${val}` });
+            });
+          } else {
+            // Object is serialized as a single header with key-value pairs joined by commas
+            postman.addHeader({
+              key: param.name,
+              value: Object.entries(jsonResult)
+                .map(([key, val]) => `${key},${val}`)
+                .join(","),
+            });
+          }
+        }
+      } else {
+        // Handle scalar values
+        postman.addHeader({ key: param.name, value: param.value });
+      }
     }
   });
 

package/src/theme/ApiItem/index.tsx

@@ -5,8 +5,6 @@
  * LICENSE file in the root directory of this source tree.
  * ========================================================================== */
 
-import zlib from "zlib";
-
 import React from "react";
 
 import BrowserOnly from "@docusaurus/BrowserOnly";
@@ -23,13 +21,16 @@ import type { Props } from "@theme/DocItem";
 import DocItemMetadata from "@theme/DocItem/Metadata";
 import SkeletonLoader from "@theme/SkeletonLoader";
 import clsx from "clsx";
-import { ServerObject } from "docusaurus-plugin-openapi-docs/src/openapi/types";
-import { ParameterObject } from "docusaurus-plugin-openapi-docs/src/openapi/types";
+import {
+  ParameterObject,
+  ServerObject,
+} from "docusaurus-plugin-openapi-docs/src/openapi/types";
 import type { ApiItem as ApiItemType } from "docusaurus-plugin-openapi-docs/src/types";
 import type {
   DocFrontMatter,
   ThemeConfig,
 } from "docusaurus-theme-openapi-docs/src/types";
+import { ungzip } from "pako";
 import { Provider } from "react-redux";
 
 import { createStoreWithoutState, createStoreWithState } from "./store";
@@ -52,6 +53,16 @@ interface SampleFrontMatter extends DocFrontMatter {
   readonly sample?: any;
 }
 
+function base64ToUint8Array(base64: string) {
+  const binary = atob(base64);
+  const len = binary.length;
+  const bytes = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+
 // @ts-ignore
 export default function ApiItem(props: Props): JSX.Element {
   const docHtmlClassName = `docs-doc-id-${props.content.metadata.id}`;
@@ -65,7 +76,7 @@ export default function ApiItem(props: Props): JSX.Element {
   if (api) {
     try {
       api = JSON.parse(
-        zlib.inflateSync(Buffer.from(api as any, "base64") as any).toString()
+        new TextDecoder().decode(ungzip(base64ToUint8Array(api as any)))
       );
     } catch {}
   }