@scalar/snippetz 0.2.7 → 0.2.9

package/dist/httpsnippet-lite/esm/targets/php/guzzle/client.js

@@ -0,0 +1,126 @@
+import { CodeBuilder } from '../../../helpers/code-builder.js';
+import { escapeForSingleQuotes } from '../../../helpers/escape.js';
+import { hasHeader, getHeader, getHeaderName } from '../../../helpers/headers.js';
+import { convertType } from '../helpers.js';
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+/**
+ * @description
+ * HTTP code snippet generator for PHP using Guzzle.
+ *
+ * @author @RobertoArruda
+ * @author @erunion
+ *
+ * for any questions or issues regarding the generated code snippet, please open an issue mentioning the author.
+ */
+const guzzle = {
+    info: {
+        key: 'guzzle',
+        title: 'Guzzle',
+        link: 'http://docs.guzzlephp.org/en/stable/',
+        description: 'PHP with Guzzle',
+    },
+    convert: ({ postData, fullUrl, method, cookies, headersObj }, options) => {
+        let _a;
+        const opts = {
+            closingTag: false,
+            indent: '  ',
+            noTags: false,
+            shortTags: false,
+            ...options,
+        };
+        const { push, blank, join } = new CodeBuilder({ indent: opts.indent });
+        const { code: requestCode, push: requestPush, join: requestJoin, } = new CodeBuilder({ indent: opts.indent });
+        if (!opts.noTags) {
+            push(opts.shortTags ? '<?' : '<?php');
+            blank();
+        }
+        switch (postData === null || postData === void 0 ? void 0 : postData.mimeType) {
+            case 'application/x-www-form-urlencoded':
+                requestPush(`'form_params' => ${convertType(postData.paramsObj, opts.indent + opts.indent, opts.indent)},`, 1);
+                break;
+            case 'multipart/form-data': {
+                const fields = [];
+                if (postData.params) {
+                    postData.params.forEach(function (param) {
+                        if (param.fileName) {
+                            const field = {
+                                name: param.name,
+                                filename: param.fileName,
+                                contents: param.value,
+                            };
+                            if (param.contentType) {
+                                field.headers = { 'Content-Type': param.contentType };
+                            }
+                            fields.push(field);
+                        }
+                        else if (param.value) {
+                            fields.push({
+                                name: param.name,
+                                contents: param.value,
+                            });
+                        }
+                    });
+                }
+                if (fields.length) {
+                    requestPush(`'multipart' => ${convertType(fields, opts.indent + opts.indent, opts.indent)}`, 1);
+                    // Guzzle adds its own boundary for multipart requests.
+                    if (hasHeader(headersObj, 'content-type')) {
+                        if ((_a = getHeader(headersObj, 'content-type')) === null ||
+                            _a === void 0
+                            ? void 0
+                            : _a.indexOf('boundary')) {
+                            const headerName = getHeaderName(headersObj, 'content-type');
+                            if (headerName) {
+                                delete headersObj[headerName];
+                            }
+                        }
+                    }
+                }
+                break;
+            }
+            default:
+                if (postData === null || postData === void 0 ? void 0 : postData.text) {
+                    requestPush(`'body' => ${convertType(postData.text)},`, 1);
+                }
+        }
+        // construct headers
+        const headers = Object.keys(headersObj)
+            .sort()
+            .map(function (key) {
+            return `${opts.indent}${opts.indent}'${key}' => '${escapeForSingleQuotes(headersObj[key])}',`;
+        });
+        // construct cookies
+        const cookieString = cookies
+            .map((cookie) => `${encodeURIComponent(cookie.name)}=${encodeURIComponent(cookie.value)}`)
+            .join('; ');
+        if (cookieString.length) {
+            headers.push(`${opts.indent}${opts.indent}'cookie' => '${escapeForSingleQuotes(cookieString)}',`);
+        }
+        if (headers.length) {
+            requestPush("'headers' => [", 1);
+            requestPush(headers.join('\n'));
+            requestPush('],', 1);
+        }
+        push('$client = new \\GuzzleHttp\\Client();');
+        blank();
+        if (requestCode.length) {
+            push(`$response = $client->request('${method}', '${fullUrl}', [`);
+            push(requestJoin());
+            push(']);');
+        }
+        else {
+            push(`$response = $client->request('${method}', '${fullUrl}');`);
+        }
+        blank();
+        push('echo $response->getBody();');
+        if (!opts.noTags && opts.closingTag) {
+            blank();
+            push('?>');
+        }
+        return join();
+    },
+};
+
+export { guzzle };

