@readme/httpsnippet 4.0.0 → 4.0.3

package/dist/targets/swift/helpers.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Create a string corresponding to a valid declaration and initialization of a Swift array or dictionary literal
+ *
+ * @param name Desired name of the instance
+ * @param parameters Key-value object of parameters to translate to a Swift object litearal
+ * @param opts Target options
+ * @return {string}
+ */
+export declare const literalDeclaration: <T, U>(name: string, parameters: T, opts: U) => string;
+/**
+ * Create a valid Swift string of a literal value according to its type.
+ *
+ * @param value Any JavaScript literal
+ * @param opts Target options
+ */
+export declare const literalRepresentation: <T, U>(value: T, opts: U, indentLevel?: number) => number | string;

package/dist/targets/swift/helpers.js

@@ -0,0 +1,80 @@
+"use strict";
+exports.__esModule = true;
+exports.literalRepresentation = exports.literalDeclaration = void 0;
+/**
+ * Create an string of given length filled with blank spaces
+ *
+ * @param length Length of the array to return
+ * @param str String to pad out with
+ */
+var buildString = function (length, str) { return str.repeat(length); };
+/**
+ * Create a string corresponding to a Dictionary or Array literal representation with pretty option and indentation.
+ */
+var concatArray = function (arr, pretty, indentation, indentLevel) {
+    var currentIndent = buildString(indentLevel, indentation);
+    var closingBraceIndent = buildString(indentLevel - 1, indentation);
+    var join = pretty ? ",\n".concat(currentIndent) : ', ';
+    if (pretty) {
+        return "[\n".concat(currentIndent).concat(arr.join(join), "\n").concat(closingBraceIndent, "]");
+    }
+    return "[".concat(arr.join(join), "]");
+};
+/**
+ * Create a string corresponding to a valid declaration and initialization of a Swift array or dictionary literal
+ *
+ * @param name Desired name of the instance
+ * @param parameters Key-value object of parameters to translate to a Swift object litearal
+ * @param opts Target options
+ * @return {string}
+ */
+var literalDeclaration = function (name, parameters, opts) {
+    return "let ".concat(name, " = ").concat((0, exports.literalRepresentation)(parameters, opts));
+};
+exports.literalDeclaration = literalDeclaration;
+/**
+ * Create a valid Swift string of a literal value according to its type.
+ *
+ * @param value Any JavaScript literal
+ * @param opts Target options
+ */
+var literalRepresentation = function (value, opts, indentLevel) {
+    indentLevel = indentLevel === undefined ? 1 : indentLevel + 1;
+    switch (Object.prototype.toString.call(value)) {
+        case '[object Number]':
+            return value;
+        case '[object Array]': {
+            // Don't prettify arrays nto not take too much space
+            var pretty_1 = false;
+            var valuesRepresentation = value.map(function (v) {
+                // Switch to prettify if the value is a dictionary with multiple keys
+                if (Object.prototype.toString.call(v) === '[object Object]') {
+                    pretty_1 = Object.keys(v).length > 1;
+                }
+                return (0, exports.literalRepresentation)(v, opts, indentLevel);
+            });
+            // @ts-expect-error needs better types
+            return concatArray(valuesRepresentation, pretty_1, opts.indent, indentLevel);
+        }
+        case '[object Object]': {
+            var keyValuePairs = [];
+            // eslint-disable-next-line guard-for-in, no-restricted-syntax
+            for (var key in value) {
+                keyValuePairs.push("\"".concat(key, "\": ").concat((0, exports.literalRepresentation)(value[key], opts, indentLevel)));
+            }
+            return concatArray(keyValuePairs, 
+            // @ts-expect-error needs better types
+            opts.pretty && keyValuePairs.length > 1, 
+            // @ts-expect-error needs better types
+            opts.indent, indentLevel);
+        }
+        case '[object Boolean]':
+            return value.toString();
+        default:
+            if (value === null || value === undefined) {
+                return '';
+            }
+            return "\"".concat(value.toString().replace(/"/g, '\\"'), "\"");
+    }
+};
+exports.literalRepresentation = literalRepresentation;

package/dist/targets/swift/nsurlsession/client.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @description
+ * HTTP code snippet generator for Swift using NSURLSession.
+ *
+ * @author
+ * @thibaultCha
+ *
+ * for any questions or issues regarding the generated code snippet, please open an issue mentioning the author.
+ */
+import type { Client } from '../../targets';
+export interface NsurlsessionOptions {
+    pretty?: boolean;
+    timeout?: number | string;
+}
+export declare const nsurlsession: Client<NsurlsessionOptions>;

package/dist/targets/swift/nsurlsession/client.js

@@ -0,0 +1,156 @@
+"use strict";
+/**
+ * @description
+ * HTTP code snippet generator for Swift using NSURLSession.
+ *
+ * @author
+ * @thibaultCha
+ *
+ * for any questions or issues regarding the generated code snippet, please open an issue mentioning the author.
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+exports.__esModule = true;
+exports.nsurlsession = void 0;
+var code_builder_1 = require("../../../helpers/code-builder");
+var helpers_1 = require("../helpers");
+exports.nsurlsession = {
+    info: {
+        key: 'nsurlsession',
+        title: 'NSURLSession',
+        link: 'https://developer.apple.com/library/mac/documentation/Foundation/Reference/NSURLSession_class/index.html',
+        description: "Foundation's NSURLSession request"
+    },
+    convert: function (_a, options) {
+        var allHeaders = _a.allHeaders, postData = _a.postData, fullUrl = _a.fullUrl, method = _a.method;
+        var opts = __assign({ indent: '  ', pretty: true, timeout: '10' }, options);
+        var _b = new code_builder_1.CodeBuilder({ indent: opts.indent }), push = _b.push, blank = _b.blank, join = _b.join;
+        // Markers for headers to be created as litteral objects and later be set on the NSURLRequest if exist
+        var req = {
+            hasHeaders: false,
+            hasBody: false
+        };
+        // We just want to make sure people understand that is the only dependency
+        push('import Foundation');
+        if (Object.keys(allHeaders).length) {
+            req.hasHeaders = true;
+            blank();
+            push((0, helpers_1.literalDeclaration)('headers', allHeaders, opts));
+        }
+        if (postData.text || postData.jsonObj || postData.params) {
+            req.hasBody = true;
+            switch (postData.mimeType) {
+                case 'application/x-www-form-urlencoded':
+                    // By appending parameters one by one in the resulting snippet,
+                    // we make it easier for the user to edit it according to his or her needs after pasting.
+                    // The user can just add/remove lines adding/removing body parameters.
+                    blank();
+                    if (postData.params) {
+                        var _c = __read(postData.params), head = _c[0], tail = _c.slice(1);
+                        push("let postData = NSMutableData(data: \"".concat(head.name, "=").concat(head.value, "\".data(using: String.Encoding.utf8)!)"));
+                        tail.forEach(function (_a) {
+                            var name = _a.name, value = _a.value;
+                            push("postData.append(\"&".concat(name, "=").concat(value, "\".data(using: String.Encoding.utf8)!)"));
+                        });
+                    }
+                    else {
+                        req.hasBody = false;
+                    }
+                    break;
+                case 'application/json':
+                    if (postData.jsonObj) {
+                        push("".concat((0, helpers_1.literalDeclaration)('parameters', postData.jsonObj, opts), " as [String : Any]"));
+                        blank();
+                        push('let postData = JSONSerialization.data(withJSONObject: parameters, options: [])');
+                    }
+                    break;
+                case 'multipart/form-data':
+                    /**
+                     * By appending multipart parameters one by one in the resulting snippet,
+                     * we make it easier for the user to edit it according to his or her needs after pasting.
+                     * The user can just edit the parameters NSDictionary or put this part of a snippet in a multipart builder method.
+                     */
+                    push((0, helpers_1.literalDeclaration)('parameters', postData.params, opts));
+                    blank();
+                    push("let boundary = \"".concat(postData.boundary, "\""));
+                    blank();
+                    push('var body = ""');
+                    push('var error: NSError? = nil');
+                    push('for param in parameters {');
+                    push('let paramName = param["name"]!', 1);
+                    push('body += "--\\(boundary)\\r\\n"', 1);
+                    push('body += "Content-Disposition:form-data; name=\\"\\(paramName)\\""', 1);
+                    push('if let filename = param["fileName"] {', 1);
+                    push('let contentType = param["content-type"]!', 2);
+                    push('let fileContent = String(contentsOfFile: filename, encoding: String.Encoding.utf8)', 2);
+                    push('if (error != nil) {', 2);
+                    push('print(error as Any)', 3);
+                    push('}', 2);
+                    push('body += "; filename=\\"\\(filename)\\"\\r\\n"', 2);
+                    push('body += "Content-Type: \\(contentType)\\r\\n\\r\\n"', 2);
+                    push('body += fileContent', 2);
+                    push('} else if let paramValue = param["value"] {', 1);
+                    push('body += "\\r\\n\\r\\n\\(paramValue)"', 2);
+                    push('}', 1);
+                    push('}');
+                    break;
+                default:
+                    blank();
+                    push("let postData = NSData(data: \"".concat(postData.text, "\".data(using: String.Encoding.utf8)!)"));
+            }
+        }
+        blank();
+        // NSURLRequestUseProtocolCachePolicy is the default policy, let's just always set it to avoid confusion.
+        push("let request = NSMutableURLRequest(url: NSURL(string: \"".concat(fullUrl, "\")! as URL,"));
+        push('                                        cachePolicy: .useProtocolCachePolicy,');
+        push(
+        // @ts-expect-error needs better types
+        "                                    timeoutInterval: ".concat(parseInt(opts.timeout, 10).toFixed(1), ")"));
+        push("request.httpMethod = \"".concat(method, "\""));
+        if (req.hasHeaders) {
+            push('request.allHTTPHeaderFields = headers');
+        }
+        if (req.hasBody) {
+            push('request.httpBody = postData as Data');
+        }
+        blank();
+        // Retrieving the shared session will be less verbose than creating a new one.
+        push('let session = URLSession.shared');
+        push('let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in');
+        push('if (error != nil) {', 1);
+        push('print(error as Any)', 2);
+        push('} else {', 1); // Casting the NSURLResponse to NSHTTPURLResponse so the user can see the status     .
+        push('let httpResponse = response as? HTTPURLResponse', 2);
+        push('print(httpResponse)', 2);
+        push('}', 1);
+        push('})');
+        blank();
+        push('dataTask.resume()');
+        return join();
+    }
+};

