@scalar/snippetz 0.2.6 → 0.2.8

package/dist/_virtual/client24.js

@@ -0,0 +1,122 @@
+import { CodeBuilder } from '../httpsnippet-lite/dist/esm/helpers/code-builder.js';
+import { escapeForDoubleQuotes } from '../httpsnippet-lite/dist/esm/helpers/escape.js';
+
+/**
+ * @description
+ * HTTP code snippet generator for native Go.
+ *
+ * @author
+ * @montanaflynn
+ *
+ * for any questions or issues regarding the generated code snippet, please open an issue mentioning the author.
+ */
+const native = {
+    info: {
+        key: 'native',
+        title: 'NewRequest',
+        link: 'http://golang.org/pkg/net/http/#NewRequest',
+        description: 'Golang HTTP client request',
+    },
+    convert: ({ postData, method, allHeaders, fullUrl }, options = {}) => {
+        const { blank, push, join } = new CodeBuilder({ indent: '\t' });
+        const { showBoilerplate = true, checkErrors = false, printBody = true, timeout = -1, insecureSkipVerify = false, } = options;
+        const errorPlaceholder = checkErrors ? 'err' : '_';
+        const indent = showBoilerplate ? 1 : 0;
+        const errorCheck = () => {
+            if (checkErrors) {
+                push('if err != nil {', indent);
+                push('panic(err)', indent + 1);
+                push('}', indent);
+            }
+        };
+        // Create boilerplate
+        if (showBoilerplate) {
+            push('package main');
+            blank();
+            push('import (');
+            push('"fmt"', indent);
+            if (timeout > 0) {
+                push('"time"', indent);
+            }
+            if (insecureSkipVerify) {
+                push('"crypto/tls"', indent);
+            }
+            if (postData === null || postData === void 0 ? void 0 : postData.text) {
+                push('"strings"', indent);
+            }
+            push('"net/http"', indent);
+            if (printBody) {
+                push('"io"', indent);
+            }
+            push(')');
+            blank();
+            push('func main() {');
+            blank();
+        }
+        // Create an insecure transport for the client
+        if (insecureSkipVerify) {
+            push('insecureTransport := http.DefaultTransport.(*http.Transport).Clone()', indent);
+            push('insecureTransport.TLSClientConfig = &tls.Config{InsecureSkipVerify: true}', indent);
+        }
+        // Create client
+        const hasTimeout = timeout > 0;
+        const hasClient = hasTimeout || insecureSkipVerify;
+        const client = hasClient ? 'client' : 'http.DefaultClient';
+        if (hasClient) {
+            push('client := http.Client{', indent);
+            if (hasTimeout) {
+                push(`Timeout: time.Duration(${timeout} * time.Second),`, indent + 1);
+            }
+            if (insecureSkipVerify) {
+                push('Transport: insecureTransport,', indent + 1);
+            }
+            push('}', indent);
+            blank();
+        }
+        push(`url := "${fullUrl}"`, indent);
+        blank();
+        // If we have body content or not create the var and reader or nil
+        if (postData === null || postData === void 0 ? void 0 : postData.text) {
+            push(`payload := strings.NewReader(${JSON.stringify(postData.text)})`, indent);
+            blank();
+            push(`req, ${errorPlaceholder} := http.NewRequest("${method}", url, payload)`, indent);
+            blank();
+        }
+        else {
+            push(`req, ${errorPlaceholder} := http.NewRequest("${method}", url, nil)`, indent);
+            blank();
+        }
+        errorCheck();
+        // Add headers
+        if (Object.keys(allHeaders).length) {
+            Object.keys(allHeaders).forEach(key => {
+                push(`req.Header.Add("${key}", "${escapeForDoubleQuotes(allHeaders[key])}")`, indent);
+            });
+            blank();
+        }
+        // Make request
+        push(`res, ${errorPlaceholder} := ${client}.Do(req)`, indent);
+        errorCheck();
+        // Get Body
+        if (printBody) {
+            blank();
+            push('defer res.Body.Close()', indent);
+            push(`body, ${errorPlaceholder} := io.ReadAll(res.Body)`, indent);
+            errorCheck();
+        }
+        // Print it
+        blank();
+        push('fmt.Println(res)', indent);
+        if (printBody) {
+            push('fmt.Println(string(body))', indent);
+        }
+        // End main block
+        if (showBoilerplate) {
+            blank();
+            push('}');
+        }
+        return join();
+    },
+};
+
+export { native };

