@scalar/snippetz 0.7.8 → 0.9.0

package/dist/plugins/php/laravel/laravel.js

@@ -0,0 +1,134 @@
+import { accumulateRepeatedValue, buildQueryString } from '../../../libs/http.js';
+import { objectToString } from '../../../libs/php.js';
+const escapePhpString = (value) => value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+const quotePhpString = (value) => `'${escapePhpString(value)}'`;
+const escapePhpObjectKey = escapePhpString;
+const escapeObjectKeys = (value) => {
+    if (Array.isArray(value)) {
+        return value.map((item) => escapeObjectKeys(item));
+    }
+    if (value && typeof value === 'object') {
+        return Object.entries(value).reduce((acc, [key, nestedValue]) => {
+            acc[escapePhpObjectKey(key)] = escapeObjectKeys(nestedValue);
+            return acc;
+        }, {});
+    }
+    return value;
+};
+const getCookieDomain = (url) => {
+    if (!url) {
+        return 'localhost';
+    }
+    try {
+        return new URL(url).hostname || 'localhost';
+    }
+    catch {
+        return 'localhost';
+    }
+};
+/**
+ * php/laravel
+ */
+export const phpLaravel = {
+    target: 'php',
+    client: 'laravel',
+    title: 'Laravel HTTP Client',
+    generate(request, configuration) {
+        const normalizedRequest = {
+            method: 'GET',
+            ...request,
+        };
+        normalizedRequest.method = normalizedRequest.method.toUpperCase();
+        const queryString = buildQueryString(normalizedRequest.queryString);
+        const url = `${normalizedRequest.url ?? ''}${queryString}`;
+        const chain = [];
+        if (configuration?.auth?.username && configuration.auth.password) {
+            chain.push(`withBasicAuth(${quotePhpString(configuration.auth.username)}, ${quotePhpString(configuration.auth.password)})`);
+        }
+        if (normalizedRequest.headers?.length) {
+            const headers = {};
+            normalizedRequest.headers.forEach((header) => {
+                accumulateRepeatedValue(headers, header.name, header.value);
+            });
+            chain.push(`withHeaders(${objectToString(escapeObjectKeys(headers))})`);
+        }
+        if (normalizedRequest.cookies?.length) {
+            const cookies = {};
+            normalizedRequest.cookies.forEach((cookie) => {
+                accumulateRepeatedValue(cookies, cookie.name, cookie.value);
+            });
+            chain.push(`withCookies(${objectToString(escapeObjectKeys(cookies))}, ${quotePhpString(getCookieDomain(normalizedRequest.url ?? ''))})`);
+        }
+        let payload;
+        if (normalizedRequest.postData) {
+            if (normalizedRequest.postData.mimeType === 'application/json') {
+                if (normalizedRequest.postData.text) {
+                    try {
+                        payload = JSON.parse(normalizedRequest.postData.text);
+                    }
+                    catch {
+                        chain.push(`withBody(${quotePhpString(normalizedRequest.postData.text)}, 'application/json')`);
+                    }
+                }
+            }
+            else if (normalizedRequest.postData.mimeType === 'application/x-www-form-urlencoded' &&
+                normalizedRequest.postData.params) {
+                const formData = {};
+                normalizedRequest.postData.params.forEach((param) => {
+                    accumulateRepeatedValue(formData, param.name, param.value ?? '');
+                });
+                chain.push('asForm()');
+                payload = formData;
+            }
+            else if (normalizedRequest.postData.mimeType === 'multipart/form-data' && normalizedRequest.postData.params) {
+                const multipartData = {};
+                normalizedRequest.postData.params.forEach((param) => {
+                    if (param.fileName !== undefined) {
+                        const args = [
+                            quotePhpString(param.name),
+                            `file_get_contents(${quotePhpString(param.fileName)})`,
+                            quotePhpString(param.fileName),
+                        ];
+                        if (param.contentType) {
+                            args.push(objectToString(escapeObjectKeys({ 'Content-Type': param.contentType })));
+                        }
+                        chain.push(`attach(${args.join(', ')})`);
+                    }
+                    else if (param.contentType) {
+                        chain.push(`attach(${quotePhpString(param.name)}, ${quotePhpString(param.value ?? '')}, null, ${objectToString(escapeObjectKeys({ 'Content-Type': param.contentType }))})`);
+                    }
+                    else {
+                        accumulateRepeatedValue(multipartData, param.name, param.value ?? '');
+                    }
+                });
+                if (Object.keys(multipartData).length > 0) {
+                    payload = multipartData;
+                }
+            }
+            else if (normalizedRequest.postData.mimeType === 'application/octet-stream') {
+                chain.push(`withBody(${quotePhpString(normalizedRequest.postData.text ?? '')}, 'application/octet-stream')`);
+            }
+            else if (normalizedRequest.postData.text) {
+                try {
+                    payload = JSON.parse(normalizedRequest.postData.text);
+                }
+                catch {
+                    chain.push(`withBody(${quotePhpString(normalizedRequest.postData.text)}, ${quotePhpString(normalizedRequest.postData.mimeType || 'text/plain')})`);
+                }
+            }
+        }
+        const requestMethod = normalizedRequest.method.toLowerCase();
+        const supportsDirectMethod = ['delete', 'get', 'head', 'patch', 'post', 'put'].includes(requestMethod);
+        const requestCall = supportsDirectMethod
+            ? payload !== undefined && requestMethod !== 'head'
+                ? `${requestMethod}(${quotePhpString(url)}, ${objectToString(escapeObjectKeys(payload), 1)})`
+                : `${requestMethod}(${quotePhpString(url)})`
+            : payload !== undefined
+                ? `send(${quotePhpString(normalizedRequest.method)}, ${quotePhpString(url)}, ${objectToString(escapeObjectKeys(payload), 1)})`
+                : `send(${quotePhpString(normalizedRequest.method)}, ${quotePhpString(url)})`;
+        const expression = chain.length > 0
+            ? [`Http::${chain[0]}`, ...chain.slice(1).map((method) => `  ->${method}`), `  ->${requestCall}`].join('\n')
+            : `Http::${requestCall}`;
+        return `use Illuminate\\Support\\Facades\\Http;\n\n$response = ${expression};`;
+    },
+};