package/dist/httpsnippet-lite/esm/targets/php/helpers.d.ts

@@ -0,0 +1,3 @@
+export declare const convertType: (obj: any, indent: any, lastIndent: any) => any;
+export declare const supportedMethods: string[];
+//# sourceMappingURL=helpers.d.ts.map

package/dist/httpsnippet-lite/esm/targets/php/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../../../src/httpsnippet-lite/esm/targets/php/helpers.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW,iDAgCvB,CAAA;AACD,eAAO,MAAM,gBAAgB,UA4B5B,CAAA"}

package/dist/httpsnippet-lite/esm/targets/php/helpers.js

@@ -0,0 +1,37 @@
+import { escapeString } from '../../helpers/escape.js';
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+const convertType = (obj, indent, lastIndent) => {
+    lastIndent = lastIndent || '';
+    indent = indent || '';
+    switch (Object.prototype.toString.call(obj)) {
+        case '[object Null]':
+            return 'null';
+        case '[object Undefined]':
+            return 'null';
+        case '[object String]':
+            return `'${escapeString(obj, { delimiter: "'", escapeNewlines: false })}'`;
+        case '[object Number]':
+            return obj.toString();
+        case '[object Array]': {
+            const contents = obj
+                .map((item) => convertType(item, `${indent}${indent}`, indent))
+                .join(`,\n${indent}`);
+            return `[\n${indent}${contents}\n${lastIndent}]`;
+        }
+        case '[object Object]': {
+            const result = [];
+            for (const i in obj) {
+                if (Object.prototype.hasOwnProperty.call(obj, i)) {
+                    result.push(`${convertType(i, indent)} => ${convertType(obj[i], `${indent}${indent}`, indent)}`);
+                }
+            }
+            return `[\n${indent}${result.join(`,\n${indent}`)}\n${lastIndent}]`;
+        }
+        default:
+            return 'null';
+    }
+};
+
+export { convertType };

package/dist/httpsnippet-lite/esm/targets/php/http1/client.d.ts

@@ -0,0 +1,17 @@
+export declare const http1: {
+    info: {
+        key: string;
+        title: string;
+        link: string;
+        description: string;
+    };
+    convert: ({ method, url, postData, queryObj, headersObj, cookiesObj }: {
+        method: any;
+        url: any;
+        postData: any;
+        queryObj: any;
+        headersObj: any;
+        cookiesObj: any;
+    }, options?: {}) => any;
+};
+//# sourceMappingURL=client.d.ts.map

package/dist/httpsnippet-lite/esm/targets/php/http1/client.d.ts.map

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

package/dist/httpsnippet-lite/esm/targets/php/http2/client.d.ts

@@ -0,0 +1,17 @@
+export declare const http2: {
+    info: {
+        key: string;
+        title: string;
+        link: string;
+        description: string;
+    };
+    convert: ({ postData, headersObj, method, queryObj, cookiesObj, url }: {
+        postData: any;
+        headersObj: any;
+        method: any;
+        queryObj: any;
+        cookiesObj: any;
+        url: any;
+    }, options?: {}) => any;
+};
+//# sourceMappingURL=client.d.ts.map

package/dist/httpsnippet-lite/esm/targets/php/http2/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../../../src/httpsnippet-lite/esm/targets/php/http2/client.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;CAgIjB,CAAA"}

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

@@ -0,0 +1,75 @@
+export declare const php: {
+    info: {
+        key: string;
+        title: string;
+        extname: string;
+        default: string;
+    };
+    clientsById: {
+        curl: {
+            info: {
+                key: string;
+                title: string;
+                link: string;
+                description: string;
+            };
+            convert: ({ uriObj, postData, fullUrl, method, httpVersion, cookies, headersObj }: {
+                uriObj: any;
+                postData: any;
+                fullUrl: any;
+                method: any;
+                httpVersion: any;
+                cookies: any;
+                headersObj: any;
+            }, options?: {}) => any;
+        };
+        guzzle: {
+            info: {
+                key: string;
+                title: string;
+                link: string;
+                description: string;
+            };
+            convert: ({ postData, fullUrl, method, cookies, headersObj }: {
+                postData: any;
+                fullUrl: any;
+                method: any;
+                cookies: any;
+                headersObj: any;
+            }, options: any) => any;
+        };
+        http1: {
+            info: {
+                key: string;
+                title: string;
+                link: string;
+                description: string;
+            };
+            convert: ({ method, url, postData, queryObj, headersObj, cookiesObj }: {
+                method: any;
+                url: any;
+                postData: any;
+                queryObj: any;
+                headersObj: any;
+                cookiesObj: any;
+            }, options?: {}) => any;
+        };
+        http2: {
+            info: {
+                key: string;
+                title: string;
+                link: string;
+                description: string;
+            };
+            convert: ({ postData, headersObj, method, queryObj, cookiesObj, url }: {
+                postData: any;
+                headersObj: any;
+                method: any;
+                queryObj: any;
+                cookiesObj: any;
+                url: any;
+            }, options?: {}) => any;
+        };
+    };
+};
+//# sourceMappingURL=target.d.ts.map

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

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

