@scalar/snippetz 0.2.7 → 0.2.9

package/dist/httpsnippet-lite/esm/targets/clojure/clj_http/client.js

@@ -0,0 +1,189 @@
+import { CodeBuilder } from '../../../helpers/code-builder.js';
+import { getHeaderName, getHeader } from '../../../helpers/headers.js';
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+/**
+ * @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,
+        };
+        // Remove query string from URL if queryObj has parameters
+        if (queryObj && Object.keys(queryObj).length > 0) {
+            url = url.split('?')[0];
+        }
+        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/httpsnippet-lite/esm/targets/clojure/target.d.ts

@@ -0,0 +1,26 @@
+export declare const clojure: {
+    info: {
+        key: string;
+        title: string;
+        extname: string;
+        default: string;
+    };
+    clientsById: {
+        clj_http: {
+            info: {
+                key: string;
+                title: string;
+                link: string;
+                description: string;
+            };
+            convert: ({ queryObj, method, postData, url, allHeaders }: {
+                queryObj: any;
+                method: any;
+                postData: any;
+                url: any;
+                allHeaders: any;
+            }, options: any) => any;
+        };
+    };
+};
+//# sourceMappingURL=target.d.ts.map

package/dist/httpsnippet-lite/esm/targets/clojure/target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"target.d.ts","sourceRoot":"","sources":["../../../../../src/httpsnippet-lite/esm/targets/clojure/target.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;CAUnB,CAAA"}

package/dist/httpsnippet-lite/esm/targets/csharp/httpclient/client.d.ts

@@ -0,0 +1,15 @@
+export declare const httpclient: {
+    info: {
+        key: string;
+        title: string;
+        link: string;
+        description: string;
+    };
+    convert: ({ allHeaders, postData, method, fullUrl }: {
+        allHeaders: any;
+        postData: any;
+        method: any;
+        fullUrl: any;
+    }, options: any) => any;
+};
+//# sourceMappingURL=client.d.ts.map

package/dist/httpsnippet-lite/esm/targets/csharp/httpclient/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../../../src/httpsnippet-lite/esm/targets/csharp/httpclient/client.ts"],"names":[],"mappings":"AAgCA,eAAO,MAAM,UAAU;;;;;;;;;;;;;CAoJtB,CAAA"}

package/dist/httpsnippet-lite/esm/targets/csharp/httpclient/client.js

@@ -0,0 +1,169 @@
+import { CodeBuilder } from '../../../helpers/code-builder.js';
+import { escapeForDoubleQuotes } from '../../../helpers/escape.js';
+import { getHeader } from '../../../helpers/headers.js';
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+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) => {
+        let _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/httpsnippet-lite/esm/targets/csharp/restsharp/client.d.ts

@@ -0,0 +1,17 @@
+export declare const restsharp: {
+    info: {
+        key: string;
+        title: string;
+        link: string;
+        description: string;
+    };
+    convert: ({ allHeaders, method, fullUrl, headersObj, cookies, postData }: {
+        allHeaders: any;
+        method: any;
+        fullUrl: any;
+        headersObj: any;
+        cookies: any;
+        postData: any;
+    }) => any;
+};
+//# sourceMappingURL=client.d.ts.map

package/dist/httpsnippet-lite/esm/targets/csharp/restsharp/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../../../src/httpsnippet-lite/esm/targets/csharp/restsharp/client.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;CA4CrB,CAAA"}

package/dist/httpsnippet-lite/esm/targets/csharp/restsharp/client.js

@@ -0,0 +1,49 @@
+import { CodeBuilder } from '../../../helpers/code-builder.js';
+import { escapeForDoubleQuotes } from '../../../helpers/escape.js';
+import { getHeader } from '../../../helpers/headers.js';
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+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/httpsnippet-lite/esm/targets/csharp/target.d.ts

@@ -0,0 +1,41 @@
+export declare const csharp: {
+    info: {
+        key: string;
+        title: string;
+        extname: string;
+        default: string;
+    };
+    clientsById: {
+        httpclient: {
+            info: {
+                key: string;
+                title: string;
+                link: string;
+                description: string;
+            };
+            convert: ({ allHeaders, postData, method, fullUrl }: {
+                allHeaders: any;
+                postData: any;
+                method: any;
+                fullUrl: any;
+            }, options: any) => any;
+        };
+        restsharp: {
+            info: {
+                key: string;
+                title: string;
+                link: string;
+                description: string;
+            };
+            convert: ({ allHeaders, method, fullUrl, headersObj, cookies, postData }: {
+                allHeaders: any;
+                method: any;
+                fullUrl: any;
+                headersObj: any;
+                cookies: any;
+                postData: any;
+            }) => any;
+        };
+    };
+};
+//# sourceMappingURL=target.d.ts.map

package/dist/httpsnippet-lite/esm/targets/csharp/target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"target.d.ts","sourceRoot":"","sources":["../../../../../src/httpsnippet-lite/esm/targets/csharp/target.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWlB,CAAA"}

package/dist/httpsnippet-lite/esm/targets/go/native/client.d.ts

@@ -0,0 +1,15 @@
+export declare const native: {
+    info: {
+        key: string;
+        title: string;
+        link: string;
+        description: string;
+    };
+    convert: ({ postData, method, allHeaders, fullUrl }: {
+        postData: any;
+        method: any;
+        allHeaders: any;
+        fullUrl: any;
+    }, options?: {}) => any;
+};
+//# sourceMappingURL=client.d.ts.map

package/dist/httpsnippet-lite/esm/targets/go/native/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../../../src/httpsnippet-lite/esm/targets/go/native/client.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,MAAM;;;;;;;;;;;;;CAkIlB,CAAA"}

package/dist/httpsnippet-lite/esm/targets/go/native/client.js

@@ -0,0 +1,124 @@
+import { CodeBuilder } from '../../../helpers/code-builder.js';
+import { escapeForDoubleQuotes } from '../../../helpers/escape.js';
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+/**
+ * @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 };