package/dist/plugins/r/httr2/httr2.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from '@scalar/types/snippetz';
+/**
+ * r/httr2
+ */
+export declare const rHttr2: Plugin;
+//# sourceMappingURL=httr2.d.ts.map

package/dist/plugins/r/httr2/httr2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"httr2.d.ts","sourceRoot":"","sources":["../../../../src/plugins/r/httr2/httr2.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,MAAM,EAAuB,MAAM,wBAAwB,CAAA;AAkDrF;;GAEG;AACH,eAAO,MAAM,MAAM,EAAE,MAuHpB,CAAA"}

package/dist/plugins/r/httr2/httr2.js

@@ -0,0 +1,159 @@
+import { reduceQueryParams } from '../../../libs/http.js';
+/**
+ * Formats JSON text as an R list structure
+ */
+const jsonToRList = (text, indent) => {
+    try {
+        const obj = JSON.parse(text);
+        return formatRValue(obj, indent);
+    }
+    catch {
+        return `"${text}"`;
+    }
+};
+/**
+ * Recursively formats a JS value as R syntax
+ */
+const formatRValue = (value, indent) => {
+    if (value === null || value === undefined) {
+        return 'NULL';
+    }
+    if (typeof value === 'boolean') {
+        return value ? 'TRUE' : 'FALSE';
+    }
+    if (typeof value === 'number') {
+        return String(value);
+    }
+    if (typeof value === 'string') {
+        return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            return 'list()';
+        }
+        const items = value.map((v) => `${indent}  ${formatRValue(v, indent + '  ')}`).join(',\n');
+        return `list(\n${items}\n${indent})`;
+    }
+    if (typeof value === 'object') {
+        const entries = Object.entries(value);
+        if (entries.length === 0) {
+            return 'list()';
+        }
+        const items = entries.map(([k, v]) => `${indent}  ${k} = ${formatRValue(v, indent + '  ')}`).join(',\n');
+        return `list(\n${items}\n${indent})`;
+    }
+    return String(value);
+};
+/**
+ * r/httr2
+ */
+export const rHttr2 = {
+    target: 'r',
+    client: 'httr2',
+    title: 'httr2',
+    generate(request, configuration) {
+        const normalizedRequest = {
+            url: 'https://example.com',
+            method: 'GET',
+            ...request,
+        };
+        const method = normalizedRequest.method.toUpperCase();
+        const lines = ['library(httr2)', ''];
+        // Start the pipe chain
+        lines.push(`response <- request("${normalizedRequest.url}") |>`);
+        // Collect pipe steps
+        const steps = [];
+        // Method (GET is default, so only add for non-GET)
+        if (method !== 'GET') {
+            steps.push(`  req_method("${method}")`);
+        }
+        // Headers
+        const headers = {};
+        if (normalizedRequest.headers?.length) {
+            for (const header of normalizedRequest.headers) {
+                headers[header.name] = header.value;
+            }
+        }
+        // Cookies as Cookie header
+        if (normalizedRequest.cookies?.length) {
+            const cookieString = normalizedRequest.cookies.map((c) => `${c.name}=${c.value}`).join('; ');
+            headers['Cookie'] = cookieString;
+        }
+        // Auth
+        if (configuration?.auth?.username && configuration?.auth?.password) {
+            steps.push(`  req_auth_basic("${configuration.auth.username}", "${configuration.auth.password}")`);
+        }
+        if (Object.keys(headers).length) {
+            const headerEntries = Object.entries(headers);
+            if (headerEntries.length === 1) {
+                const [name, value] = headerEntries[0];
+                steps.push(`  req_headers("${name}" = "${value}")`);
+            }
+            else {
+                const headerLines = headerEntries.map(([name, value]) => `    "${name}" = "${value}"`).join(',\n');
+                steps.push(`  req_headers(\n${headerLines}\n  )`);
+            }
+        }
+        // Query parameters
+        if (normalizedRequest.queryString?.length) {
+            const params = reduceQueryParams(normalizedRequest.queryString);
+            const entries = Object.entries(params);
+            if (entries.length === 1) {
+                const [name, value] = entries[0];
+                if (Array.isArray(value)) {
+                    const items = value.map((v) => `"${v}"`).join(', ');
+                    steps.push(`  req_url_query("${name}" = c(${items}))`);
+                }
+                else {
+                    steps.push(`  req_url_query("${name}" = "${value}")`);
+                }
+            }
+            else {
+                const paramLines = entries
+                    .map(([name, value]) => {
+                    if (Array.isArray(value)) {
+                        const items = value.map((v) => `"${v}"`).join(', ');
+                        return `    "${name}" = c(${items})`;
+                    }
+                    return `    "${name}" = "${value}"`;
+                })
+                    .join(',\n');
+                steps.push(`  req_url_query(\n${paramLines}\n  )`);
+            }
+        }
+        // Body
+        if (normalizedRequest.postData) {
+            const { mimeType, text, params } = normalizedRequest.postData;
+            if (mimeType === 'application/json' && text) {
+                const rList = jsonToRList(text, '  ');
+                steps.push(`  req_body_json(${rList})`);
+            }
+            else if (mimeType === 'multipart/form-data' && params) {
+                const paramLines = params
+                    .map((p) => {
+                    if (p.fileName !== undefined) {
+                        return `    ${p.name} = curl::form_file("${p.fileName}")`;
+                    }
+                    return `    ${p.name} = "${p.value ?? ''}"`;
+                })
+                    .join(',\n');
+                steps.push(`  req_body_multipart(\n${paramLines}\n  )`);
+            }
+            else if (mimeType === 'application/x-www-form-urlencoded' && params) {
+                const paramLines = params.map((p) => `    "${p.name}" = "${p.value ?? ''}"`).join(',\n');
+                steps.push(`  req_body_form(\n${paramLines}\n  )`);
+            }
+            else if (text) {
+                steps.push(`  req_body_raw("${text}", type = "${mimeType ?? 'application/octet-stream'}")`);
+            }
+        }
+        // Always end with req_perform
+        steps.push('  req_perform()');
+        // Join steps with pipe operator
+        lines[lines.length - 1] = `response <- request("${normalizedRequest.url}") |>`;
+        lines.push(steps.join(' |>\n'));
+        lines.push('');
+        lines.push('resp_body_string(response)');
+        return lines.join('\n');
+    },
+};