package/dist/_virtual/client25.js

@@ -0,0 +1,37 @@
+import { CodeBuilder } from '../httpsnippet-lite/dist/esm/helpers/code-builder.js';
+import { escapeForDoubleQuotes } from '../httpsnippet-lite/dist/esm/helpers/escape.js';
+import { getHeader } from '../httpsnippet-lite/dist/esm/helpers/headers.js';
+
+const restsharp = {
+    info: {
+        key: 'restsharp',
+        title: 'RestSharp',
+        link: 'http://restsharp.org/',
+        description: 'Simple REST and HTTP API Client for .NET',
+    },
+    convert: ({ allHeaders, method, fullUrl, headersObj, cookies, postData }) => {
+        const { push, join } = new CodeBuilder();
+        const isSupportedMethod = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'].includes(method.toUpperCase());
+        if (!isSupportedMethod) {
+            return 'Method not supported';
+        }
+        push(`var client = new RestClient("${fullUrl}");`);
+        push(`var request = new RestRequest(Method.${method.toUpperCase()});`);
+        // Add headers, including the cookies
+        Object.keys(headersObj).forEach(key => {
+            push(`request.AddHeader("${key}", "${escapeForDoubleQuotes(headersObj[key])}");`);
+        });
+        cookies === null || cookies === void 0 ? void 0 : cookies.forEach(({ name, value }) => {
+            push(`request.AddCookie("${name}", "${value}");`);
+        });
+        if (postData === null || postData === void 0 ? void 0 : postData.text) {
+            const header = getHeader(allHeaders, 'content-type');
+            const text = JSON.stringify(postData.text);
+            push(`request.AddParameter("${header}", ${text}, ParameterType.RequestBody);`);
+        }
+        push('IRestResponse response = client.Execute(request);');
+        return join();
+    },
+};
+
+export { restsharp };

package/dist/_virtual/client26.js

