@scalar/snippetz 0.8.0 → 0.9.1

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/swift/nsurlsession/nsurlsession.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nsurlsession.d.ts","sourceRoot":"","sources":["../../../../src/plugins/swift/nsurlsession/nsurlsession.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAKpD;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAQ/B,CAAA"}
+{"version":3,"file":"nsurlsession.d.ts","sourceRoot":"","sources":["../../../../src/plugins/swift/nsurlsession/nsurlsession.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AA+EpD;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,MA2E/B,CAAA"}

package/dist/plugins/swift/nsurlsession/nsurlsession.js

@@ -1,5 +1,59 @@
-import { nsurlsession } from '../../../httpsnippet-lite/targets/swift/nsurlsession/client.js';
-import { convertWithHttpSnippetLite } from '../../../utils/convertWithHttpSnippetLite.js';
+import { collectHeaders, joinUrlAndQuery, normalizeMethod, normalizeUrl } from '../../../libs/http.js';
+const swiftStringLiteral = (value) => JSON.stringify(value);
+const rawMultilineStringHashes = (value) => {
+    let hashCount = 1;
+    while (value.includes(`"""${'#'.repeat(hashCount)}`)) {
+        hashCount += 1;
+    }
+    return '#'.repeat(hashCount);
+};
+const toPrettyJson = (value) => {
+    try {
+        return JSON.stringify(JSON.parse(value), null, 2);
+    }
+    catch {
+        return value;
+    }
+};
+const encodeFormComponent = (value) => encodeURIComponent(value);
+const escapeForMultipartHeader = (value) => value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+const buildMultipartBody = (params) => {
+    const lines = [
+        'let boundary = UUID().uuidString',
+        'var body = Data()',
+        '',
+        'func appendToBody(_ value: String) {',
+        '  body.append(value.data(using: .utf8)!)',
+        '}',
+        '',
+    ];
+    params.forEach((param) => {
+        const escapedName = escapeForMultipartHeader(param.name);
+        const escapedFileName = escapeForMultipartHeader(param.fileName ?? '');
+        const escapedContentType = param.contentType ? escapeForMultipartHeader(param.contentType) : undefined;
+        lines.push(`appendToBody("--\\(boundary)\\r\\n")`);
+        if (param.fileName !== undefined) {
+            lines.push(`appendToBody(${swiftStringLiteral(`Content-Disposition: form-data; name="${escapedName}"; filename="${escapedFileName}"\r\n`)})`);
+            if (escapedContentType) {
+                lines.push(`appendToBody(${swiftStringLiteral(`Content-Type: ${escapedContentType}\r\n`)})`);
+            }
+            lines.push('appendToBody("\\r\\n")');
+            lines.push(`appendToBody(${swiftStringLiteral(`<# File data for ${param.fileName || 'file'} #>\r\n`)})`);
+        }
+        else {
+            lines.push(`appendToBody(${swiftStringLiteral(`Content-Disposition: form-data; name="${escapedName}"\r\n`)})`);
+            if (escapedContentType) {
+                lines.push(`appendToBody(${swiftStringLiteral(`Content-Type: ${escapedContentType}\r\n`)})`);
+            }
+            lines.push('appendToBody("\\r\\n")');
+            lines.push(`appendToBody(${swiftStringLiteral(param.value ?? '')})`);
+            lines.push('appendToBody("\\r\\n")');
+        }
+        lines.push('');
+    });
+    lines.push('appendToBody("--\\(boundary)--\\r\\n")');
+    return lines;
+};
 /**
  * swift/nsurlsession
  */
@@ -7,8 +61,67 @@ export const swiftNsurlsession = {
     target: 'swift',
     client: 'nsurlsession',
     title: 'NSURLSession',
-    generate(request) {
-        // TODO: Write an own converter
-        return convertWithHttpSnippetLite(nsurlsession, request);
+    generate(request, configuration) {
+        if (!request) {
+            return '';
+        }
+        const method = normalizeMethod(request.method);
+        const url = normalizeUrl(joinUrlAndQuery(request.url ?? '', request.queryString));
+        const headers = collectHeaders(request.headers, request.cookies);
+        const lines = [
+            'import Foundation',
+            '',
+            `var request = URLRequest(url: URL(string: ${swiftStringLiteral(url)})!)`,
+        ];
+        lines.push(`request.httpMethod = ${swiftStringLiteral(method)}`);
+        headers.forEach((header) => {
+            lines.push(`request.setValue(${swiftStringLiteral(header.value)}, forHTTPHeaderField: ${swiftStringLiteral(header.name)})`);
+        });
+        if (configuration?.auth?.username && configuration?.auth?.password) {
+            lines.push(`let credentials = ${swiftStringLiteral(`${configuration.auth.username}:${configuration.auth.password}`)}`);
+            lines.push('let encodedCredentials = Data(credentials.utf8).base64EncodedString()');
+            lines.push('request.setValue("Basic \\(encodedCredentials)", forHTTPHeaderField: "Authorization")');
+        }
+        if (request.postData) {
+            const { mimeType, text, params } = request.postData;
+            if (mimeType === 'application/json' && text !== undefined) {
+                const prettyJson = toPrettyJson(text);
+                const hashes = rawMultilineStringHashes(prettyJson);
+                lines.push(`let jsonBody = ${hashes}"""`);
+                lines.push(prettyJson);
+                lines.push(`"""${hashes}`);
+                lines.push('request.httpBody = jsonBody.data(using: .utf8)');
+            }
+            else if (mimeType === 'application/x-www-form-urlencoded' && params?.length) {
+                const formBody = params
+                    .map((param) => `${encodeFormComponent(param.name)}=${encodeFormComponent(param.value ?? '')}`)
+                    .join('&');
+                lines.push(`let formBody = ${swiftStringLiteral(formBody)}`);
+                lines.push('request.httpBody = formBody.data(using: .utf8)');
+            }
+            else if (mimeType === 'multipart/form-data' && params?.length) {
+                lines.push(...buildMultipartBody(params));
+                lines.push('request.setValue("multipart/form-data; boundary=\\(boundary)", forHTTPHeaderField: "Content-Type")');
+                lines.push('request.httpBody = body');
+            }
+            else if (mimeType === 'application/octet-stream') {
+                lines.push(`let binaryBody = Data(${swiftStringLiteral(text ?? '')}.utf8)`);
+                lines.push('request.httpBody = binaryBody');
+            }
+            else if (text !== undefined) {
+                lines.push(`let rawBody = ${swiftStringLiteral(text)}`);
+                lines.push('request.httpBody = rawBody.data(using: .utf8)');
+            }
+        }
+        lines.push('');
+        lines.push('let (data, response) = try await URLSession.shared.data(for: request)');
+        lines.push('');
+        lines.push('guard let httpResponse = response as? HTTPURLResponse,');
+        lines.push('      200..<300 ~= httpResponse.statusCode else {');
+        lines.push('  throw URLError(.badServerResponse)');
+        lines.push('}');
+        lines.push('');
+        lines.push('print(String(data: data, encoding: .utf8) ?? "")');
+        return lines.join('\n');
     },
 };

package/dist/snippetz.d.ts

@@ -6,8 +6,8 @@ export declare function snippetz(): {
     print<T extends TargetId>(target: T, client: ClientId<T>, request: Partial<HarRequest>): string | undefined;
     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";
+        target: "c" | "clojure" | "csharp" | "dart" | "fsharp" | "go" | "http" | "java" | "js" | "kotlin" | "node" | "objc" | "ocaml" | "php" | "powershell" | "python" | "r" | "ruby" | "rust" | "shell" | "swift";
+        client: "http" | "libcurl" | "clj_http" | "httpclient" | "restsharp" | "native" | "http1.1" | "asynchttp" | "nethttp" | "okhttp" | "unirest" | "axios" | "fetch" | "jquery" | "ofetch" | "xhr" | "undici" | "nsurlsession" | "cohttp" | "curl" | "guzzle" | "laravel" | "restmethod" | "webrequest" | "python3" | "requests" | "aiohttp" | "httpx_sync" | "httpx_async" | "httr2" | "reqwest" | "httpie" | "wget";
     }[];
     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;