@scalar/snippetz 0.7.3 → 0.7.5

package/dist/plugins/fsharp/httpclient/httpclient.js

@@ -1,148 +1,182 @@
-const fsharpHttpclient = {
-  target: "fsharp",
-  client: "httpclient",
-  title: "HttpClient",
-  generate: (request, _) => {
-    if (!request) {
-      return "";
-    }
-    const finalUrl = buildUrlWithQueryString(request.url, request.queryString);
-    let code = "";
-    code += generateHttpRequestMessage(request.method, finalUrl);
-    if (request.headers && request.headers.length > 0) {
-      code += generateHeadersCode(request.headers);
-    }
-    if (request.postData) {
-      code += generatePostDataCode(request.postData);
-    }
-    if (request.cookies && request.cookies.length > 0 && request.url) {
-      code += generateCookiesCode(request.cookies, request.url);
-      code += "let client = new HttpClient(handler)\n";
-    } else {
-      code += "let client = new HttpClient()\n";
-    }
-    code += "let! result = client.SendAsync(httpRequestMessage)\n";
-    return code;
-  }
+/**
+ * F# HttpClient plugin for generating HTTP request code
+ */
+export const fsharpHttpclient = {
+    target: 'fsharp',
+    client: 'httpclient',
+    title: 'HttpClient',
+    generate: (request, _) => {
+        if (!request) {
+            return '';
+        }
+        const finalUrl = buildUrlWithQueryString(request.url, request.queryString);
+        let code = '';
+        // Initialize HttpRequestMessage
+        code += generateHttpRequestMessage(request.method, finalUrl);
+        // Add headers if present
+        if (request.headers && request.headers.length > 0) {
+            code += generateHeadersCode(request.headers);
+        }
+        // Add request body if present
+        if (request.postData) {
+            code += generatePostDataCode(request.postData);
+        }
+        // Configure client with cookies if present
+        if (request.cookies && request.cookies.length > 0 && request.url) {
+            code += generateCookiesCode(request.cookies, request.url);
+            code += 'let client = new HttpClient(handler)\n';
+        }
+        else {
+            code += 'let client = new HttpClient()\n';
+        }
+        // Send the request
+        code += 'let! result = client.SendAsync(httpRequestMessage)\n';
+        return code;
+    },
 };
+/**
+ * Builds a query string from an array of query parameters
+ */
 function buildQueryString(queryParams) {
-  if (!queryParams || queryParams.length === 0) {
-    return "";
-  }
-  const params = queryParams.map((param) => `${param.name}=${param.value}`);
-  return "?" + params.join("&");
+    if (!queryParams || queryParams.length === 0) {
+        return '';
+    }
+    const params = queryParams.map((param) => `${param.name}=${param.value}`);
+    return '?' + params.join('&');
 }
+/**
+ * Combines base URL with query string if present
+ */
 function buildUrlWithQueryString(baseUrl, queryParams) {
-  if (!baseUrl) {
-    return "";
-  }
-  if (!queryParams || queryParams.length === 0) {
-    return baseUrl;
-  }
-  return baseUrl + buildQueryString(queryParams);
+    if (!baseUrl) {
+        return '';
+    }
+    if (!queryParams || queryParams.length === 0) {
+        return baseUrl;
+    }
+    return baseUrl + buildQueryString(queryParams);
 }
+/**
+ * Generates the HttpRequestMessage initialization code
+ */
 function generateHttpRequestMessage(method, url) {
-  return `let httpRequestMessage = new HttpRequestMessage(
+    return `let httpRequestMessage = new HttpRequestMessage(
   HttpMethod("${method}"),
   new Uri("${escapeString(url)}")
-)
-
-`;
+)\n\n`;
 }
+/**
+ * Generates code to add headers to the HttpRequestMessage
+ */
 function generateHeadersCode(headers) {
-  let code = "";
-  for (const header of headers) {
-    code += `httpRequestMessage.Headers.Add("${escapeString(header.name ?? "")}", "${escapeString(header.value ?? "")}")
-`;
-  }
-  code += "\n";
-  return code;
+    let code = '';
+    for (const header of headers) {
+        code += `httpRequestMessage.Headers.Add("${escapeString(header.name ?? '')}", "${escapeString(header.value ?? '')}")\n`;
+    }
+    code += '\n';
+    return code;
 }
+/**
+ * Generates code to configure cookies for the HttpClient
+ */
 function generateCookiesCode(cookies, url) {
-  let code = "let cookieContainer = CookieContainer()\n";
-  for (const cookie of cookies) {
-    code += `cookieContainer.Add(Uri("${escapeString(url)}"), Cookie("${escapeString(cookie.name ?? "")}", "${escapeString(cookie.value ?? "")}"))
-`;
-  }
-  code += "use handler = new HttpClientHandler()\n";
-  code += "handler.CookieContainer <- cookieContainer\n\n";
-  return code;
+    let code = 'let cookieContainer = CookieContainer()\n';
+    for (const cookie of cookies) {
+        code += `cookieContainer.Add(Uri("${escapeString(url)}"), Cookie("${escapeString(cookie.name ?? '')}", "${escapeString(cookie.value ?? '')}"))\n`;
+    }
+    code += 'use handler = new HttpClientHandler()\n';
+    code += 'handler.CookieContainer <- cookieContainer\n\n';
+    return code;
 }
+/**
+ * Generates code to set the request content based on postData
+ */
 function generatePostDataCode(postData) {
-  if (!postData) {
-    return "";
-  }
-  let code = "";
-  switch (postData.mimeType) {
-    case "multipart/form-data":
-      code += generateMultipartFormDataCode(postData);
-      break;
-    case "application/x-www-form-urlencoded":
-      code += generateUrlEncodedFormDataCode(postData);
-      break;
-    case "application/json":
-      code += generateJsonContentCode(postData);
-      break;
-    default:
-      code += generateGenericContentCode(postData, postData.mimeType);
-      break;
-  }
-  code += "httpRequestMessage.Content <- content\n\n";
-  return code;
+    if (!postData) {
+        return '';
+    }
+    let code = '';
+    switch (postData.mimeType) {
+        case 'multipart/form-data':
+            code += generateMultipartFormDataCode(postData);
+            break;
+        case 'application/x-www-form-urlencoded':
+            code += generateUrlEncodedFormDataCode(postData);
+            break;
+        case 'application/json':
+            code += generateJsonContentCode(postData);
+            break;
+        default:
+            code += generateGenericContentCode(postData, postData.mimeType);
+            break;
+    }
+    code += 'httpRequestMessage.Content <- content\n\n';
+    return code;
 }
+/**
+ * Generates code for generic content types
+ */
 function generateGenericContentCode(postData, contentType) {
-  let code = `let content = new StringContent("${escapeString(postData.text ?? "")}", Encoding.UTF8, "${escapeString(contentType ?? "")}")
-`;
-  code += `content.Headers.ContentType <- MediaTypeHeaderValue("${escapeString(contentType ?? "")}")
-`;
-  return code;
+    let code = `let content = new StringContent("${escapeString(postData.text ?? '')}", Encoding.UTF8, "${escapeString(contentType ?? '')}")\n`;
+    code += `content.Headers.ContentType <- MediaTypeHeaderValue("${escapeString(contentType ?? '')}")\n`;
+    return code;
 }
+/**
+ * Generates code for multipart/form-data content
+ */
 function generateMultipartFormDataCode(postData) {
-  let code = "let content = new MultipartFormDataContent()\n";
-  let fileIndex = 0;
-  for (const param of postData.params) {
-    if (param.value === "BINARY") {
-      const escapedFileName = escapeString(param.fileName ?? "");
-      code += `let fileStreamContent_${fileIndex} = new StreamContent(File.OpenRead("${escapedFileName}"))
-`;
-      code += `fileStreamContent_${fileIndex}.Headers.ContentType <- MediaTypeHeaderValue("${escapeString(param.contentType ?? "")}")
-`;
-      code += `content.Add(fileStreamContent_${fileIndex}, "${escapedFileName}", "${escapedFileName}")
-`;
-      fileIndex++;
-    } else {
-      code += `content.Add(new StringContent("${escapeString(param.value ?? "")}"), "${escapeString(param.name ?? "")}")
-`;
+    let code = 'let content = new MultipartFormDataContent()\n';
+    let fileIndex = 0;
+    for (const param of postData.params) {
+        if (param.value === 'BINARY') {
+            const escapedFileName = escapeString(param.fileName ?? '');
+            code += `let fileStreamContent_${fileIndex} = new StreamContent(File.OpenRead("${escapedFileName}"))\n`;
+            code += `fileStreamContent_${fileIndex}.Headers.ContentType <- MediaTypeHeaderValue("${escapeString(param.contentType ?? '')}")\n`;
+            code += `content.Add(fileStreamContent_${fileIndex}, "${escapedFileName}", "${escapedFileName}")\n`;
+            fileIndex++;
+        }
+        else {
+            code += `content.Add(new StringContent("${escapeString(param.value ?? '')}"), "${escapeString(param.name ?? '')}")\n`;
+        }
     }
-  }
-  return code;
+    return code;
 }
+/**
+ * Generates code for JSON content
+ */
 function generateJsonContentCode(postData) {
-  let prettyJson;
-  try {
-    prettyJson = JSON.stringify(JSON.parse(postData.text ?? "{}"), null, 2);
-  } catch {
-    prettyJson = postData.text ?? "{}";
-  }
-  return `let content = new StringContent("""${prettyJson}""", Encoding.UTF8, "application/json")
-`;
+    let prettyJson;
+    try {
+        prettyJson = JSON.stringify(JSON.parse(postData.text ?? '{}'), null, 2);
+    }
+    catch {
+        // If JSON parsing fails, use the raw text as-is
+        prettyJson = postData.text ?? '{}';
+    }
+    return `let content = new StringContent("""${prettyJson}""", Encoding.UTF8, "application/json")\n`;
 }
+/**
+ * Generates code for application/x-www-form-urlencoded content
+ */
 function generateUrlEncodedFormDataCode(postData) {
-  let code = "let formUrlEncodedContentDictionary = new Dictionary<string, string>()\n";
-  for (const param of postData.params) {
-    code += `formUrlEncodedContentDictionary.Add("${escapeString(param.name ?? "")}", "${escapeString(param.value ?? "")}")
-`;
-  }
-  code += "let content = new FormUrlEncodedContent(formUrlEncodedContentDictionary)\n";
-  return code;
+    let code = 'let formUrlEncodedContentDictionary = new Dictionary<string, string>()\n';
+    for (const param of postData.params) {
+        code += `formUrlEncodedContentDictionary.Add("${escapeString(param.name ?? '')}", "${escapeString(param.value ?? '')}")\n`;
+    }
+    code += 'let content = new FormUrlEncodedContent(formUrlEncodedContentDictionary)\n';
+    return code;
 }
+/**
+ * Escapes special characters for F# string literals
+ */
 function escapeString(str) {
-  if (str == null) {
-    return "";
-  }
-  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+    if (str == null) {
+        return '';
+    }
+    return str
+        .replace(/\\/g, '\\\\') // Escape backslashes
+        .replace(/"/g, '\\"') // Escape double quotes
+        .replace(/\n/g, '\\n') // Escape newlines
+        .replace(/\r/g, '\\r') // Escape carriage returns
+        .replace(/\t/g, '\\t'); // Escape tabs
 }
-export {
-  fsharpHttpclient
-};
-//# sourceMappingURL=httpclient.js.map

package/dist/plugins/fsharp/httpclient/index.js

@@ -1,5 +1 @@
-import { fsharpHttpclient } from "./httpclient.js";
-export {
-  fsharpHttpclient
-};
-//# sourceMappingURL=index.js.map
+export { fsharpHttpclient } from './httpclient.js';

package/dist/plugins/go/native/index.js

@@ -1,5 +1 @@
-import { goNative } from "./native.js";
-export {
-  goNative
-};
-//# sourceMappingURL=index.js.map
+export { goNative } from './native.js';

package/dist/plugins/go/native/native.js

@@ -1,14 +1,14 @@
-import { native } from "../../../httpsnippet-lite/targets/go/native/client.js";
-import { convertWithHttpSnippetLite } from "../../../utils/convertWithHttpSnippetLite.js";
-const goNative = {
-  target: "go",
-  client: "native",
-  title: "NewRequest",
-  generate(request) {
-    return convertWithHttpSnippetLite(native, request);
-  }
+import { native } from '../../../httpsnippet-lite/targets/go/native/client.js';
+import { convertWithHttpSnippetLite } from '../../../utils/convertWithHttpSnippetLite.js';
+/**
+ * go/native
+ */
+export const goNative = {
+    target: 'go',
+    client: 'native',
+    title: 'NewRequest',
+    generate(request) {
+        // TODO: Write an own converter
+        return convertWithHttpSnippetLite(native, request);
+    },
 };
-export {
-  goNative
-};
-//# sourceMappingURL=native.js.map

package/dist/plugins/http/http11/http11.js

@@ -1,86 +1,104 @@
-const httpHttp11 = {
-  target: "http",
-  client: "http1.1",
-  title: "HTTP/1.1",
-  generate(request) {
-    const normalizedRequest = {
-      method: "GET",
-      headers: [],
-      queryString: [],
-      ...request
-    };
-    normalizedRequest.method = normalizedRequest.method.toUpperCase();
-    let url;
-    let path;
-    try {
-      url = new URL(normalizedRequest.url || "http://");
-      path = url.pathname + (url.search || "");
-    } catch (_error) {
-      path = normalizedRequest.url || "/";
-    }
-    const hostname = url?.hostname || "UNKNOWN_HOSTNAME";
-    let requestString = `${normalizedRequest.method} ${path} HTTP/1.1\r
-`;
-    if (normalizedRequest.queryString.length) {
-      const queryString = normalizedRequest.queryString.map((param) => `${encodeURIComponent(param.name)}=${encodeURIComponent(param.value)}`).join("&");
-      requestString = `${normalizedRequest.method} ${path}?${queryString} HTTP/1.1\r
-`;
-    }
-    const headers = /* @__PURE__ */ new Map();
-    headers.set("Host", hostname);
-    normalizedRequest.headers.forEach((header) => {
-      if (headers.has(header.name)) {
-        headers.set(header.name, `${headers.get(header.name)}, ${header.value}`);
-      } else {
-        headers.set(header.name, header.value);
-      }
-    });
-    if (normalizedRequest.queryString.length) {
-      const queryString = normalizedRequest.queryString.map((param) => `${encodeURIComponent(param.name)}=${encodeURIComponent(param.value)}`).join("&");
-      requestString = `${normalizedRequest.method} ${path}?${queryString} HTTP/1.1\r
-`;
-    }
-    let body = "";
-    if (normalizedRequest.postData) {
-      if (normalizedRequest.postData.mimeType === "application/json" && normalizedRequest.postData.text) {
-        headers.set("Content-Type", "application/json");
-        body = normalizedRequest.postData.text;
-      } else if (normalizedRequest.postData.mimeType === "application/octet-stream" && normalizedRequest.postData.text) {
-        headers.set("Content-Type", "application/octet-stream");
-        body = normalizedRequest.postData.text;
-      } else if (normalizedRequest.postData.mimeType === "application/x-www-form-urlencoded" && normalizedRequest.postData.params) {
-        const formData = normalizedRequest.postData.params.map((param) => `${encodeURIComponent(param.name)}=${encodeURIComponent(param.value ?? "")}`).join("&");
-        headers.set("Content-Type", "application/x-www-form-urlencoded");
-        body = formData;
-      } else if (normalizedRequest.postData.mimeType === "multipart/form-data" && normalizedRequest.postData.params) {
-        const boundary = "----WebKitFormBoundary7MA4YWxkTrZu0gW";
-        headers.set("Content-Type", `multipart/form-data; boundary=${boundary}`);
-        body = normalizedRequest.postData.params.map((param) => {
-          if (param.fileName) {
-            return `--${boundary}\r
-Content-Disposition: form-data; name="${param.name}"; filename="${param.fileName}"\r
-\r
-`;
-          }
-          return `--${boundary}\r
-Content-Disposition: form-data; name="${param.name}"\r
-\r
-${param.value}\r
-`;
-        }).join("") + `--${boundary}--\r
-`;
-      }
-    }
-    headers.forEach((value, name) => {
-      requestString += `${name}: ${value}\r
-`;
-    });
-    requestString += `\r
-${body}`;
-    return requestString;
-  }
+/**
+ * http/http1.1
+ */
+export const httpHttp11 = {
+    target: 'http',
+    client: 'http1.1',
+    title: 'HTTP/1.1',
+    generate(request) {
+        // Defaults
+        const normalizedRequest = {
+            method: 'GET',
+            headers: [],
+            queryString: [],
+            ...request,
+        };
+        // Normalize method
+        normalizedRequest.method = normalizedRequest.method.toUpperCase();
+        // Parse URL with error handling
+        let url;
+        let path;
+        try {
+            url = new URL(normalizedRequest.url || 'http://');
+            path = url.pathname + (url.search || '');
+        }
+        catch (_error) {
+            // Oops, got an invalid URL, use the provided URL directly.
+            path = normalizedRequest.url || '/';
+        }
+        const hostname = url?.hostname || 'UNKNOWN_HOSTNAME';
+        // Start building the request
+        let requestString = `${normalizedRequest.method} ${path} HTTP/1.1\r\n`;
+        // Handle query string parameters
+        if (normalizedRequest.queryString.length) {
+            const queryString = normalizedRequest.queryString
+                .map((param) => `${encodeURIComponent(param.name)}=${encodeURIComponent(param.value)}`)
+                .join('&');
+            // Append query string to the path
+            requestString = `${normalizedRequest.method} ${path}?${queryString} HTTP/1.1\r\n`;
+        }
+        // Store all headers
+        const headers = new Map();
+        // Host header
+        headers.set('Host', hostname);
+        // Passed headers
+        normalizedRequest.headers.forEach((header) => {
+            if (headers.has(header.name)) {
+                headers.set(header.name, `${headers.get(header.name)}, ${header.value}`);
+            }
+            else {
+                headers.set(header.name, header.value);
+            }
+        });
+        // Query string parameters
+        if (normalizedRequest.queryString.length) {
+            const queryString = normalizedRequest.queryString
+                .map((param) => `${encodeURIComponent(param.name)}=${encodeURIComponent(param.value)}`)
+                .join('&');
+            // Append query string to the path
+            requestString = `${normalizedRequest.method} ${path}?${queryString} HTTP/1.1\r\n`;
+        }
+        // Request body
+        let body = '';
+        if (normalizedRequest.postData) {
+            // Always set the Content-Type header based on postData.mimeType
+            if (normalizedRequest.postData.mimeType === 'application/json' && normalizedRequest.postData.text) {
+                headers.set('Content-Type', 'application/json');
+                body = normalizedRequest.postData.text;
+            }
+            else if (normalizedRequest.postData.mimeType === 'application/octet-stream' &&
+                normalizedRequest.postData.text) {
+                headers.set('Content-Type', 'application/octet-stream');
+                body = normalizedRequest.postData.text;
+            }
+            else if (normalizedRequest.postData.mimeType === 'application/x-www-form-urlencoded' &&
+                normalizedRequest.postData.params) {
+                const formData = normalizedRequest.postData.params
+                    .map((param) => `${encodeURIComponent(param.name)}=${encodeURIComponent(param.value ?? '')}`)
+                    .join('&');
+                headers.set('Content-Type', 'application/x-www-form-urlencoded');
+                body = formData;
+            }
+            else if (normalizedRequest.postData.mimeType === 'multipart/form-data' && normalizedRequest.postData.params) {
+                const boundary = '----WebKitFormBoundary7MA4YWxkTrZu0gW';
+                headers.set('Content-Type', `multipart/form-data; boundary=${boundary}`);
+                body =
+                    normalizedRequest.postData.params
+                        .map((param) => {
+                        if (param.fileName) {
+                            return `--${boundary}\r\nContent-Disposition: form-data; name="${param.name}"; filename="${param.fileName}"\r\n\r\n`;
+                        }
+                        return `--${boundary}\r\nContent-Disposition: form-data; name="${param.name}"\r\n\r\n${param.value}\r\n`;
+                    })
+                        .join('') + `--${boundary}--\r\n`;
+            }
+        }
+        // Add headers to requestString
+        headers.forEach((value, name) => {
+            requestString += `${name}: ${value}\r\n`;
+        });
+        // Add body to requestString
+        requestString += `\r\n${body}`;
+        return requestString;
+    },
 };
-export {
-  httpHttp11
-};
-//# sourceMappingURL=http11.js.map

package/dist/plugins/http/http11/index.js

@@ -1,5 +1 @@
-import { httpHttp11 } from "./http11.js";
-export {
-  httpHttp11
-};
-//# sourceMappingURL=index.js.map
+export { httpHttp11 } from './http11.js';

package/dist/plugins/java/asynchttp/asynchttp.js

@@ -1,14 +1,14 @@
-import { asynchttp } from "../../../httpsnippet-lite/targets/java/asynchttp/client.js";
-import { convertWithHttpSnippetLite } from "../../../utils/convertWithHttpSnippetLite.js";
-const javaAsynchttp = {
-  target: "java",
-  client: "asynchttp",
-  title: "AsyncHttp",
-  generate(request) {
-    return convertWithHttpSnippetLite(asynchttp, request);
-  }
+import { asynchttp } from '../../../httpsnippet-lite/targets/java/asynchttp/client.js';
+import { convertWithHttpSnippetLite } from '../../../utils/convertWithHttpSnippetLite.js';
+/**
+ * java/asynchttp
+ */
+export const javaAsynchttp = {
+    target: 'java',
+    client: 'asynchttp',
+    title: 'AsyncHttp',
+    generate(request) {
+        // TODO: Write an own converter
+        return convertWithHttpSnippetLite(asynchttp, request);
+    },
 };
-export {
-  javaAsynchttp
-};
-//# sourceMappingURL=asynchttp.js.map

package/dist/plugins/java/asynchttp/index.js

@@ -1,5 +1 @@
-import { javaAsynchttp } from "./asynchttp.js";
-export {
-  javaAsynchttp
-};
-//# sourceMappingURL=index.js.map
+export { javaAsynchttp } from './asynchttp.js';

package/dist/plugins/java/nethttp/index.js

@@ -1,5 +1 @@
-import { javaNethttp } from "./nethttp.js";
-export {
-  javaNethttp
-};
-//# sourceMappingURL=index.js.map
+export { javaNethttp } from './nethttp.js';

package/dist/plugins/java/nethttp/nethttp.js

@@ -1,14 +1,14 @@
-import { nethttp } from "../../../httpsnippet-lite/targets/java/nethttp/client.js";
-import { convertWithHttpSnippetLite } from "../../../utils/convertWithHttpSnippetLite.js";
-const javaNethttp = {
-  target: "java",
-  client: "nethttp",
-  title: "java.net.http",
-  generate(request) {
-    return convertWithHttpSnippetLite(nethttp, request);
-  }
+import { nethttp } from '../../../httpsnippet-lite/targets/java/nethttp/client.js';
+import { convertWithHttpSnippetLite } from '../../../utils/convertWithHttpSnippetLite.js';
+/**
+ * java/nethttp
+ */
+export const javaNethttp = {
+    target: 'java',
+    client: 'nethttp',
+    title: 'java.net.http',
+    generate(request) {
+        // TODO: Write an own converter
+        return convertWithHttpSnippetLite(nethttp, request);
+    },
 };
-export {
-  javaNethttp
-};
-//# sourceMappingURL=nethttp.js.map

package/dist/plugins/java/okhttp/index.js

@@ -1,5 +1 @@
-import { javaOkhttp } from "./okhttp.js";
-export {
-  javaOkhttp
-};
-//# sourceMappingURL=index.js.map
+export { javaOkhttp } from './okhttp.js';