@@ -0,0 +1,154 @@
+import { CodeBuilder } from '../httpsnippet-lite/dist/esm/helpers/code-builder.js';
+import { escapeForDoubleQuotes } from '../httpsnippet-lite/dist/esm/helpers/escape.js';
+import { getHeader } from '../httpsnippet-lite/dist/esm/helpers/headers.js';
+
+const getDecompressionMethods = (allHeaders) => {
+    let acceptEncodings = getHeader(allHeaders, 'accept-encoding');
+    if (!acceptEncodings) {
+        return []; // no decompression
+    }
+    const supportedMethods = {
+        gzip: 'DecompressionMethods.GZip',
+        deflate: 'DecompressionMethods.Deflate',
+    };
+    const methods = [];
+    if (typeof acceptEncodings === 'string') {
+        acceptEncodings = [acceptEncodings];
+    }
+    acceptEncodings.forEach(acceptEncoding => {
+        acceptEncoding.split(',').forEach(encoding => {
+            const match = /\s*([^;\s]+)/.exec(encoding);
+            if (match) {
+                const method = supportedMethods[match[1]];
+                if (method) {
+                    methods.push(method);
+                }
+            }
+        });
+    });
+    return methods;
+};
+const httpclient = {
+    info: {
+        key: 'httpclient',
+        title: 'HttpClient',
+        link: 'https://docs.microsoft.com/en-us/dotnet/api/system.net.http.httpclient',
+        description: '.NET Standard HTTP Client',
+    },
+    convert: ({ allHeaders, postData, method, fullUrl }, options) => {
+        var _a, _b;
+        const opts = {
+            indent: '    ',
+            ...options,
+        };
+        const { push, join } = new CodeBuilder({ indent: opts.indent });
+        push('using System.Net.Http.Headers;');
+        let clienthandler = '';
+        const cookies = Boolean(allHeaders.cookie);
+        const decompressionMethods = getDecompressionMethods(allHeaders);
+        if (cookies || decompressionMethods.length) {
+            clienthandler = 'clientHandler';
+            push('var clientHandler = new HttpClientHandler');
+            push('{');
+            if (cookies) {
+                // enable setting the cookie header
+                push('UseCookies = false,', 1);
+            }
+            if (decompressionMethods.length) {
+                // enable decompression for supported methods
+                push(`AutomaticDecompression = ${decompressionMethods.join(' | ')},`, 1);
+            }
+            push('};');
+        }
+        push(`var client = new HttpClient(${clienthandler});`);
+        push('var request = new HttpRequestMessage');
+        push('{');
+        const methods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS', 'TRACE'];
+        method = method.toUpperCase();
+        if (method && methods.includes(method)) {
+            // buildin method
+            method = `HttpMethod.${method[0]}${method.substring(1).toLowerCase()}`;
+        }
+        else {
+            // custom method
+            method = `new HttpMethod("${method}")`;
+        }
+        push(`Method = ${method},`, 1);
+        push(`RequestUri = new Uri("${fullUrl}"),`, 1);
+        const headers = Object.keys(allHeaders).filter(header => {
+            switch (header.toLowerCase()) {
+                case 'content-type':
+                case 'content-length':
+                case 'accept-encoding':
+                    // skip these headers
+                    return false;
+                default:
+                    return true;
+            }
+        });
+        if (headers.length) {
+            push('Headers =', 1);
+            push('{', 1);
+            headers.forEach(key => {
+                push(`{ "${key}", "${escapeForDoubleQuotes(allHeaders[key])}" },`, 2);
+            });
+            push('},', 1);
+        }
+        if (postData === null || postData === void 0 ? void 0 : postData.text) {
+            const contentType = postData.mimeType;
+            switch (contentType) {
+                case 'application/x-www-form-urlencoded':
+                    push('Content = new FormUrlEncodedContent(new Dictionary<string, string>', 1);
+                    push('{', 1);
+                    (_a = postData.params) === null || _a === void 0 ? void 0 : _a.forEach(param => {
+                        push(`{ "${param.name}", "${param.value}" },`, 2);
+                    });
+                    push('}),', 1);
+                    break;
+                case 'multipart/form-data':
+                    push('Content = new MultipartFormDataContent', 1);
+                    push('{', 1);
+                    (_b = postData.params) === null || _b === void 0 ? void 0 : _b.forEach(param => {
+                        push(`new StringContent(${JSON.stringify(param.value || '')})`, 2);
+                        push('{', 2);
+                        push('Headers =', 3);
+                        push('{', 3);
+                        if (param.contentType) {
+                            push(`ContentType = new MediaTypeHeaderValue("${param.contentType}"),`, 4);
+                        }
+                        push('ContentDisposition = new ContentDispositionHeaderValue("form-data")', 4);
+                        push('{', 4);
+                        push(`Name = "${param.name}",`, 5);
+                        if (param.fileName) {
+                            push(`FileName = "${param.fileName}",`, 5);
+                        }
+                        push('}', 4);
+                        push('}', 3);
+                        push('},', 2);
+                    });
+                    push('},', 1);
+                    break;
+                default:
+                    push(`Content = new StringContent(${JSON.stringify((postData === null || postData === void 0 ? void 0 : postData.text) || '')})`, 1);
+                    push('{', 1);
+                    push('Headers =', 2);
+                    push('{', 2);
+                    push(`ContentType = new MediaTypeHeaderValue("${contentType}")`, 3);
+                    push('}', 2);
+                    push('}', 1);
+                    break;
+            }
+        }
+        push('};');
+        // send and read response
+        push('using (var response = await client.SendAsync(request))');
+        push('{');
+        push('response.EnsureSuccessStatusCode();', 1);
+        push('var body = await response.Content.ReadAsStringAsync();', 1);
+        push('Console.WriteLine(body);', 1);
+        push('}');
+        return join();
+    },
+};
+
+export { httpclient };