package/dist/httpsnippet-lite/esm/targets/powershell/common.d.ts

@@ -0,0 +1,10 @@
+export declare const generatePowershellConvert: (command: any) => ({ method, headersObj, cookies, uriObj, fullUrl, postData, allHeaders, }: {
+    method: any;
+    headersObj: any;
+    cookies: any;
+    uriObj: any;
+    fullUrl: any;
+    postData: any;
+    allHeaders: any;
+}) => any;
+//# sourceMappingURL=common.d.ts.map

package/dist/httpsnippet-lite/esm/targets/powershell/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../../../src/httpsnippet-lite/esm/targets/powershell/common.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,yBAAyB;;;;;;;;SA4DrC,CAAA"}

package/dist/httpsnippet-lite/esm/targets/powershell/common.js

@@ -0,0 +1,53 @@
+import { CodeBuilder } from '../../helpers/code-builder.js';
+import { escapeString } from '../../helpers/escape.js';
+import { getHeader } from '../../helpers/headers.js';
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+const generatePowershellConvert = (command) => {
+    const convert = ({ method, headersObj, cookies, uriObj, fullUrl, postData, allHeaders, }) => {
+        const { push, join } = new CodeBuilder();
+        const methods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'];
+        if (!methods.includes(method.toUpperCase())) {
+            return 'Method not supported';
+        }
+        const commandOptions = [];
+        // Add headers, including the cookies
+        const headers = Object.keys(headersObj);
+        // construct headers
+        if (headers.length) {
+            push('$headers=@{}');
+            headers.forEach((key) => {
+                if (key !== 'connection') {
+                    // Not allowed
+                    push(`$headers.Add("${key}", "${escapeString(headersObj[key], { escapeChar: '`' })}")`);
+                }
+            });
+            commandOptions.push('-Headers $headers');
+        }
+        // construct cookies
+        if (cookies.length) {
+            push('$session = New-Object Microsoft.PowerShell.Commands.WebRequestSession');
+            cookies.forEach((cookie) => {
+                push('$cookie = New-Object System.Net.Cookie');
+                push(`$cookie.Name = '${cookie.name}'`);
+                push(`$cookie.Value = '${cookie.value}'`);
+                push(`$cookie.Domain = '${uriObj.host}'`);
+                push('$session.Cookies.Add($cookie)');
+            });
+            commandOptions.push('-WebSession $session');
+        }
+        if (postData === null || postData === void 0 ? void 0 : postData.text) {
+            commandOptions.push(`-ContentType '${escapeString(getHeader(allHeaders, 'content-type'), {
+                delimiter: "'",
+                escapeChar: '`',
+            })}'`);
+            commandOptions.push(`-Body '${postData.text}'`);
+        }
+        push(`$response = ${command} -Uri '${fullUrl}' -Method ${method} ${commandOptions.join(' ')}`);
+        return join();
+    };
+    return convert;
+};
+
+export { generatePowershellConvert };

package/dist/httpsnippet-lite/esm/targets/powershell/restmethod/client.d.ts

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

package/dist/httpsnippet-lite/esm/targets/powershell/restmethod/client.d.ts.map

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

package/dist/httpsnippet-lite/esm/targets/powershell/restmethod/client.js

@@ -0,0 +1,15 @@
+import { generatePowershellConvert } from '../common.js';
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+const restmethod = {
+    info: {
+        key: 'restmethod',
+        title: 'Invoke-RestMethod',
+        link: 'https://docs.microsoft.com/en-us/powershell/module/Microsoft.PowerShell.Utility/Invoke-RestMethod',
+        description: 'Powershell Invoke-RestMethod client',
+    },
+    convert: generatePowershellConvert('Invoke-RestMethod'),
+};
+
+export { restmethod };

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

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

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

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