package/dist/targets/swift/target.d.ts

@@ -0,0 +1,2 @@
+import type { Target } from '../targets';
+export declare const swift: Target;

package/dist/targets/swift/target.js

@@ -0,0 +1,15 @@
+"use strict";
+exports.__esModule = true;
+exports.swift = void 0;
+var client_1 = require("./nsurlsession/client");
+exports.swift = {
+    info: {
+        key: 'swift',
+        title: 'Swift',
+        extname: '.swift',
+        "default": 'nsurlsession'
+    },
+    clientsById: {
+        nsurlsession: client_1.nsurlsession
+    }
+};

package/dist/targets/targets.d.ts

@@ -0,0 +1,52 @@
+import type { Merge } from 'type-fest';
+import type { CodeBuilderOptions } from '../helpers/code-builder';
+import type { Request } from '..';
+export declare type TargetId = keyof typeof targets;
+export declare type ClientId = string;
+export interface ClientInfo {
+    key: ClientId;
+    title: string;
+    link: string;
+    description: string;
+}
+export declare type Converter<T extends Record<string, any>> = (request: Request, options?: Merge<CodeBuilderOptions, T>) => string;
+export interface Client<T extends Record<string, any> = Record<string, any>> {
+    info: ClientInfo;
+    convert: Converter<T>;
+}
+export declare type Extension = `.${string}` | null;
+export interface TargetInfo {
+    key: TargetId;
+    title: string;
+    extname: Extension;
+    default: string;
+    cli?: string;
+}
+export interface Target {
+    info: TargetInfo;
+    clientsById: Record<ClientId, Client>;
+}
+export declare const targets: {
+    c: Target;
+    clojure: Target;
+    csharp: Target;
+    go: Target;
+    http: Target;
+    java: Target;
+    javascript: Target;
+    kotlin: Target;
+    node: Target;
+    objc: Target;
+    ocaml: Target;
+    php: Target;
+    powershell: Target;
+    python: Target;
+    r: Target;
+    ruby: Target;
+    shell: Target;
+    swift: Target;
+};
+export declare const isTarget: (target: Target) => target is Target;
+export declare const addTarget: (target: Target) => void;
+export declare const isClient: (client: Client) => client is Client<Record<string, any>>;
+export declare const addTargetClient: (targetId: TargetId, client: Client) => void;