package/dist/_virtual/client27.js

@@ -0,0 +1,181 @@
+import { CodeBuilder } from '../httpsnippet-lite/dist/esm/helpers/code-builder.js';
+import { getHeaderName, getHeader } from '../httpsnippet-lite/dist/esm/helpers/headers.js';
+
+/**
+ * @description
+ * HTTP code snippet generator for Clojure using clj-http.
+ *
+ * @author
+ * @tggreene
+ *
+ * for any questions or issues regarding the generated code snippet, please open an issue mentioning the author.
+ */
+class Keyword {
+    constructor(name) {
+        this.name = '';
+        this.toString = () => `:${this.name}`;
+        this.name = name;
+    }
+}
+class File {
+    constructor(path) {
+        this.path = '';
+        this.toString = () => `(clojure.java.io/file "${this.path}")`;
+        this.path = path;
+    }
+}
+const jsType = (input) => {
+    if (input === undefined) {
+        return null;
+    }
+    if (input === null) {
+        return 'null';
+    }
+    return input.constructor.name.toLowerCase();
+};
+const objEmpty = (input) => {
+    if (jsType(input) === 'object') {
+        return Object.keys(input).length === 0;
+    }
+    return false;
+};
+const filterEmpty = (input) => {
+    Object.keys(input)
+        .filter(x => objEmpty(input[x]))
+        .forEach(x => {
+        delete input[x];
+    });
+    return input;
+};
+const padBlock = (padSize, input) => {
+    const padding = ' '.repeat(padSize);
+    return input.replace(/\n/g, `\n${padding}`);
+};
+const jsToEdn = (js) => {
+    switch (jsType(js)) {
+        case 'string':
+            return `"${js.replace(/"/g, '\\"')}"`;
+        case 'file':
+            return js.toString();
+        case 'keyword':
+            return js.toString();
+        case 'null':
+            return 'nil';
+        case 'regexp':
+            return `#"${js.source}"`;
+        case 'object': {
+            // simple vertical format
+            const obj = Object.keys(js)
+                .reduce((accumulator, key) => {
+                const val = padBlock(key.length + 2, jsToEdn(js[key]));
+                return `${accumulator}:${key} ${val}\n `;
+            }, '')
+                .trim();
+            return `{${padBlock(1, obj)}}`;
+        }
+        case 'array': {
+            // simple horizontal format
+            const arr = js
+                .reduce((accumulator, value) => `${accumulator} ${jsToEdn(value)}`, '')
+                .trim();
+            return `[${padBlock(1, arr)}]`;
+        }
+        default: // 'number' 'boolean'
+            return js.toString();
+    }
+};
+const clj_http = {
+    info: {
+        key: 'clj_http',
+        title: 'clj-http',
+        link: 'https://github.com/dakrone/clj-http',
+        description: 'An idiomatic clojure http client wrapping the apache client.',
+    },
+    convert: ({ queryObj, method, postData, url, allHeaders }, options) => {
+        const { push, join } = new CodeBuilder({ indent: options === null || options === void 0 ? void 0 : options.indent });
+        const methods = ['get', 'post', 'put', 'delete', 'patch', 'head', 'options'];
+        method = method.toLowerCase();
+        if (!methods.includes(method)) {
+            push('Method not supported');
+            return join();
+        }
+        const params = {
+            headers: allHeaders,
+            'query-params': queryObj,
+        };
+        switch (postData === null || postData === void 0 ? void 0 : postData.mimeType) {
+            case 'application/json':
+                {
+                    params['content-type'] = new Keyword('json');
+                    params['form-params'] = postData.jsonObj;
+                    const header = getHeaderName(params.headers, 'content-type');
+                    if (header) {
+                        delete params.headers[header];
+                    }
+                }
+                break;
+            case 'application/x-www-form-urlencoded':
+                {
+                    params['form-params'] = postData.paramsObj;
+                    const header = getHeaderName(params.headers, 'content-type');
+                    if (header) {
+                        delete params.headers[header];
+                    }
+                }
+                break;
+            case 'text/plain':
+                {
+                    params.body = postData.text;
+                    const header = getHeaderName(params.headers, 'content-type');
+                    if (header) {
+                        delete params.headers[header];
+                    }
+                }
+                break;
+            case 'multipart/form-data': {
+                if (postData.params) {
+                    params.multipart = postData.params.map(param => {
+                        if (param.fileName && !param.value) {
+                            return {
+                                name: param.name,
+                                content: new File(param.fileName),
+                            };
+                        }
+                        return {
+                            name: param.name,
+                            content: param.value,
+                        };
+                    });
+                    const header = getHeaderName(params.headers, 'content-type');
+                    if (header) {
+                        delete params.headers[header];
+                    }
+                }
+                break;
+            }
+        }
+        switch (getHeader(params.headers, 'accept')) {
+            case 'application/json':
+                {
+                    params.accept = new Keyword('json');
+                    const header = getHeaderName(params.headers, 'accept');
+                    if (header) {
+                        delete params.headers[header];
+                    }
+                }
+                break;
+        }
+        push("(require '[clj-http.client :as client])\n");
+        if (objEmpty(filterEmpty(params))) {
+            push(`(client/${method} "${url}")`);
+        }
+        else {
+            const padding = 11 + method.length + url.length;
+            const formattedParams = padBlock(padding, jsToEdn(filterEmpty(params)));
+            push(`(client/${method} "${url}" ${formattedParams})`);
+        }
+        return join();
+    },
+};
+
+export { clj_http };