package/dist/httpsnippet-lite/esm/targets/powershell/webrequest/client.d.ts

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

package/dist/httpsnippet-lite/esm/targets/powershell/webrequest/client.d.ts.map

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

package/dist/httpsnippet-lite/esm/targets/powershell/webrequest/client.js

@@ -0,0 +1,15 @@
+import { generatePowershellConvert } from '../common.js';
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+const webrequest = {
+    info: {
+        key: 'webrequest',
+        title: 'Invoke-WebRequest',
+        link: 'https://docs.microsoft.com/en-us/powershell/module/Microsoft.PowerShell.Utility/Invoke-WebRequest',
+        description: 'Powershell Invoke-WebRequest client',
+    },
+    convert: generatePowershellConvert('Invoke-WebRequest'),
+};
+
+export { webrequest };

package/dist/httpsnippet-lite/esm/targets/python/helpers.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Create a valid Python string of a literal value according to its type.
+ *
+ * @param {*} value Any JavaScript literal
+ * @param {object} opts Target options
+ * @return {string}
+ */
+export declare const literalRepresentation: (value: any, opts: any, indentLevel: any) => any;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/httpsnippet-lite/esm/targets/python/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../../../src/httpsnippet-lite/esm/targets/python/helpers.ts"],"names":[],"mappings":"AAoBA;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,kDA+CjC,CAAA"}

package/dist/httpsnippet-lite/esm/targets/python/helpers.js

@@ -0,0 +1,63 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+/**
+ * Create a string corresponding to a Dictionary or Array literal representation with pretty option
+ * and indentation.
+ */
+function concatValues(concatType, values, pretty, indentation, indentLevel) {
+    const currentIndent = indentation.repeat(indentLevel);
+    const closingBraceIndent = indentation.repeat(indentLevel - 1);
+    const join = pretty ? `,\n${currentIndent}` : ', ';
+    const openingBrace = concatType === 'object' ? '{' : '[';
+    const closingBrace = concatType === 'object' ? '}' : ']';
+    if (pretty) {
+        return `${openingBrace}\n${currentIndent}${values.join(join)}\n${closingBraceIndent}${closingBrace}`;
+    }
+    if (concatType === 'object' && values.length > 0) {
+        return `${openingBrace} ${values.join(join)} ${closingBrace}`;
+    }
+    return `${openingBrace}${values.join(join)}${closingBrace}`;
+}
+/**
+ * Create a valid Python string of a literal value according to its type.
+ *
+ * @param {*} value Any JavaScript literal
+ * @param {object} opts Target options
+ * @return {string}
+ */
+const literalRepresentation = (value, opts, indentLevel) => {
+    indentLevel = indentLevel === undefined ? 1 : indentLevel + 1;
+    switch (Object.prototype.toString.call(value)) {
+        case '[object Number]':
+            return value;
+        case '[object Array]': {
+            let pretty = false;
+            const valuesRepresentation = value.map((v) => {
+                // Switch to prettify if the value is a dictionary with multiple keys
+                if (Object.prototype.toString.call(v) === '[object Object]') {
+                    pretty = Object.keys(v).length > 1;
+                }
+                return literalRepresentation(v, opts, indentLevel);
+            });
+            return concatValues('array', valuesRepresentation, pretty, opts.indent, indentLevel);
+        }
+        case '[object Object]': {
+            const keyValuePairs = [];
+            for (const key in value) {
+                keyValuePairs.push(`"${key}": ${literalRepresentation(value[key], opts, indentLevel)}`);
+            }
+            return concatValues('object', keyValuePairs, opts.pretty && keyValuePairs.length > 1, opts.indent, indentLevel);
+        }
+        case '[object Null]':
+            return 'None';
+        case '[object Boolean]':
+            return value ? 'True' : 'False';
+        default:
+            if (value === null || value === undefined) {
+                return '';
+            }
+            return `"${value.toString().replace(/"/g, '\\"')}"`;
+    }
+};
+
+export { literalRepresentation };

package/dist/httpsnippet-lite/esm/targets/python/python3/client.d.ts

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

package/dist/httpsnippet-lite/esm/targets/python/python3/client.d.ts.map

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