package/dist/targets/targets.js

@@ -0,0 +1,130 @@
+"use strict";
+exports.__esModule = true;
+exports.addTargetClient = exports.isClient = exports.addTarget = exports.isTarget = exports.targets = void 0;
+var target_1 = require("./c/target");
+var target_2 = require("./clojure/target");
+var target_3 = require("./csharp/target");
+var target_4 = require("./go/target");
+var target_5 = require("./http/target");
+var target_6 = require("./java/target");
+var target_7 = require("./javascript/target");
+var target_8 = require("./kotlin/target");
+var target_9 = require("./node/target");
+var target_10 = require("./objc/target");
+var target_11 = require("./ocaml/target");
+var target_12 = require("./php/target");
+var target_13 = require("./powershell/target");
+var target_14 = require("./python/target");
+var target_15 = require("./r/target");
+var target_16 = require("./ruby/target");
+var target_17 = require("./shell/target");
+var target_18 = require("./swift/target");
+exports.targets = {
+    c: target_1.c,
+    clojure: target_2.clojure,
+    csharp: target_3.csharp,
+    go: target_4.go,
+    http: target_5.http,
+    java: target_6.java,
+    javascript: target_7.javascript,
+    kotlin: target_8.kotlin,
+    node: target_9.node,
+    objc: target_10.objc,
+    ocaml: target_11.ocaml,
+    php: target_12.php,
+    powershell: target_13.powershell,
+    python: target_14.python,
+    r: target_15.r,
+    ruby: target_16.ruby,
+    shell: target_17.shell,
+    swift: target_18.swift
+};
+var isTarget = function (target) {
+    if (typeof target !== 'object' || target === null || Array.isArray(target)) {
+        var got = target === null ? 'null' : Array.isArray(target) ? 'array' : typeof target;
+        throw new Error("you tried to add a target which is not an object, got type: \"".concat(got, "\""));
+    }
+    if (!Object.prototype.hasOwnProperty.call(target, 'info')) {
+        throw new Error('targets must contain an `info` object');
+    }
+    if (!Object.prototype.hasOwnProperty.call(target.info, 'key')) {
+        throw new Error('targets must have an `info` object with the property `key`');
+    }
+    if (!target.info.key) {
+        throw new Error('target key must be a unique string');
+    }
+    if (Object.prototype.hasOwnProperty.call(exports.targets, target.info.key)) {
+        throw new Error("a target already exists with this key, `".concat(target.info.key, "`"));
+    }
+    if (!Object.prototype.hasOwnProperty.call(target.info, 'title')) {
+        throw new Error('targets must have an `info` object with the property `title`');
+    }
+    if (!target.info.title) {
+        throw new Error('target title must be a non-zero-length string');
+    }
+    if (!Object.prototype.hasOwnProperty.call(target.info, 'extname')) {
+        throw new Error('targets must have an `info` object with the property `extname`');
+    }
+    if (!Object.prototype.hasOwnProperty.call(target, 'clientsById') ||
+        !target.clientsById ||
+        Object.keys(target.clientsById).length === 0) {
+        throw new Error("No clients provided in target ".concat(target.info.key, ".  You must provide the property `clientsById` containg your clients."));
+    }
+    if (!Object.prototype.hasOwnProperty.call(target.info, 'default')) {
+        throw new Error('targets must have an `info` object with the property `default`');
+    }
+    if (!Object.prototype.hasOwnProperty.call(target.clientsById, target.info["default"])) {
+        throw new Error("target ".concat(target.info.key, " is configured with a default client ").concat(target.info["default"], ", but no such client was found in the property `clientsById` (found ").concat(JSON.stringify(Object.keys(target.clientsById)), ")"));
+    }
+    Object.values(target.clientsById).forEach(exports.isClient);
+    return true;
+};
+exports.isTarget = isTarget;
+var addTarget = function (target) {
+    if (!(0, exports.isTarget)(target)) {
+        return;
+    }
+    exports.targets[target.info.key] = target;
+};
+exports.addTarget = addTarget;
+var isClient = function (client) {
+    if (!client) {
+        throw new Error('clients must be objects');
+    }
+    if (!Object.prototype.hasOwnProperty.call(client, 'info')) {
+        throw new Error('targets client must contain an `info` object');
+    }
+    if (!Object.prototype.hasOwnProperty.call(client.info, 'key')) {
+        throw new Error('targets client must have an `info` object with property `key`');
+    }
+    if (!client.info.key) {
+        throw new Error('client.info.key must contain an identifier unique to this target');
+    }
+    if (!Object.prototype.hasOwnProperty.call(client.info, 'title')) {
+        throw new Error('targets client must have an `info` object with property `title`');
+    }
+    if (!Object.prototype.hasOwnProperty.call(client.info, 'description')) {
+        throw new Error('targets client must have an `info` object with property `description`');
+    }
+    if (!Object.prototype.hasOwnProperty.call(client.info, 'link')) {
+        throw new Error('targets client must have an `info` object with property `link`');
+    }
+    if (!Object.prototype.hasOwnProperty.call(client, 'convert') || typeof client.convert !== 'function') {
+        throw new Error('targets client must have a `convert` property containing a conversion function');
+    }
+    return true;
+};
+exports.isClient = isClient;
+var addTargetClient = function (targetId, client) {
+    if (!(0, exports.isClient)(client)) {
+        return;
+    }
+    if (!Object.prototype.hasOwnProperty.call(exports.targets, targetId)) {
+        throw new Error("Sorry, but no ".concat(targetId, " target exists to add clients to"));
+    }
+    if (Object.prototype.hasOwnProperty.call(exports.targets[targetId], client.info.key)) {
+        throw new Error("the target ".concat(targetId, " already has a client with the key ").concat(client.info.key, ", please use a different key"));
+    }
+    exports.targets[targetId].clientsById[client.info.key] = client;
+};
+exports.addTargetClient = addTargetClient;

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "4.0.0",
+  "version": "4.0.3",
   "name": "@readme/httpsnippet",
   "description": "HTTP Request snippet generator for *most* languages",
   "homepage": "https://github.com/readmeio/httpsnippet",