package/dist/_virtual/client28.js

@@ -0,0 +1,43 @@
+import { CodeBuilder } from '../httpsnippet-lite/dist/esm/helpers/code-builder.js';
+import { escapeForDoubleQuotes } from '../httpsnippet-lite/dist/esm/helpers/escape.js';
+
+const libcurl = {
+    info: {
+        key: 'libcurl',
+        title: 'Libcurl',
+        link: 'http://curl.haxx.se/libcurl',
+        description: 'Simple REST and HTTP API Client for C',
+    },
+    convert: ({ method, fullUrl, headersObj, allHeaders, postData }) => {
+        const { push, blank, join } = new CodeBuilder();
+        push('CURL *hnd = curl_easy_init();');
+        blank();
+        push(`curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "${method.toUpperCase()}");`);
+        push(`curl_easy_setopt(hnd, CURLOPT_URL, "${fullUrl}");`);
+        // Add headers, including the cookies
+        const headers = Object.keys(headersObj);
+        // construct headers
+        if (headers.length) {
+            blank();
+            push('struct curl_slist *headers = NULL;');
+            headers.forEach(header => {
+                push(`headers = curl_slist_append(headers, "${header}: ${escapeForDoubleQuotes(headersObj[header])}");`);
+            });
+            push('curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);');
+        }
+        // construct cookies
+        if (allHeaders.cookie) {
+            blank();
+            push(`curl_easy_setopt(hnd, CURLOPT_COOKIE, "${allHeaders.cookie}");`);
+        }
+        if (postData === null || postData === void 0 ? void 0 : postData.text) {
+            blank();
+            push(`curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, ${JSON.stringify(postData.text)});`);
+        }
+        blank();
+        push('CURLcode ret = curl_easy_perform(hnd);');
+        return join();
+    },
+};
+
+export { libcurl };

