@scalar/snippetz 0.7.4 → 0.7.5

package/dist/plugins/python/requests/index.js

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

package/dist/plugins/python/requests/requests.js

@@ -1,13 +1,12 @@
-import { requestsLikeGenerate } from "../../../plugins/python/requestsLike.js";
-const pythonRequests = {
-  target: "python",
-  client: "requests",
-  title: "Requests",
-  generate(request, configuration) {
-    return requestsLikeGenerate("requests", request, configuration);
-  }
+import { requestsLikeGenerate } from '../../../plugins/python/requestsLike.js';
+/**
+ * python/requests
+ */
+export const pythonRequests = {
+    target: 'python',
+    client: 'requests',
+    title: 'Requests',
+    generate(request, configuration) {
+        return requestsLikeGenerate('requests', request, configuration);
+    },
 };
-export {
-  pythonRequests
-};
-//# sourceMappingURL=requests.js.map

package/dist/plugins/python/requestsLike.js

@@ -1,121 +1,137 @@
-import { reduceQueryParams } from "../../libs/http.js";
+import { reduceQueryParams } from '../../libs/http.js';
 const LENGTH_CONSIDERED_AS_SHORT = 40;
+// Function to convert JavaScript boolean and null values to Python equivalents
 function convertToPythonSyntax(str) {
-  const replacements = [
-    ["true", "True"],
-    ["false", "False"],
-    ["null", "None"]
-  ];
-  let result = str;
-  for (const [jsonVal, pythonVal] of replacements) {
-    const patterns = [`(: )${jsonVal}(?=,|\\n)`, `^( +)${jsonVal}(?=,|\\n)`];
-    for (const pattern of patterns) {
-      result = result.replace(new RegExp(pattern, "gm"), `$1${pythonVal}`);
+    const replacements = [
+        ['true', 'True'],
+        ['false', 'False'],
+        ['null', 'None'],
+    ];
+    let result = str;
+    for (const [jsonVal, pythonVal] of replacements) {
+        const patterns = [`(: )${jsonVal}(?=,|\\n)`, `^( +)${jsonVal}(?=,|\\n)`];
+        for (const pattern of patterns) {
+            result = result.replace(new RegExp(pattern, 'gm'), `$1${pythonVal}`);
+        }
     }
-  }
-  return result;
+    return result;
 }
-function requestsLikeGenerate(clientVar, request, configuration) {
-  const normalizedRequest = {
-    url: "https://example.com",
-    method: "get",
-    ...request
-  };
-  const method = normalizedRequest.method.toLowerCase();
-  const options = {};
-  if (normalizedRequest.headers?.length) {
-    options.headers = normalizedRequest.headers.reduce(
-      (acc, header) => {
-        if (!(header.name in acc)) {
-          acc[header.name] = header.value;
+export function requestsLikeGenerate(clientVar, request, configuration) {
+    // Normalize request with defaults
+    const normalizedRequest = {
+        url: 'https://example.com',
+        method: 'get',
+        ...request,
+    };
+    // Normalize method to lowercase for requests library
+    const method = normalizedRequest.method.toLowerCase();
+    // Build options object
+    const options = {};
+    // Add headers if present
+    if (normalizedRequest.headers?.length) {
+        options.headers = normalizedRequest.headers.reduce((acc, header) => {
+            if (!(header.name in acc)) {
+                acc[header.name] = header.value;
+            }
+            return acc;
+        }, {});
+    }
+    // Add query parameters if present
+    if (normalizedRequest.queryString?.length) {
+        options.params = reduceQueryParams(normalizedRequest.queryString);
+    }
+    // Add cookies if present
+    if (normalizedRequest.cookies?.length) {
+        options.cookies = Object.fromEntries(normalizedRequest.cookies.map((c) => [c.name, c.value]));
+    }
+    // Add auth if present
+    if (configuration?.auth?.username && configuration?.auth?.password) {
+        options.auth = [configuration.auth.username, configuration.auth.password];
+    }
+    // Handle request body
+    if (normalizedRequest.postData) {
+        const { mimeType, text, params } = normalizedRequest.postData;
+        if (mimeType === 'application/json' && text) {
+            try {
+                options.json = JSON.parse(text);
+            }
+            catch {
+                options.data = text;
+            }
+        }
+        else if (mimeType === 'application/octet-stream' && text) {
+            options.data = text; // Store raw text, we'll handle the b"..." formatting later
+        }
+        else if (mimeType === 'multipart/form-data' && params) {
+            const files = [];
+            const formData = {};
+            params.forEach((param) => {
+                if (param.fileName !== undefined) {
+                    files.push({ key: param.name, file: `open("${param.fileName}", "rb")` });
+                }
+                else if (param.value !== undefined) {
+                    formData[param.name] = param.value;
+                }
+            });
+            if (Object.keys(files).length) {
+                options.files = files;
+            }
+            if (Object.keys(formData).length) {
+                options.data = formData;
+            }
+        }
+        else if (mimeType === 'application/x-www-form-urlencoded' && params) {
+            options.data = Object.fromEntries(params.map((p) => [p.name, p.value]));
         }
-        return acc;
-      },
-      {}
-    );
-  }
-  if (normalizedRequest.queryString?.length) {
-    options.params = reduceQueryParams(normalizedRequest.queryString);
-  }
-  if (normalizedRequest.cookies?.length) {
-    options.cookies = Object.fromEntries(normalizedRequest.cookies.map((c) => [c.name, c.value]));
-  }
-  if (configuration?.auth?.username && configuration?.auth?.password) {
-    options.auth = [configuration.auth.username, configuration.auth.password];
-  }
-  if (normalizedRequest.postData) {
-    const { mimeType, text, params } = normalizedRequest.postData;
-    if (mimeType === "application/json" && text) {
-      try {
-        options.json = JSON.parse(text);
-      } catch {
-        options.data = text;
-      }
-    } else if (mimeType === "application/octet-stream" && text) {
-      options.data = text;
-    } else if (mimeType === "multipart/form-data" && params) {
-      const files = [];
-      const formData = {};
-      params.forEach((param) => {
-        if (param.fileName !== void 0) {
-          files.push({ key: param.name, file: `open("${param.fileName}", "rb")` });
-        } else if (param.value !== void 0) {
-          formData[param.name] = param.value;
+    }
+    // Format all parameters
+    const formattedParams = [];
+    // Format URL based on length
+    const urlParam = `"${normalizedRequest.url}"`;
+    if (normalizedRequest.url.length > LENGTH_CONSIDERED_AS_SHORT) {
+        formattedParams.push(urlParam);
+    }
+    else {
+        // Will be handled in the return statement for short URLs
+        formattedParams.push('');
+    }
+    // Format options
+    for (const [key, value] of Object.entries(options)) {
+        if (key === 'auth') {
+            formattedParams.push(`${key}=(${convertToPythonSyntax(JSON.stringify(value[0]))}, ${convertToPythonSyntax(JSON.stringify(value[1]))})`);
+        }
+        else if (key === 'files') {
+            const filesTuples = value.map(({ key, file }) => `      ("${key}", ${file})`);
+            const filesStr = '[\n' + filesTuples.join(',\n') + '\n    ]';
+            formattedParams.push(`${key}=${filesStr}`);
         }
-      });
-      if (Object.keys(files).length) {
-        options.files = files;
-      }
-      if (Object.keys(formData).length) {
-        options.data = formData;
-      }
-    } else if (mimeType === "application/x-www-form-urlencoded" && params) {
-      options.data = Object.fromEntries(params.map((p) => [p.name, p.value]));
+        else if (key === 'json') {
+            const jsonString = convertToPythonSyntax(JSON.stringify(value, null, 2)
+                .split('\n')
+                .map((line, i) => (i === 0 ? line : '    ' + line))
+                .join('\n'));
+            formattedParams.push(`${key}=${jsonString}`);
+        }
+        else if (key === 'data' && normalizedRequest.postData?.mimeType === 'application/octet-stream') {
+            // Special handling for binary data
+            formattedParams.push(`${key}=b"${value}"`);
+        }
+        else {
+            const str = convertToPythonSyntax(JSON.stringify(value, null, 2)
+                .split('\n')
+                .map((line, i) => (i === 0 ? line : '    ' + line))
+                .join('\n'));
+            formattedParams.push(`${key}=${str}`);
+        }
+    }
+    // Build the final request string with conditional URL formatting
+    if (normalizedRequest.url.length > LENGTH_CONSIDERED_AS_SHORT) {
+        return `${clientVar}.${method}(\n    ${formattedParams.join(',\n    ')}\n)`;
     }
-  }
-  const formattedParams = [];
-  const urlParam = `"${normalizedRequest.url}"`;
-  if (normalizedRequest.url.length > LENGTH_CONSIDERED_AS_SHORT) {
-    formattedParams.push(urlParam);
-  } else {
-    formattedParams.push("");
-  }
-  for (const [key, value] of Object.entries(options)) {
-    if (key === "auth") {
-      formattedParams.push(
-        `${key}=(${convertToPythonSyntax(JSON.stringify(value[0]))}, ${convertToPythonSyntax(JSON.stringify(value[1]))})`
-      );
-    } else if (key === "files") {
-      const filesTuples = value.map(({ key: key2, file }) => `      ("${key2}", ${file})`);
-      const filesStr = "[\n" + filesTuples.join(",\n") + "\n    ]";
-      formattedParams.push(`${key}=${filesStr}`);
-    } else if (key === "json") {
-      const jsonString = convertToPythonSyntax(
-        JSON.stringify(value, null, 2).split("\n").map((line, i) => i === 0 ? line : "    " + line).join("\n")
-      );
-      formattedParams.push(`${key}=${jsonString}`);
-    } else if (key === "data" && normalizedRequest.postData?.mimeType === "application/octet-stream") {
-      formattedParams.push(`${key}=b"${value}"`);
-    } else {
-      const str = convertToPythonSyntax(
-        JSON.stringify(value, null, 2).split("\n").map((line, i) => i === 0 ? line : "    " + line).join("\n")
-      );
-      formattedParams.push(`${key}=${str}`);
+    // For short URLs with no additional parameters, return a single-line format
+    if (formattedParams.length <= 1) {
+        return `${clientVar}.${method}(${urlParam})`;
     }
-  }
-  if (normalizedRequest.url.length > LENGTH_CONSIDERED_AS_SHORT) {
-    return `${clientVar}.${method}(
-    ${formattedParams.join(",\n    ")}
-)`;
-  }
-  if (formattedParams.length <= 1) {
-    return `${clientVar}.${method}(${urlParam})`;
-  }
-  return `${clientVar}.${method}(${urlParam}${formattedParams.length > 1 ? "," : ""}
-    ${formattedParams.slice(1).join(",\n    ")}
-)`;
+    // For short URLs with parameters, maintain the multi-line format
+    return `${clientVar}.${method}(${urlParam}${formattedParams.length > 1 ? ',' : ''}\n    ${formattedParams.slice(1).join(',\n    ')}\n)`;
 }
-export {
-  requestsLikeGenerate
-};
-//# sourceMappingURL=requestsLike.js.map

package/dist/plugins/r/httr/httr.js

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

package/dist/plugins/r/httr/index.js

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

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

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

package/dist/plugins/ruby/native/native.js

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

package/dist/plugins/rust/reqwest/index.js

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

package/dist/plugins/rust/reqwest/reqwest.js

@@ -1,96 +1,123 @@
-import { buildQueryString, buildUrl, normalizeRequest, processHeaders } from "../../../libs/http.js";
-import { createChain, formatJson, indent, wrapInDoubleQuotes } from "../../../libs/rust.js";
-const rustReqwest = {
-  target: "rust",
-  client: "reqwest",
-  title: "reqwest",
-  generate(request, options) {
-    if (!request) {
-      return "";
-    }
-    const normalizedRequest = normalizeRequest(request);
-    const queryString = buildQueryString(normalizedRequest.queryString);
-    const url = buildUrl(normalizedRequest.url || "", queryString);
-    const headers = processHeaders(normalizedRequest);
-    const chainedCalls = [];
-    const authCall = createAuthCall(options?.auth);
-    if (authCall) {
-      chainedCalls.push(authCall);
-    }
-    chainedCalls.push(...createHeaderCalls(headers));
-    const bodyCall = createBodyCall(normalizedRequest.postData);
-    if (bodyCall) {
-      chainedCalls.push(bodyCall);
-    }
-    return buildRustCode(url, normalizedRequest.method, chainedCalls);
-  }
+import { buildQueryString, buildUrl, normalizeRequest, processHeaders } from '../../../libs/http.js';
+import { createChain, formatJson, indent, wrapInDoubleQuotes } from '../../../libs/rust.js';
+/**
+ * rust/reqwest plugin for generating Rust reqwest HTTP client code
+ */
+export const rustReqwest = {
+    target: 'rust',
+    client: 'reqwest',
+    title: 'reqwest',
+    generate(request, options) {
+        if (!request) {
+            return '';
+        }
+        // Normalization
+        const normalizedRequest = normalizeRequest(request);
+        // Query string
+        const queryString = buildQueryString(normalizedRequest.queryString);
+        const url = buildUrl(normalizedRequest.url || '', queryString);
+        // Headers and cookies
+        const headers = processHeaders(normalizedRequest);
+        // Chained calls
+        const chainedCalls = [];
+        // Auth
+        const authCall = createAuthCall(options?.auth);
+        if (authCall) {
+            chainedCalls.push(authCall);
+        }
+        // Headers
+        chainedCalls.push(...createHeaderCalls(headers));
+        // Body
+        const bodyCall = createBodyCall(normalizedRequest.postData);
+        if (bodyCall) {
+            chainedCalls.push(bodyCall);
+        }
+        // Code
+        return buildRustCode(url, normalizedRequest.method, chainedCalls);
+    },
 };
+/**
+ * Helper function to create multipart form parts with proper indentation
+ */
 const createMultipartPart = (param) => {
-  if (param.fileName) {
-    return [
-      indent(2, `let part = reqwest::multipart::Part::text(${wrapInDoubleQuotes(param.value || "")})`),
-      indent(3, `.file_name(${wrapInDoubleQuotes(param.fileName)});`),
-      indent(2, `form = form.part(${wrapInDoubleQuotes(param.name)}, part);`)
-    ].join("\n");
-  }
-  return indent(2, `form = form.text(${wrapInDoubleQuotes(param.name)}, ${wrapInDoubleQuotes(param.value || "")});`);
+    if (param.fileName) {
+        return [
+            indent(2, `let part = reqwest::multipart::Part::text(${wrapInDoubleQuotes(param.value || '')})`),
+            indent(3, `.file_name(${wrapInDoubleQuotes(param.fileName)});`),
+            indent(2, `form = form.part(${wrapInDoubleQuotes(param.name)}, part);`),
+        ].join('\n');
+    }
+    return indent(2, `form = form.text(${wrapInDoubleQuotes(param.name)}, ${wrapInDoubleQuotes(param.value || '')});`);
 };
+/**
+ * Creates authentication chained call if credentials are provided
+ */
 const createAuthCall = (auth) => {
-  if (!auth?.username || !auth?.password) {
-    return null;
-  }
-  return createChain("basic_auth", wrapInDoubleQuotes(auth.username), wrapInDoubleQuotes(auth.password));
+    if (!auth?.username || !auth?.password) {
+        return null;
+    }
+    return createChain('basic_auth', wrapInDoubleQuotes(auth.username), wrapInDoubleQuotes(auth.password));
 };
+/**
+ * Creates header chained calls from headers object
+ */
 const createHeaderCalls = (headers) => {
-  return Object.entries(headers).map(
-    ([key, value]) => createChain("header", wrapInDoubleQuotes(key), wrapInDoubleQuotes(value))
-  );
+    return Object.entries(headers).map(([key, value]) => createChain('header', wrapInDoubleQuotes(key), wrapInDoubleQuotes(value)));
 };
+/**
+ * Creates body chained call based on content type
+ */
 const createBodyCall = (postData) => {
-  if (!postData) {
-    return null;
-  }
-  const { mimeType, text, params } = postData;
-  switch (mimeType) {
-    case "application/json": {
-      const formattedJson = formatJson(text);
-      return createChain("json", `&serde_json::json!(${formattedJson})`);
+    if (!postData) {
+        return null;
     }
-    case "application/x-www-form-urlencoded": {
-      const formData = params?.map((param) => `(${wrapInDoubleQuotes(param.name)}, ${wrapInDoubleQuotes(param.value || "")})`).join(", ") || "";
-      return createChain("form", `&[${formData}]`);
+    const { mimeType, text, params } = postData;
+    switch (mimeType) {
+        case 'application/json': {
+            const formattedJson = formatJson(text);
+            return createChain('json', `&serde_json::json!(${formattedJson})`);
+        }
+        case 'application/x-www-form-urlencoded': {
+            const formData = params
+                ?.map((param) => `(${wrapInDoubleQuotes(param.name)}, ${wrapInDoubleQuotes(param.value || '')})`)
+                .join(', ') || '';
+            return createChain('form', `&[${formData}]`);
+        }
+        case 'multipart/form-data': {
+            const formParts = params?.map(createMultipartPart).join('\n') || '';
+            const multipartBlock = [
+                '.multipart({',
+                indent(2, 'let mut form = reqwest::multipart::Form::new();'),
+                formParts,
+                indent(3, 'form'),
+                indent(2, '})'),
+            ].join('\n');
+            return indent(1, multipartBlock);
+        }
+        default:
+            return createChain('body', wrapInDoubleQuotes(text || ''));
     }
-    case "multipart/form-data": {
-      const formParts = params?.map(createMultipartPart).join("\n") || "";
-      const multipartBlock = [
-        ".multipart({",
-        indent(2, "let mut form = reqwest::multipart::Form::new();"),
-        formParts,
-        indent(3, "form"),
-        indent(2, "})")
-      ].join("\n");
-      return indent(1, multipartBlock);
-    }
-    default:
-      return createChain("body", wrapInDoubleQuotes(text || ""));
-  }
 };
+/**
+ * Builds the complete Rust code by assembling all code
+ */
 const buildRustCode = (url, method, chainedCalls) => {
-  const code = ["let client = reqwest::Client::new();", ""];
-  if (chainedCalls.length > 0) {
-    code.push("let request = client");
-    code.push(indent(1, `.${method.toLowerCase()}(${wrapInDoubleQuotes(url)})`));
-    code.push(...chainedCalls);
-  } else {
-    code.push(`let request = client.${method.toLowerCase()}(${wrapInDoubleQuotes(url)})`);
-  }
-  const lastPart = code[code.length - 1];
-  code[code.length - 1] = lastPart + ";";
-  code.push("");
-  code.push("let response = request.send().await?;");
-  return code.join("\n");
-};
-export {
-  rustReqwest
+    const code = ['let client = reqwest::Client::new();', ''];
+    // Add chained calls with proper formatting
+    if (chainedCalls.length > 0) {
+        code.push('let request = client');
+        code.push(indent(1, `.${method.toLowerCase()}(${wrapInDoubleQuotes(url)})`));
+        // Add a newline before the first chained call
+        code.push(...chainedCalls);
+    }
+    else {
+        code.push(`let request = client.${method.toLowerCase()}(${wrapInDoubleQuotes(url)})`);
+    }
+    // Add semicolon to the last chained call
+    const lastPart = code[code.length - 1];
+    code[code.length - 1] = lastPart + ';';
+    // Add response handling
+    code.push('');
+    code.push('let response = request.send().await?;');
+    return code.join('\n');
 };
-//# sourceMappingURL=reqwest.js.map