package/dist/plugins/r/httr2/index.d.ts

@@ -0,0 +1,2 @@
+export { rHttr2 } from './httr2.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/r/httr2/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/r/httr2/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA"}

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

@@ -0,0 +1 @@
+export { rHttr2 } from './httr2.js';

package/dist/plugins/ruby/native/native.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"native.d.ts","sourceRoot":"","sources":["../../../../src/plugins/ruby/native/native.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAKpD;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,MAQxB,CAAA"}
+{"version":3,"file":"native.d.ts","sourceRoot":"","sources":["../../../../src/plugins/ruby/native/native.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AA8DpD;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,MAuGxB,CAAA"}

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

@@ -1,5 +1,51 @@
-import { native } from '../../../httpsnippet-lite/targets/ruby/native/client.js';
-import { convertWithHttpSnippetLite } from '../../../utils/convertWithHttpSnippetLite.js';
+import { buildQueryString } from '../../../libs/http.js';
+const escapeRubyDoubleQuoted = (value) => value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+const escapeRubySingleQuoted = (value) => value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+const encodeFormComponent = (value) => encodeURIComponent(value).replace(/'/g, '%27');
+const standardMethods = new Set([
+    'GET',
+    'POST',
+    'HEAD',
+    'DELETE',
+    'PATCH',
+    'PUT',
+    'OPTIONS',
+    'COPY',
+    'LOCK',
+    'UNLOCK',
+    'MOVE',
+    'TRACE',
+]);
+const toRubyMethodClass = (method) => method.charAt(0) + method.slice(1).toLowerCase();
+const maybeAddCustomMethodClass = (lines, method, hasBody) => {
+    if (standardMethods.has(method)) {
+        return;
+    }
+    const methodClass = toRubyMethodClass(method);
+    lines.push(`class Net::HTTP::${methodClass} < Net::HTTPRequest`);
+    lines.push(`  METHOD = '${method}'`);
+    lines.push(`  REQUEST_HAS_BODY = '${hasBody ? 'true' : 'false'}'`);
+    lines.push('  RESPONSE_HAS_BODY = true');
+    lines.push('end');
+    lines.push('');
+};
+const encodeUrlWithPathPreservedBrackets = (url) => {
+    try {
+        const parsedUrl = new URL(url);
+        const encodedPath = parsedUrl.pathname
+            .split('/')
+            .map((segment) => encodeURIComponent(decodeURIComponent(segment)).replace(/%5B/g, '[').replace(/%5D/g, ']').replace(/%24/g, '$'))
+            .join('/');
+        // Keep legacy behavior from the previous converter: omit trailing slash for origin-only URLs.
+        if (parsedUrl.pathname === '/') {
+            return `${parsedUrl.origin}${parsedUrl.search}${parsedUrl.hash}`;
+        }
+        return `${parsedUrl.origin}${encodedPath}${parsedUrl.search}${parsedUrl.hash}`;
+    }
+    catch {
+        return url;
+    }
+};
 /**
  * ruby/native
  */
@@ -7,8 +53,95 @@ export const rubyNative = {
     target: 'ruby',
     client: 'native',
     title: 'net::http',
-    generate(request) {
-        // TODO: Write an own converter
-        return convertWithHttpSnippetLite(native, request);
+    generate(request, configuration) {
+        const normalizedRequest = {
+            method: 'GET',
+            ...request,
+        };
+        normalizedRequest.method = normalizedRequest.method.toUpperCase();
+        const queryString = buildQueryString(normalizedRequest.queryString);
+        const rawUrl = `${normalizedRequest.url ?? ''}${queryString}`;
+        const encodedUrl = encodeUrlWithPathPreservedBrackets(rawUrl);
+        const lines = ["require 'uri'", "require 'net/http'", ''];
+        maybeAddCustomMethodClass(lines, normalizedRequest.method, Boolean(normalizedRequest.postData?.text));
+        lines.push(`url = URI("${escapeRubyDoubleQuoted(encodedUrl)}")`, '');
+        lines.push('http = Net::HTTP.new(url.host, url.port)');
+        if (encodedUrl.startsWith('https://')) {
+            lines.push('http.use_ssl = true');
+        }
+        lines.push('');
+        const methodClass = toRubyMethodClass(normalizedRequest.method);
+        lines.push(`request = Net::HTTP::${methodClass}.new(url)`);
+        if (configuration?.auth?.username && configuration?.auth?.password) {
+            const username = escapeRubyDoubleQuoted(configuration.auth.username);
+            const password = escapeRubyDoubleQuoted(configuration.auth.password);
+            lines.push(`request.basic_auth("${username}", "${password}")`);
+        }
+        if (normalizedRequest.headers?.length) {
+            normalizedRequest.headers.forEach((header) => {
+                lines.push(`request["${escapeRubyDoubleQuoted(header.name)}"] = '${escapeRubySingleQuoted(header.value)}'`);
+            });
+        }
+        if (normalizedRequest.cookies?.length) {
+            const cookieString = normalizedRequest.cookies
+                .map((cookie) => `${encodeFormComponent(cookie.name)}=${encodeFormComponent(cookie.value)}`)
+                .join('; ');
+            lines.push(`request["Cookie"] = '${escapeRubySingleQuoted(cookieString)}'`);
+        }
+        if (normalizedRequest.postData) {
+            const { mimeType, text, params } = normalizedRequest.postData;
+            if (mimeType === 'application/json' && text !== undefined) {
+                try {
+                    const parsed = JSON.parse(text);
+                    const prettyJson = JSON.stringify(parsed, null, 2);
+                    lines.push('request.body = <<~JSON');
+                    lines.push(prettyJson);
+                    lines.push('JSON');
+                }
+                catch {
+                    lines.push(`request.body = ${JSON.stringify(text)}`);
+                }
+            }
+            else if (mimeType === 'application/x-www-form-urlencoded' && params) {
+                const encodedForm = params
+                    .map((param) => `${encodeFormComponent(param.name)}=${encodeFormComponent(param.value ?? '')}`)
+                    .join('&');
+                lines.push(`request.body = '${escapeRubySingleQuoted(encodedForm)}'`);
+            }
+            else if (mimeType === 'multipart/form-data' && params) {
+                lines.push('form_data = []');
+                params.forEach((param) => {
+                    const name = escapeRubySingleQuoted(param.name);
+                    if (param.fileName !== undefined) {
+                        const fileName = escapeRubySingleQuoted(param.fileName);
+                        if (param.contentType) {
+                            const contentType = escapeRubySingleQuoted(param.contentType);
+                            lines.push(`form_data << ['${name}', File.open('${fileName}'), { filename: '${fileName}', content_type: '${contentType}' }]`);
+                        }
+                        else {
+                            lines.push(`form_data << ['${name}', File.open('${fileName}')]`);
+                        }
+                    }
+                    else if (param.contentType) {
+                        const value = escapeRubySingleQuoted(param.value ?? '');
+                        const contentType = escapeRubySingleQuoted(param.contentType);
+                        lines.push(`form_data << ['${name}', '${value}', { content_type: '${contentType}' }]`);
+                    }
+                    else {
+                        const value = escapeRubySingleQuoted(param.value ?? '');
+                        lines.push(`form_data << ['${name}', '${value}']`);
+                    }
+                });
+                lines.push("request.set_form(form_data, 'multipart/form-data')");
+            }
+            else if (mimeType === 'application/octet-stream') {
+                lines.push(`request.body = ${JSON.stringify(text ?? '')}`);
+            }
+            else if (text !== undefined) {
+                lines.push(`request.body = ${JSON.stringify(text)}`);
+            }
+        }
+        lines.push('', 'response = http.request(request)', 'puts response.read_body');
+        return lines.join('\n');
     },
 };

package/dist/plugins/shared/axios.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin, TargetId } from '@scalar/types/snippetz';
+export declare const createAxiosPlugin: (target: Extract<TargetId, "js" | "node">) => Plugin;
+//# sourceMappingURL=axios.d.ts.map

package/dist/plugins/shared/axios.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"axios.d.ts","sourceRoot":"","sources":["../../../src/plugins/shared/axios.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAA;AA4I9D,eAAO,MAAM,iBAAiB,GAAI,QAAQ,OAAO,CAAC,QAAQ,EAAE,IAAI,GAAG,MAAM,CAAC,KAAG,MAmD3E,CAAA"}

package/dist/plugins/shared/axios.js

@@ -0,0 +1,148 @@
+import { accumulateRepeatedValue, reduceQueryParams } from '../../libs/http.js';
+import { Raw, objectToString } from '../../libs/javascript.js';
+const escapeJsString = (value) => value.replaceAll('\\', '\\\\').replaceAll('\n', '\\n').replaceAll('\r', '\\r').replaceAll("'", "\\'");
+const sanitizeForGeneratedCode = (value) => {
+    if (typeof value === 'string') {
+        return escapeJsString(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => sanitizeForGeneratedCode(item));
+    }
+    if (value && typeof value === 'object' && !(value instanceof Raw)) {
+        return Object.entries(value).reduce((acc, [key, objectValue]) => {
+            acc[key] = sanitizeForGeneratedCode(objectValue);
+            return acc;
+        }, {});
+    }
+    return value;
+};
+const addHeaderValue = (headers, name, value) => {
+    if (value === '') {
+        headers[name] = value;
+        return;
+    }
+    accumulateRepeatedValue(headers, name, value);
+};
+const buildHeaders = (request) => {
+    const headers = {};
+    request?.headers?.forEach((header) => {
+        addHeaderValue(headers, header.name, header.value);
+    });
+    if (request?.cookies?.length) {
+        const cookieValue = request.cookies.map((cookie) => `${cookie.name}=${cookie.value}`).join('; ');
+        addHeaderValue(headers, 'Cookie', cookieValue);
+    }
+    return Object.keys(headers).length ? headers : undefined;
+};
+const buildData = (request) => {
+    const setup = [];
+    const postData = request?.postData;
+    if (!postData) {
+        return { setup };
+    }
+    if (postData.mimeType === 'application/json') {
+        if (!postData.text) {
+            return { setup };
+        }
+        try {
+            return {
+                setup,
+                data: JSON.parse(postData.text),
+            };
+        }
+        catch {
+            return {
+                setup,
+                data: postData.text,
+            };
+        }
+    }
+    if (postData.mimeType === 'application/x-www-form-urlencoded' && postData.params?.length) {
+        setup.push('const encodedParams = new URLSearchParams()');
+        postData.params.forEach((param) => {
+            const encodedName = escapeJsString(param.name);
+            const encodedValue = escapeJsString(param.value ?? '');
+            setup.push(`encodedParams.append('${encodedName}', '${encodedValue}')`);
+        });
+        return {
+            setup,
+            data: new Raw('encodedParams'),
+        };
+    }
+    if (postData.mimeType === 'multipart/form-data' && postData.params?.length) {
+        setup.push('const formData = new FormData()');
+        postData.params.forEach((param) => {
+            const encodedName = escapeJsString(param.name);
+            if (param.fileName !== undefined) {
+                const encodedFileName = escapeJsString(param.fileName);
+                const blobWithType = param.contentType ? `, { type: '${escapeJsString(param.contentType)}' }` : '';
+                setup.push(`formData.append('${encodedName}', new Blob([]${blobWithType}), '${encodedFileName}')`);
+                return;
+            }
+            if (param.contentType) {
+                const encodedContentType = escapeJsString(param.contentType);
+                const encodedValue = escapeJsString(param.value ?? '');
+                setup.push(`formData.append('${encodedName}', new Blob(['${encodedValue}'], { type: '${encodedContentType}' }))`);
+                return;
+            }
+            const encodedValue = escapeJsString(param.value ?? '');
+            setup.push(`formData.append('${encodedName}', '${encodedValue}')`);
+        });
+        return {
+            setup,
+            data: new Raw('formData'),
+        };
+    }
+    if (!postData.text) {
+        return { setup };
+    }
+    return {
+        setup,
+        data: postData.text,
+    };
+};
+export const createAxiosPlugin = (target) => ({
+    target,
+    client: 'axios',
+    title: 'Axios',
+    generate(request, configuration) {
+        const normalizedRequest = {
+            method: 'GET',
+            ...request,
+        };
+        normalizedRequest.method = normalizedRequest.method.toUpperCase();
+        const options = {
+            method: normalizedRequest.method,
+            url: escapeJsString(normalizedRequest.url ?? ''),
+        };
+        const params = reduceQueryParams(normalizedRequest.queryString);
+        if (Object.keys(params).length) {
+            options.params = sanitizeForGeneratedCode(params);
+        }
+        const headers = buildHeaders(normalizedRequest);
+        if (headers) {
+            options.headers = sanitizeForGeneratedCode(headers);
+        }
+        if (configuration?.auth?.username && configuration?.auth?.password) {
+            options.auth = {
+                username: escapeJsString(configuration.auth.username),
+                password: escapeJsString(configuration.auth.password),
+            };
+        }
+        const { setup, data } = buildData(normalizedRequest);
+        if (data !== undefined) {
+            options.data = data instanceof Raw ? data : sanitizeForGeneratedCode(data);
+        }
+        const setupBlock = setup.length ? `${setup.join('\n')}\n\n` : '';
+        return `import axios from 'axios'
+
+${setupBlock}const options = ${objectToString(options)}
+
+try {
+  const { data } = await axios.request(options)
+  console.log(data)
+} catch (error) {
+  console.error(error)
+}`;
+    },
+});

package/dist/plugins/shell/curl/curl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"curl.d.ts","sourceRoot":"","sources":["../../../../src/plugins/shell/curl/curl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAIpD;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,MAoIvB,CAAA"}
+{"version":3,"file":"curl.d.ts","sourceRoot":"","sources":["../../../../src/plugins/shell/curl/curl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAIpD;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,MAkIvB,CAAA"}

package/dist/plugins/shell/curl/curl.js

@@ -22,9 +22,7 @@ export const shellCurl = {
                 normalizedRequest.queryString
                     .map((param) => {
                     // Ensure both name and value are fully URI encoded
-                    const encodedName = encodeURIComponent(param.name);
-                    const encodedValue = encodeURIComponent(param.value);
-                    return `${encodedName}=${encodedValue}`;
+                    return `${param.name}=${param.value}`;
                 })
                     .join('&')
             : '';

package/dist/snippetz.d.ts

@@ -7,7 +7,7 @@ export declare function snippetz(): {
     clients(): import("@scalar/types/snippetz").Target[];
     plugins(): {
         target: "c" | "clojure" | "csharp" | "go" | "http" | "java" | "kotlin" | "node" | "objc" | "ocaml" | "php" | "powershell" | "python" | "r" | "ruby" | "shell" | "swift" | "dart" | "fsharp" | "js" | "rust";
-        client: "http" | "libcurl" | "clj_http" | "httpclient" | "restsharp" | "native" | "http1.1" | "asynchttp" | "nethttp" | "okhttp" | "unirest" | "axios" | "fetch" | "ofetch" | "undici" | "nsurlsession" | "cohttp" | "curl" | "guzzle" | "restmethod" | "webrequest" | "python3" | "requests" | "httpx_sync" | "httpx_async" | "httr" | "httpie" | "wget" | "jquery" | "xhr" | "reqwest";
+        client: "http" | "libcurl" | "clj_http" | "httpclient" | "restsharp" | "native" | "http1.1" | "asynchttp" | "nethttp" | "okhttp" | "unirest" | "axios" | "fetch" | "ofetch" | "undici" | "nsurlsession" | "cohttp" | "curl" | "guzzle" | "laravel" | "restmethod" | "webrequest" | "python3" | "requests" | "httpx_sync" | "httpx_async" | "httr2" | "httpie" | "wget" | "jquery" | "xhr" | "reqwest";
     }[];
     findPlugin: <T extends TargetId>(target: T | string, client: ClientId<T> | string) => import("@scalar/types/snippetz").Plugin | undefined;
     hasPlugin<T extends TargetId>(target: T | string, client: ClientId<T> | string): boolean;