package/dist/_virtual/client3.js

@@ -0,0 +1,113 @@
+import { CodeBuilder } from '../httpsnippet-lite/dist/esm/helpers/code-builder.js';
+import { quote } from '../httpsnippet-lite/dist/esm/helpers/shell.js';
+
+/**
+ * @description
+ * HTTP code snippet generator for the Shell using HTTPie.
+ *
+ * @author
+ * @AhmadNassri
+ *
+ * for any questions or issues regarding the generated code snippet, please open an issue mentioning the author.
+ */
+const httpie = {
+    info: {
+        key: 'httpie',
+        title: 'HTTPie',
+        link: 'http://httpie.org/',
+        description: 'a CLI, cURL-like tool for humans',
+    },
+    convert: ({ allHeaders, postData, queryObj, fullUrl, method, url }, options) => {
+        const opts = {
+            body: false,
+            cert: false,
+            headers: false,
+            indent: '  ',
+            pretty: false,
+            print: false,
+            queryParams: false,
+            short: false,
+            style: false,
+            timeout: false,
+            verbose: false,
+            verify: false,
+            ...options,
+        };
+        const { push, join, unshift } = new CodeBuilder({
+            indent: opts.indent,
+            // @ts-expect-error SEEMS LEGIT
+            join: opts.indent !== false ? ` \\\n${opts.indent}` : ' ',
+        });
+        let raw = false;
+        const flags = [];
+        if (opts.headers) {
+            flags.push(opts.short ? '-h' : '--headers');
+        }
+        if (opts.body) {
+            flags.push(opts.short ? '-b' : '--body');
+        }
+        if (opts.verbose) {
+            flags.push(opts.short ? '-v' : '--verbose');
+        }
+        if (opts.print) {
+            flags.push(`${opts.short ? '-p' : '--print'}=${opts.print}`);
+        }
+        if (opts.verify) {
+            flags.push(`--verify=${opts.verify}`);
+        }
+        if (opts.cert) {
+            flags.push(`--cert=${opts.cert}`);
+        }
+        if (opts.pretty) {
+            flags.push(`--pretty=${opts.pretty}`);
+        }
+        if (opts.style) {
+            flags.push(`--style=${opts.style}`);
+        }
+        if (opts.timeout) {
+            flags.push(`--timeout=${opts.timeout}`);
+        }
+        // construct query params
+        if (opts.queryParams) {
+            Object.keys(queryObj).forEach(name => {
+                const value = queryObj[name];
+                if (Array.isArray(value)) {
+                    value.forEach(val => {
+                        push(`${name}==${quote(val)}`);
+                    });
+                }
+                else {
+                    push(`${name}==${quote(value)}`);
+                }
+            });
+        }
+        // construct headers
+        Object.keys(allHeaders)
+            .sort()
+            .forEach(key => {
+            push(`${key}:${quote(allHeaders[key])}`);
+        });
+        if ((postData === null || postData === void 0 ? void 0 : postData.mimeType) === 'application/x-www-form-urlencoded') {
+            // construct post params
+            if (postData.params && postData.params.length) {
+                flags.push(opts.short ? '-f' : '--form');
+                postData.params.forEach(param => {
+                    push(`${param.name}=${quote(param.value)}`);
+                });
+            }
+        }
+        else {
+            raw = true;
+        }
+        const cliFlags = flags.length ? `${flags.join(' ')} ` : '';
+        url = quote(opts.queryParams ? url : fullUrl);
+        unshift(`http ${cliFlags}${method} ${url}`);
+        if (raw && (postData === null || postData === void 0 ? void 0 : postData.text)) {
+            const postDataText = quote(postData.text);
+            unshift(`echo ${postDataText} | `);
+        }
+        return join();
+    },
+};
+
+export { httpie };