@@ -40,8 +40,7 @@
     "node": ">=14"
   },
   "files": [
-    "bin",
-    "src"
+    "dist"
   ],
   "repository": {
     "type": "git",
@@ -49,9 +48,10 @@
   },
   "scripts": {
     "build": "tsc --build tsconfig.build.json",
-    "clean": "tsc --build tsconfig.build.json --clean",
+    "clean": "rm -rf dist/",
     "lint": "eslint .",
     "prebuild": "npm run clean",
+    "prepack": "npm run build",
     "pretest": "npm run lint",
     "prettier": "prettier --list-different --write \"./**/**.js\"",
     "test": "jest --coverage"

package/src/fixtures/customTarget.ts

@@ -1,14 +0,0 @@
-import type { Target } from '../targets/targets';
-import { request } from '../targets/node/request/client';
-
-export const customTarget = {
-  info: {
-    key: 'js-variant',
-    title: 'JavaScript Variant',
-    extname: '.js',
-    default: 'request',
-  },
-  clientsById: {
-    request,
-  },
-} as unknown as Target;

package/src/fixtures/files/hello.txt

@@ -1 +0,0 @@
-Hello World

package/src/fixtures/mimetypes.ts

@@ -1,84 +0,0 @@
-import type { Request } from '..';
-
-export const mimetypes = {
-  'multipart/mixed': {
-    method: 'POST',
-    url: 'https://httpbin.org/anything',
-    postData: {
-      mimeType: 'multipart/mixed',
-      text: '',
-    },
-  } as Request,
-
-  'multipart/related': {
-    method: 'POST',
-    url: 'https://httpbin.org/anything',
-    postData: {
-      mimeType: 'multipart/related',
-      text: '',
-    },
-  } as Request,
-
-  'multipart/form-data': {
-    method: 'POST',
-    url: 'https://httpbin.org/anything',
-    postData: {
-      mimeType: 'multipart/form-data',
-      text: '',
-    },
-  } as Request,
-
-  'multipart/alternative': {
-    method: 'POST',
-    url: 'https://httpbin.org/anything',
-    postData: {
-      mimeType: 'multipart/alternative',
-      text: '',
-    },
-  } as Request,
-
-  'application/x-www-form-urlencoded': {
-    method: 'POST',
-    url: 'https://httpbin.org/anything',
-    postData: {
-      mimeType: 'application/x-www-form-urlencoded',
-      text: '',
-    },
-  } as Request,
-
-  'text/json': {
-    method: 'POST',
-    url: 'https://httpbin.org/anything',
-    postData: {
-      mimeType: 'text/json',
-      text: '',
-    },
-  } as Request,
-
-  'text/x-json': {
-    method: 'POST',
-    url: 'https://httpbin.org/anything',
-    postData: {
-      mimeType: 'text/x-json',
-      text: '',
-    },
-  } as Request,
-
-  'application/x-json': {
-    method: 'POST',
-    url: 'https://httpbin.org/anything',
-    postData: {
-      mimeType: 'application/x-json',
-      text: '',
-    },
-  } as Request,
-
-  'invalid-json': {
-    method: 'POST',
-    url: 'https://httpbin.org/anything',
-    postData: {
-      mimeType: 'application/json',
-      text: 'foo/bar',
-    },
-  } as Request,
-};

package/src/fixtures/requests/application-form-encoded.js

@@ -1,68 +0,0 @@
-module.exports = {
-  log: {
-    version: '1.2',
-    creator: {
-      name: 'HTTPSnippet',
-      version: '1.0.0',
-    },
-    entries: [
-      {
-        request: {
-          method: 'POST',
-          url: 'https://httpbin.org/anything',
-          headers: [
-            {
-              name: 'content-type',
-              value: 'application/x-www-form-urlencoded',
-            },
-          ],
-          postData: {
-            mimeType: 'application/x-www-form-urlencoded',
-            params: [
-              {
-                name: 'foo',
-                value: 'bar',
-              },
-              {
-                name: 'hello',
-                value: 'world',
-              },
-            ],
-          },
-        },
-        response: {
-          status: 200,
-          statusText: 'OK',
-          httpVersion: 'HTTP/1.1',
-          headers: [
-            {
-              name: 'Content-Type',
-              value: 'application/json',
-            },
-          ],
-          content: {
-            size: -1,
-            mimeType: 'application/json',
-            text: JSON.stringify({
-              args: {},
-              data: '',
-              files: {},
-              form: {
-                foo: 'bar',
-                hello: 'world',
-              },
-              headers: {
-                'Content-Type': 'application/x-www-form-urlencoded',
-              },
-              json: null,
-              method: 'POST',
-              url: 'https://httpbin.org/anything',
-            }),
-          },
-          headersSize: -1,
-          bodySize: -1,
-        },
-      },
-    ],
-  },
-};