@scalar/snippetz 0.9.11 → 0.9.13

package/dist/httpsnippet-lite/helpers/shell.d.ts

@@ -3,5 +3,4 @@
  * see: http://wiki.bash-hackers.org/syntax/quoting#strong_quoting
  */
 export declare const shellQuote: (value?: string) => string;
-export declare const shellEscape: (value: string) => string;
 //# sourceMappingURL=shell.d.ts.map

package/dist/httpsnippet-lite/helpers/shell.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shell.d.ts","sourceRoot":"","sources":["../../../src/httpsnippet-lite/helpers/shell.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,UAAU,GAAI,cAAU,KAAG,MAQvC,CAAA;AACD,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,KAAG,MAA2D,CAAA"}
+{"version":3,"file":"shell.d.ts","sourceRoot":"","sources":["../../../src/httpsnippet-lite/helpers/shell.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,UAAU,GAAI,cAAU,KAAG,MAQvC,CAAA"}

package/dist/httpsnippet-lite/helpers/shell.js

@@ -11,4 +11,3 @@ export const shellQuote = (value = '') => {
     // if the value is not shell safe, then quote it
     return `'${value.replace(/'/g, "'\\''")}'`;
 };
-export const shellEscape = (value) => value.replace(/\r/g, '\\r').replace(/\n/g, '\\n');

package/dist/plugins/clojure/clj_http/clj_http.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clj_http.d.ts","sourceRoot":"","sources":["../../../../src/plugins/clojure/clj_http/clj_http.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAKpD;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,MAQ5B,CAAA"}
+{"version":3,"file":"clj_http.d.ts","sourceRoot":"","sources":["../../../../src/plugins/clojure/clj_http/clj_http.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAsGpD;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,MAiI5B,CAAA"}

package/dist/plugins/clojure/clj_http/clj_http.js

@@ -1,5 +1,96 @@
-import { clj_http } from '../../../httpsnippet-lite/targets/clojure/clj_http/client.js';
-import { convertWithHttpSnippetLite } from '../../../utils/convertWithHttpSnippetLite.js';
+import { normalizeMethod, reduceQueryParams } from '../../../libs/http.js';
+/**
+ * Escapes a string so it stays a valid EDN string literal. Backslashes are
+ * escaped first, then double quotes, so the two passes do not interfere.
+ */
+const escapeEdnString = (value) => value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+/**
+ * A Clojure keyword (e.g. `:json`) rendered verbatim in EDN.
+ */
+class Keyword {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+    toString() {
+        return `:${this.name}`;
+    }
+}
+/**
+ * A reference to a file on disk, rendered as a `clojure.java.io/file` call.
+ */
+class File {
+    path;
+    constructor(path) {
+        this.path = path;
+    }
+    toString() {
+        return `(clojure.java.io/file "${escapeEdnString(this.path)}")`;
+    }
+}
+/** True when the value is a plain object with no own keys. */
+const isEmptyObject = (input) => typeof input === 'object' &&
+    input !== null &&
+    !Array.isArray(input) &&
+    !(input instanceof Keyword) &&
+    !(input instanceof File) &&
+    Object.keys(input).length === 0;
+/**
+ * Drops keys whose values are empty objects so we do not emit things like
+ * `:headers {}` for a request without headers.
+ */
+const filterEmpty = (input) => {
+    for (const key of Object.keys(input)) {
+        if (isEmptyObject(input[key])) {
+            delete input[key];
+        }
+    }
+    return input;
+};
+/** Indents every line after the first by `padSize` spaces. */
+const padBlock = (padSize, input) => input.replace(/\n/g, `\n${' '.repeat(padSize)}`);
+/**
+ * Renders a JavaScript value as an EDN literal, matching clj-http conventions:
+ * maps are laid out vertically and vectors horizontally.
+ */
+const jsToEdn = (value) => {
+    if (value === null || value === undefined) {
+        return 'nil';
+    }
+    if (value instanceof Keyword || value instanceof File) {
+        return value.toString();
+    }
+    if (typeof value === 'string') {
+        return `"${escapeEdnString(value)}"`;
+    }
+    if (Array.isArray(value)) {
+        // Simple horizontal format.
+        const body = value.reduce((accumulator, item) => `${accumulator} ${jsToEdn(item)}`, '').trim();
+        return `[${padBlock(1, body)}]`;
+    }
+    if (typeof value === 'object') {
+        // Simple vertical format, one key per line.
+        const body = Object.keys(value)
+            .reduce((accumulator, key) => {
+            const rendered = padBlock(key.length + 2, jsToEdn(value[key]));
+            return `${accumulator}:${key} ${rendered}\n `;
+        }, '')
+            .trim();
+        return `{${padBlock(1, body)}}`;
+    }
+    // number, boolean
+    return String(value);
+};
+/** Case-insensitive lookup of a header name as it was originally cased. */
+const findHeaderName = (headers, name) => Object.keys(headers).find((header) => header.toLowerCase() === name.toLowerCase());
+/** Removes a header (case-insensitive) from the headers map, if present. */
+const deleteHeader = (headers, name) => {
+    const header = findHeaderName(headers, name);
+    if (header) {
+        delete headers[header];
+    }
+};
+const SUPPORTED_METHODS = ['get', 'post', 'put', 'delete', 'patch', 'head', 'options'];
 /**
  * clojure/clj_http
  */
@@ -7,8 +98,109 @@ export const clojureCljhttp = {
     target: 'clojure',
     client: 'clj_http',
     title: 'clj-http',
-    generate(request) {
-        // TODO: Write an own converter
-        return convertWithHttpSnippetLite(clj_http, request);
+    generate(request, configuration) {
+        const method = normalizeMethod(request?.method).toLowerCase();
+        if (!SUPPORTED_METHODS.includes(method)) {
+            return 'Method not supported';
+        }
+        // Parse the URL so we can lift any query string into `:query-params`.
+        const urlObject = new URL(request?.url ?? '');
+        let url = urlObject.pathname === '/' ? urlObject.origin : urlObject.toString();
+        // Collect query parameters from both the URL and the explicit list.
+        const queryObj = reduceQueryParams([
+            ...Array.from(urlObject.searchParams.entries()).map(([name, value]) => ({ name, value })),
+            ...(request?.queryString ?? []),
+        ]);
+        if (Object.keys(queryObj).length > 0) {
+            // clj-http takes care of encoding the query string for us.
+            url = url.split('?')[0] ?? url;
+        }
+        // Reduce headers into a plain object (last value wins for duplicates).
+        const headers = (request?.headers ?? []).reduce((accumulator, header) => {
+            accumulator[header.name] = header.value ?? '';
+            return accumulator;
+        }, {});
+        // clj-http has no dedicated cookie option, so fold cookies into a single
+        // Cookie header, mirroring what the request would send on the wire.
+        if (request?.cookies?.length) {
+            headers.Cookie = request.cookies
+                .map((cookie) => `${encodeURIComponent(cookie.name)}=${encodeURIComponent(cookie.value)}`)
+                .join('; ');
+        }
+        const params = {
+            'headers': headers,
+            'query-params': queryObj,
+        };
+        // Basic authentication maps to clj-http's `:basic-auth ["user" "pass"]`.
+        if (configuration?.auth?.username && configuration?.auth?.password) {
+            params['basic-auth'] = [configuration.auth.username, configuration.auth.password];
+        }
+        const postData = request?.postData;
+        switch (postData?.mimeType) {
+            case 'application/json': {
+                params['content-type'] = new Keyword('json');
+                if (postData.text) {
+                    try {
+                        params['form-params'] = JSON.parse(postData.text);
+                    }
+                    catch {
+                        // Preserve the original payload as a raw body when it is not valid JSON.
+                        params.body = postData.text;
+                    }
+                }
+                deleteHeader(headers, 'content-type');
+                break;
+            }
+            case 'application/x-www-form-urlencoded': {
+                params['form-params'] = (postData.params ?? []).reduce((accumulator, param) => {
+                    if (param.name && param.value !== undefined) {
+                        accumulator[param.name] = param.value;
+                    }
+                    return accumulator;
+                }, {});
+                deleteHeader(headers, 'content-type');
+                break;
+            }
+            case 'multipart/form-data': {
+                if (postData.params) {
+                    params.multipart = postData.params.map((param) => 
+                    // Reference a file when there is a string fileName and no inline
+                    // body. A part carrying an actual value (a common HAR file part
+                    // with body bytes) keeps that value as the content, while an
+                    // empty or null value still references the file path.
+                    typeof param.fileName === 'string' && !param.value
+                        ? { name: param.name, content: new File(param.fileName) }
+                        : { name: param.name, content: param.value });
+                }
+                deleteHeader(headers, 'content-type');
+                break;
+            }
+            default: {
+                // Everything else (text/plain, octet-stream, …) goes through as a raw body.
+                if (postData?.text) {
+                    params.body = postData.text;
+                    deleteHeader(headers, 'content-type');
+                }
+            }
+        }
+        // clj-http exposes `:accept :json` instead of an Accept header for JSON.
+        const acceptHeader = findHeaderName(headers, 'accept');
+        if (acceptHeader && headers[acceptHeader] === 'application/json') {
+            params.accept = new Keyword('json');
+            delete headers[acceptHeader];
+        }
+        const filteredParams = filterEmpty(params);
+        const require = "(require '[clj-http.client :as client])\n";
+        // Escape the URL like every other EDN string so backslashes or quotes
+        // cannot break out of the literal.
+        const escapedUrl = escapeEdnString(url);
+        if (isEmptyObject(filteredParams)) {
+            return `${require}\n(client/${method} "${escapedUrl}")`;
+        }
+        // Align the option map under the opening of the call. The padding uses the
+        // escaped URL length so the columns line up with what is actually rendered.
+        const padding = 11 + method.length + escapedUrl.length;
+        const formattedParams = padBlock(padding, jsToEdn(filteredParams));
+        return `${require}\n(client/${method} "${escapedUrl}" ${formattedParams})`;
     },
 };

package/dist/plugins/csharp/restsharp/restsharp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"restsharp.d.ts","sourceRoot":"","sources":["../../../../src/plugins/csharp/restsharp/restsharp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAKpD;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,MAQ7B,CAAA"}
+{"version":3,"file":"restsharp.d.ts","sourceRoot":"","sources":["../../../../src/plugins/csharp/restsharp/restsharp.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAmDpD;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,MAkH7B,CAAA"}

package/dist/plugins/csharp/restsharp/restsharp.js

@@ -1,5 +1,47 @@
-import { restsharp } from '../../../httpsnippet-lite/targets/csharp/restsharp/client.js';
-import { convertWithHttpSnippetLite } from '../../../utils/convertWithHttpSnippetLite.js';
+import { parseMimeType } from '@scalar/helpers/http/mime-type';
+import { encode } from 'js-base64';
+import { joinUrlAndQuery } from '../../../libs/http.js';
+/**
+ * True for `application/json`, any RFC 6839 `+json` structured-syntax suffix
+ * (e.g. `application/vnd.api+json`), and parameterized variants
+ * (e.g. `application/json;charset=utf-8`). Case-insensitive.
+ */
+const isJsonContentType = (value) => {
+    if (!value) {
+        return false;
+    }
+    const { subtype } = parseMimeType(value);
+    return subtype === 'json' || subtype.endsWith('+json');
+};
+/**
+ * Maps an HTTP method to a RestSharp `Method` enum member. The enum uses
+ * PascalCase members (`Method.Get`, `Method.Post`, ...), so we title-case the
+ * method name to cover both the well-known verbs and any custom ones.
+ */
+const getMethod = (method) => {
+    const titleCased = method.charAt(0).toUpperCase() + method.slice(1).toLowerCase();
+    return `Method.${titleCased}`;
+};
+/**
+ * Escapes a value for use inside a regular C# double-quoted string literal.
+ * Backslashes and double quotes are escaped, and newlines, carriage returns,
+ * and tabs are turned into their escape sequences so values stay on a single
+ * line and the generated snippet remains valid C#.
+ */
+const escapeCSharpString = (text) => text.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/\t/g, '\\t');
+/**
+ * Wraps text in a C# raw string literal (`"""`), growing the delimiter when the
+ * payload itself contains a run of quotes. This keeps multi-line JSON bodies
+ * readable without escaping every quote.
+ */
+const createRawStringLiteral = (text) => {
+    let quoteCount = 3;
+    while (text.includes('"'.repeat(quoteCount))) {
+        quoteCount++;
+    }
+    const quotes = '"'.repeat(quoteCount);
+    return `${quotes}\n${text}\n${quotes}`;
+};
 /**
  * csharp/restsharp
  */
@@ -7,8 +49,95 @@ export const csharpRestsharp = {
     target: 'csharp',
     client: 'restsharp',
     title: 'RestSharp',
-    generate(request) {
-        // TODO: Write an own converter
-        return convertWithHttpSnippetLite(restsharp, request);
+    generate(request, configuration) {
+        // Defaults
+        const normalizedRequest = {
+            method: 'GET',
+            url: '',
+            ...request,
+        };
+        // Normalization
+        normalizedRequest.method = normalizedRequest.method.toUpperCase();
+        // Build the full URL, appending the query string with the correct separator
+        // (joinUrlAndQuery uses `&` when the URL already carries a query string)
+        const url = joinUrlAndQuery(normalizedRequest.url, normalizedRequest.queryString);
+        // Derive the host so cookies can be scoped to it (RestSharp requires a domain)
+        let host = '';
+        try {
+            host = new URL(url).host;
+        }
+        catch {
+            // Leave the host empty when the URL cannot be parsed
+        }
+        const lines = [];
+        // Client and request
+        lines.push(`var client = new RestClient("${escapeCSharpString(url)}");`);
+        lines.push(`var request = new RestRequest("", ${getMethod(normalizedRequest.method)});`);
+        // Basic Auth (added as an Authorization header so the client stays request-scoped)
+        const { username, password } = configuration?.auth ?? {};
+        const hasBasicAuth = Boolean(username && password);
+        if (hasBasicAuth) {
+            const credentials = encode(`${username}:${password}`);
+            lines.push(`request.AddHeader("Authorization", "Basic ${credentials}");`);
+        }
+        // Headers (skip an existing Authorization header when Basic auth from config takes precedence)
+        normalizedRequest.headers?.forEach((header) => {
+            if (hasBasicAuth && header.name.toLowerCase() === 'authorization') {
+                return;
+            }
+            lines.push(`request.AddHeader("${escapeCSharpString(header.name)}", "${escapeCSharpString(header.value)}");`);
+        });
+        // Cookies
+        normalizedRequest.cookies?.forEach((cookie) => {
+            lines.push(`request.AddCookie("${escapeCSharpString(cookie.name)}", "${escapeCSharpString(cookie.value)}", "/", "${escapeCSharpString(host)}");`);
+        });
+        // Body
+        if (normalizedRequest.postData) {
+            const { mimeType, text, params } = normalizedRequest.postData;
+            // Compare against the essence so parameterized values (e.g. a `boundary` or
+            // `charset`) still match the form, multipart, and octet-stream branches.
+            const essence = mimeType ? parseMimeType(mimeType).essence : undefined;
+            if (isJsonContentType(mimeType)) {
+                if (text) {
+                    let body = text;
+                    try {
+                        body = JSON.stringify(JSON.parse(text), null, 2);
+                    }
+                    catch {
+                        // Fall back to the raw text if it is not valid JSON
+                    }
+                    lines.push(`request.AddStringBody(${createRawStringLiteral(body)}, ContentType.Json);`);
+                }
+            }
+            else if (essence === 'application/x-www-form-urlencoded' && params) {
+                params.forEach((param) => {
+                    lines.push(`request.AddParameter("${escapeCSharpString(param.name)}", "${escapeCSharpString(param.value ?? '')}");`);
+                });
+            }
+            else if (essence === 'multipart/form-data' && params) {
+                params.forEach((param) => {
+                    if (param.fileName !== undefined) {
+                        if (param.contentType) {
+                            lines.push(`request.AddFile("${escapeCSharpString(param.name)}", "${escapeCSharpString(param.fileName)}", "${escapeCSharpString(param.contentType)}");`);
+                        }
+                        else {
+                            lines.push(`request.AddFile("${escapeCSharpString(param.name)}", "${escapeCSharpString(param.fileName)}");`);
+                        }
+                    }
+                    else {
+                        lines.push(`request.AddParameter("${escapeCSharpString(param.name)}", "${escapeCSharpString(param.value ?? '')}");`);
+                    }
+                });
+            }
+            else if (essence === 'application/octet-stream' && text) {
+                lines.push(`request.AddParameter("application/octet-stream", "${escapeCSharpString(text)}", ParameterType.RequestBody);`);
+            }
+            else if (text) {
+                lines.push(`request.AddParameter("${escapeCSharpString(mimeType ?? '')}", "${escapeCSharpString(text)}", ParameterType.RequestBody);`);
+            }
+        }
+        // Execute
+        lines.push('var response = await client.ExecuteAsync(request);');
+        return lines.join('\n');
     },
 };

package/dist/plugins/kotlin/okhttp/okhttp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"okhttp.d.ts","sourceRoot":"","sources":["../../../../src/plugins/kotlin/okhttp/okhttp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAKpD;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,MAQ1B,CAAA"}
+{"version":3,"file":"okhttp.d.ts","sourceRoot":"","sources":["../../../../src/plugins/kotlin/okhttp/okhttp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAcpD;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,MAqE1B,CAAA"}

package/dist/plugins/kotlin/okhttp/okhttp.js

@@ -1,5 +1,11 @@
-import { okhttp } from '../../../httpsnippet-lite/targets/kotlin/okhttp/client.js';
-import { convertWithHttpSnippetLite } from '../../../utils/convertWithHttpSnippetLite.js';
+import { escapeForDoubleQuotes } from '../../../httpsnippet-lite/helpers/escape.js';
+import { collectHeaders, joinUrlAndQuery, normalizeMethod, normalizeUrl } from '../../../libs/http.js';
+/** Methods OkHttp exposes as dedicated builder calls (anything else uses `.method(...)`). */
+const METHODS = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD'];
+/** Methods that accept a request body through their dedicated builder call. */
+const METHODS_WITH_BODY = ['POST', 'PUT', 'DELETE', 'PATCH'];
+/** Wrap a value in double quotes, escaping anything that would break the Kotlin string. */
+const quote = (value) => `"${escapeForDoubleQuotes(value)}"`;
 /**
  * kotlin/okhttp
  */
@@ -7,8 +13,62 @@ export const kotlinOkhttp = {
     target: 'kotlin',
     client: 'okhttp',
     title: 'OkHttp',
-    generate(request) {
-        // TODO: Write an own converter
-        return convertWithHttpSnippetLite(okhttp, request);
+    generate(request, configuration) {
+        const method = normalizeMethod(request?.method);
+        const url = normalizeUrl(joinUrlAndQuery(request?.url ?? '', request?.queryString));
+        const postData = request?.postData;
+        const lines = ['val client = OkHttpClient()', ''];
+        // Body. Whenever a `val body` is emitted below, `hasBody` flips so the request
+        // builder passes it through for both dedicated and custom method calls.
+        let hasBody = false;
+        if (postData?.mimeType === 'application/x-www-form-urlencoded' && postData.params) {
+            lines.push('val body = FormBody.Builder()');
+            postData.params.forEach((param) => {
+                lines.push(`  .addEncoded(${quote(param.name ?? '')}, ${quote(param.value ?? '')})`);
+            });
+            lines.push('  .build()', '');
+            hasBody = true;
+        }
+        else if (postData?.mimeType === 'multipart/form-data' && postData.params) {
+            lines.push('val body = MultipartBody.Builder()', '  .setType(MultipartBody.FORM)');
+            postData.params.forEach((param) => {
+                if (param.fileName !== undefined) {
+                    lines.push(`  .addFormDataPart(${quote(param.name ?? '')}, ${quote(param.fileName)}, RequestBody.create(MediaType.parse("application/octet-stream"), File(${quote(param.fileName)})))`);
+                }
+                else if (param.value !== undefined) {
+                    lines.push(`  .addFormDataPart(${quote(param.name ?? '')}, ${quote(param.value)})`);
+                }
+            });
+            lines.push('  .build()', '');
+            hasBody = true;
+        }
+        else if (postData) {
+            lines.push(`val mediaType = MediaType.parse(${quote(postData.mimeType ?? '')})`);
+            lines.push(`val body = RequestBody.create(mediaType, ${JSON.stringify(postData.text ?? '')})`);
+            hasBody = true;
+        }
+        // Request builder
+        lines.push('val request = Request.Builder()', `  .url(${quote(url)})`);
+        // Method, mirroring OkHttp's dedicated builder calls and the generic `.method(...)` fallback
+        const bodyArg = hasBody ? 'body' : 'null';
+        if (!METHODS.includes(method)) {
+            lines.push(`  .method(${quote(method)}, ${bodyArg})`);
+        }
+        else if (METHODS_WITH_BODY.includes(method)) {
+            lines.push(`  .${method.toLowerCase()}(${bodyArg})`);
+        }
+        else {
+            lines.push(`  .${method.toLowerCase()}()`);
+        }
+        // Basic auth, expressed through OkHttp's Credentials helper
+        if (configuration?.auth?.username && configuration?.auth?.password) {
+            lines.push(`  .addHeader("Authorization", Credentials.basic(${quote(configuration.auth.username)}, ${quote(configuration.auth.password)}))`);
+        }
+        // Headers, including cookies folded into a single Cookie header
+        collectHeaders(request?.headers, request?.cookies).forEach((header) => {
+            lines.push(`  .addHeader(${quote(header.name)}, ${quote(header.value)})`);
+        });
+        lines.push('  .build()', '', 'val response = client.newCall(request).execute()');
+        return lines.join('\n');
     },
 };

package/dist/plugins/objc/nsurlsession/nsurlsession.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nsurlsession.d.ts","sourceRoot":"","sources":["../../../../src/plugins/objc/nsurlsession/nsurlsession.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAKpD;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAQ9B,CAAA"}
+{"version":3,"file":"nsurlsession.d.ts","sourceRoot":"","sources":["../../../../src/plugins/objc/nsurlsession/nsurlsession.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAmEpD;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAsI9B,CAAA"}

package/dist/plugins/objc/nsurlsession/nsurlsession.js

@@ -1,5 +1,59 @@
-import { nsurlsession } from '../../../httpsnippet-lite/targets/objc/nsurlsession/client.js';
-import { convertWithHttpSnippetLite } from '../../../utils/convertWithHttpSnippetLite.js';
+import { collectHeaders, joinUrlAndQuery, normalizeMethod, normalizeUrl } from '../../../libs/http.js';
+/**
+ * Boundary used for multipart bodies. NSURLSession does not provide one, so we
+ * emit a stable placeholder the user can replace as needed.
+ */
+const MULTIPART_BOUNDARY = '---011000010111000001101001';
+/**
+ * Escapes a string so it can be safely embedded inside an Objective-C `@"..."`
+ * string literal.
+ */
+const objcStringLiteral = (value) => {
+    const escaped = value
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r')
+        .replace(/\t/g, '\\t');
+    return `@"${escaped}"`;
+};
+/**
+ * Renders a JavaScript value as an Objective-C object literal (NSDictionary,
+ * NSArray, NSNumber, ...). When `indentation` is set, nested key/value pairs are
+ * aligned under the opening brace for readability.
+ */
+const literalRepresentation = (value, indentation) => {
+    const join = indentation === undefined ? ', ' : `,\n   ${' '.repeat(indentation)}`;
+    switch (Object.prototype.toString.call(value)) {
+        case '[object Number]':
+            return `@${value}`;
+        case '[object Array]': {
+            const values = value.map((item) => literalRepresentation(item));
+            return `@[ ${values.join(join)} ]`;
+        }
+        case '[object Object]': {
+            const entries = Object.entries(value).map(([key, item]) => `@"${key}": ${literalRepresentation(item)}`);
+            return `@{ ${entries.join(join)} }`;
+        }
+        case '[object Boolean]':
+            return value ? '@YES' : '@NO';
+        default:
+            // Map JSON null/undefined to NSNull so NSJSONSerialization emits a real
+            // JSON `null` instead of an empty string.
+            if (value === null || value === undefined) {
+                return '[NSNull null]';
+            }
+            return objcStringLiteral(value.toString());
+    }
+};
+/**
+ * Declares and initializes an Objective-C object literal, for example
+ * `NSDictionary *headers = @{ @"a": @"b" };`
+ */
+const nsDeclaration = (nsClass, name, value) => {
+    const opening = `${nsClass} *${name} = `;
+    return `${opening}${literalRepresentation(value, opening.length)};`;
+};
 /**
  * objc/nsurlsession
  */
@@ -7,8 +61,73 @@ export const objcNsurlsession = {
     target: 'objc',
     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/Foundation.h>'];
+        // Headers (cookies are folded into a single Cookie header by collectHeaders)
+        const hasHeaders = headers.length > 0;
+        if (hasHeaders) {
+            const headersObject = Object.fromEntries(headers.map((header) => [header.name, header.value]));
+            lines.push('', nsDeclaration('NSDictionary', 'headers', headersObject));
+        }
+        // Body
+        let hasBody = false;
+        if (request.postData) {
+            const { mimeType, text, params } = request.postData;
+            if (mimeType === 'application/json' && text !== undefined) {
+                try {
+                    const parsed = JSON.parse(text);
+                    lines.push('', nsDeclaration('NSDictionary', 'parameters', parsed));
+                    lines.push('', 'NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];');
+                    hasBody = true;
+                }
+                catch {
+                    // Fall back to the raw text when the payload is not valid JSON.
+                    lines.push('', `NSData *postData = [${objcStringLiteral(text)} dataUsingEncoding:NSUTF8StringEncoding];`);
+                    hasBody = true;
+                }
+            }
+            else if (mimeType === 'application/x-www-form-urlencoded' && params?.length) {
+                hasBody = true;
+                const [head, ...tail] = params;
+                lines.push('', `NSMutableData *postData = [[NSMutableData alloc] initWithData:[${objcStringLiteral(`${encodeURIComponent(head.name)}=${encodeURIComponent(head.value ?? '')}`)} dataUsingEncoding:NSUTF8StringEncoding]];`);
+                tail.forEach((param) => {
+                    lines.push(`[postData appendData:[${objcStringLiteral(`&${encodeURIComponent(param.name)}=${encodeURIComponent(param.value ?? '')}`)} dataUsingEncoding:NSUTF8StringEncoding]];`);
+                });
+            }
+            else if (mimeType === 'multipart/form-data' && params?.length) {
+                hasBody = true;
+                lines.push('', nsDeclaration('NSArray', 'parameters', params), `NSString *boundary = @"${MULTIPART_BOUNDARY}";`, '', 'NSError *error;', 'NSMutableString *body = [NSMutableString string];', 'for (NSDictionary *param in parameters) {', '  [body appendFormat:@"--%@\\r\\n", boundary];', '  if (param[@"fileName"]) {', '    [body appendFormat:@"Content-Disposition:form-data; name=\\"%@\\"; filename=\\"%@\\"\\r\\n", param[@"name"], param[@"fileName"]];', '    [body appendFormat:@"Content-Type: %@\\r\\n\\r\\n", param[@"contentType"]];', '    [body appendFormat:@"%@", [NSString stringWithContentsOfFile:param[@"fileName"] encoding:NSUTF8StringEncoding error:&error]];', '    if (error) {', '      NSLog(@"%@", error);', '    }', '  } else {', '    [body appendFormat:@"Content-Disposition:form-data; name=\\"%@\\"\\r\\n\\r\\n", param[@"name"]];', '    [body appendFormat:@"%@", param[@"value"]];', '  }', '}', '[body appendFormat:@"\\r\\n--%@--\\r\\n", boundary];', 'NSData *postData = [body dataUsingEncoding:NSUTF8StringEncoding];');
+            }
+            else if (mimeType === 'application/octet-stream') {
+                hasBody = true;
+                lines.push('', `NSData *postData = [${objcStringLiteral(text ?? '')} dataUsingEncoding:NSUTF8StringEncoding];`);
+            }
+            else if (text !== undefined) {
+                hasBody = true;
+                lines.push('', `NSData *postData = [${objcStringLiteral(text)} dataUsingEncoding:NSUTF8StringEncoding];`);
+            }
+        }
+        // Request
+        lines.push('', `NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:${objcStringLiteral(url)}]`, '                                                      cachePolicy:NSURLRequestUseProtocolCachePolicy', '                                                  timeoutInterval:10.0];', `[request setHTTPMethod:@"${method}"];`);
+        if (hasHeaders) {
+            lines.push('[request setAllHTTPHeaderFields:headers];');
+        }
+        if (hasBody) {
+            lines.push('[request setHTTPBody:postData];');
+        }
+        // Basic auth
+        if (configuration?.auth?.username && configuration?.auth?.password) {
+            const credentials = objcStringLiteral(`${configuration.auth.username}:${configuration.auth.password}`);
+            lines.push(`NSData *authData = [${credentials} dataUsingEncoding:NSUTF8StringEncoding];`, 'NSString *authValue = [NSString stringWithFormat:@"Basic %@", [authData base64EncodedStringWithOptions:0]];', '[request setValue:authValue forHTTPHeaderField:@"Authorization"];');
+        }
+        // Session
+        lines.push('', 'NSURLSession *session = [NSURLSession sharedSession];', 'NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request', 'completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {', '  if (error) {', '    NSLog(@"%@", error);', '  } else {', '    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;', '    NSLog(@"%@", httpResponse);', '  }', '}];', '[dataTask resume];');
+        return lines.join('\n');
     },
 };

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":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAiBpD;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,MA8IvB,CAAA"}
+{"version":3,"file":"curl.d.ts","sourceRoot":"","sources":["../../../../src/plugins/shell/curl/curl.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAiBpD;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,MAiJvB,CAAA"}

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

@@ -29,9 +29,11 @@ export const shellCurl = {
         normalizedRequest.method = normalizedRequest.method.toUpperCase();
         // Build curl command parts
         const parts = ['curl'];
-        // URL (quote if has query parameters or special characters)
+        // Build the URL, joining extra query parameters with `&` when the URL already carries a query string
+        const baseUrl = normalizedRequest.url ?? '';
+        const separator = baseUrl.includes('?') ? '&' : '?';
         const queryString = normalizedRequest.queryString?.length
-            ? '?' +
+            ? separator +
                 normalizedRequest.queryString
                     .map((param) => {
                     // Ensure both name and value are fully URI encoded
@@ -39,9 +41,10 @@ export const shellCurl = {
                 })
                     .join('&')
             : '';
-        const url = `${normalizedRequest.url}${queryString}`;
-        const hasSpecialChars = /[\s<>[\]{}|\\^%$]/.test(url);
-        const urlPart = queryString || hasSpecialChars ? `'${url}'` : url;
+        const url = `${baseUrl}${queryString}`;
+        // Quote the URL whenever it contains anything the shell could interpret (spaces, query separators, globs, …)
+        const isShellSafe = /^[A-Za-z0-9._~:/%@+,=-]*$/.test(url);
+        const urlPart = isShellSafe ? url : `'${escapeSingleQuotes(url)}'`;
         parts[0] = `curl ${urlPart}`;
         // Method
         if (normalizedRequest.method !== 'GET') {