@ps-aux/api-client-angular 0.1.0-rc1

package/dist/AngularApiHttpClient.d.ts

@@ -0,0 +1,5 @@
+import { HttpClient as AngularHttpClient } from '@angular/common/http';
+import { UrlConverter, ObservableHttpClient } from '@ps-aux/api-client-common';
+export declare const qsUrlConverter: () => UrlConverter;
+export declare const springBootUrlConverter: () => UrlConverter;
+export declare const createHttpClient: (client: AngularHttpClient, urlConverter?: UrlConverter) => ObservableHttpClient;

package/dist/api-client-angular/src/AngularApiHttpClient.d.ts

@@ -0,0 +1,3 @@
+import { HttpClient as AngularHttpClient } from '@angular/common/http';
+import { HttpClient } from './types';
+export declare const createHttpClient: (client: AngularHttpClient) => HttpClient;

package/dist/api-client-angular/src/index.d.ts

@@ -0,0 +1 @@
+export { createHttpClient } from './AngularApiHttpClient';

package/dist/api-client-angular/src/serializeQuery.d.ts

@@ -0,0 +1,2 @@
+export declare const serializeQuery: (obj: any) => any;
+export declare const flattenObject: (obj: any, prefix?: string) => any;

package/dist/api-client-angular/src/types.d.ts

@@ -0,0 +1,20 @@
+import { Observable } from 'rxjs';
+export type ContentType = {};
+export type RequestParams = {};
+export declare const ContentType: {
+    Json: string;
+    FormData: string;
+};
+export type Request = {
+    path: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    format?: 'json';
+    query?: any;
+    body?: any;
+    type?: string;
+    secure?: boolean;
+    responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
+};
+export type HttpClient<Any = any> = {
+    request: <Data, A = any>(req: Request) => Observable<Data>;
+};

package/dist/api-client-common/src/index.d.ts

@@ -0,0 +1 @@
+export declare const myFun: (f: string) => string;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { createHttpClient, springBootUrlConverter, qsUrlConverter } from './AngularApiHttpClient';

package/dist/index.esm.js

@@ -0,0 +1,334 @@
+import { map } from 'rxjs';
+import qs from 'qs';
+
+const { isArray } = Array;
+
+function fromPairs(listOfPairs){
+  const toReturn = {};
+  listOfPairs.forEach(([ prop, value ]) => toReturn[ prop ] = value);
+
+  return toReturn
+}
+
+function partitionObject(predicate, iterable){
+  const yes = {};
+  const no = {};
+  Object.entries(iterable).forEach(([ prop, value ]) => {
+    if (predicate(value, prop)){
+      yes[ prop ] = value;
+    } else {
+      no[ prop ] = value;
+    }
+  });
+
+  return [ yes, no ]
+}
+
+function partitionArray(
+  predicate, list, indexed = false
+){
+  const yes = [];
+  const no = [];
+  let counter = -1;
+
+  while (counter++ < list.length - 1){
+    if (
+      indexed ? predicate(list[ counter ], counter) : predicate(list[ counter ])
+    ){
+      yes.push(list[ counter ]);
+    } else {
+      no.push(list[ counter ]);
+    }
+  }
+
+  return [ yes, no ]
+}
+
+function partition(predicate, iterable){
+  if (arguments.length === 1){
+    return listHolder => partition(predicate, listHolder)
+  }
+  if (!isArray(iterable)) return partitionObject(predicate, iterable)
+
+  return partitionArray(predicate, iterable)
+}
+
+var flat = flatten$1;
+flatten$1.flatten = flatten$1;
+flatten$1.unflatten = unflatten;
+
+function isBuffer (obj) {
+  return obj &&
+    obj.constructor &&
+    (typeof obj.constructor.isBuffer === 'function') &&
+    obj.constructor.isBuffer(obj)
+}
+
+function keyIdentity (key) {
+  return key
+}
+
+function flatten$1 (target, opts) {
+  opts = opts || {};
+
+  const delimiter = opts.delimiter || '.';
+  const maxDepth = opts.maxDepth;
+  const transformKey = opts.transformKey || keyIdentity;
+  const output = {};
+
+  function step (object, prev, currentDepth) {
+    currentDepth = currentDepth || 1;
+    Object.keys(object).forEach(function (key) {
+      const value = object[key];
+      const isarray = opts.safe && Array.isArray(value);
+      const type = Object.prototype.toString.call(value);
+      const isbuffer = isBuffer(value);
+      const isobject = (
+        type === '[object Object]' ||
+        type === '[object Array]'
+      );
+
+      const newKey = prev
+        ? prev + delimiter + transformKey(key)
+        : transformKey(key);
+
+      if (!isarray && !isbuffer && isobject && Object.keys(value).length &&
+        (!opts.maxDepth || currentDepth < maxDepth)) {
+        return step(value, newKey, currentDepth + 1)
+      }
+
+      output[newKey] = value;
+    });
+  }
+
+  step(target);
+
+  return output
+}
+
+function unflatten (target, opts) {
+  opts = opts || {};
+
+  const delimiter = opts.delimiter || '.';
+  const overwrite = opts.overwrite || false;
+  const transformKey = opts.transformKey || keyIdentity;
+  const result = {};
+
+  const isbuffer = isBuffer(target);
+  if (isbuffer || Object.prototype.toString.call(target) !== '[object Object]') {
+    return target
+  }
+
+  // safely ensure that the key is
+  // an integer.
+  function getkey (key) {
+    const parsedKey = Number(key);
+
+    return (
+      isNaN(parsedKey) ||
+      key.indexOf('.') !== -1 ||
+      opts.object
+    ) ? key
+      : parsedKey
+  }
+
+  function addKeys (keyPrefix, recipient, target) {
+    return Object.keys(target).reduce(function (result, key) {
+      result[keyPrefix + delimiter + key] = target[key];
+
+      return result
+    }, recipient)
+  }
+
+  function isEmpty (val) {
+    const type = Object.prototype.toString.call(val);
+    const isArray = type === '[object Array]';
+    const isObject = type === '[object Object]';
+
+    if (!val) {
+      return true
+    } else if (isArray) {
+      return !val.length
+    } else if (isObject) {
+      return !Object.keys(val).length
+    }
+  }
+
+  target = Object.keys(target).reduce(function (result, key) {
+    const type = Object.prototype.toString.call(target[key]);
+    const isObject = (type === '[object Object]' || type === '[object Array]');
+    if (!isObject || isEmpty(target[key])) {
+      result[key] = target[key];
+      return result
+    } else {
+      return addKeys(
+        key,
+        result,
+        flatten$1(target[key], opts)
+      )
+    }
+  }, {});
+
+  Object.keys(target).forEach(function (key) {
+    const split = key.split(delimiter).map(transformKey);
+    let key1 = getkey(split.shift());
+    let key2 = getkey(split[0]);
+    let recipient = result;
+
+    while (key2 !== undefined) {
+      if (key1 === '__proto__') {
+        return
+      }
+
+      const type = Object.prototype.toString.call(recipient[key1]);
+      const isobject = (
+        type === '[object Object]' ||
+        type === '[object Array]'
+      );
+
+      // do not write over falsey, non-undefined values if overwrite is false
+      if (!overwrite && !isobject && typeof recipient[key1] !== 'undefined') {
+        return
+      }
+
+      if ((overwrite && !isobject) || (!overwrite && recipient[key1] == null)) {
+        recipient[key1] = (
+          typeof key2 === 'number' &&
+          !opts.object ? [] : {}
+        );
+      }
+
+      recipient = recipient[key1];
+      if (split.length > 0) {
+        key1 = getkey(split.shift());
+        key2 = getkey(split[0]);
+      }
+    }
+
+    // unflatten again for 'messy objects'
+    recipient[key1] = unflatten(target[key], opts);
+  });
+
+  return result
+}
+
+/**
+ *  Brings the 1st level to the 0th level.
+ *  Flats the object by nesting with '.' path separator.
+ */
+const serializeQueryForSpringBoot = (obj) => {
+    const parts = [];
+    Object.entries(obj).forEach(([key, val]) => {
+        if (Array.isArray(val)) {
+            val.forEach((v) => {
+                parts.push([key, v]);
+            });
+        }
+        else if (typeof val === 'object') {
+            objectToParams(val).forEach(([key, val]) => {
+                parts.push([key, val.toString()]);
+            });
+        }
+        else {
+            parts.push([key, val]);
+        }
+    });
+    return parts.map((p) => `${p[0]}=${p[1]}`).join('&');
+};
+const flatten = (obj) => {
+    const r = flat.flatten(obj);
+    //   { empty: {} } would be { empty: {} } instead of empty array
+    return Object.entries(r).filter(([k, v]) => typeof v !== 'object');
+};
+const objectToParams = (obj) => {
+    const [arrayProps, nonArrayProps] = partition((e) => Array.isArray(e[1]), Object.entries(obj));
+    const withoutArrayProps = fromPairs(nonArrayProps);
+    const res = flatten(withoutArrayProps);
+    arrayProps.forEach(([k, vals]) => {
+        vals.forEach((v) => res.push([k, v]));
+    });
+    return res;
+};
+
+// @ts-ignore
+const serializeQueryWithQs = (obj) => {
+    return qs.stringify(obj);
+};
+
+const fileResFilenameRegex = /filename="([^"]+)"/;
+const getFileNameFromContentDispositionHeader = (contentDispositionHeader) => {
+    if (!contentDispositionHeader)
+        return 'download-file';
+    const match = contentDispositionHeader.match(fileResFilenameRegex);
+    const fileName = match ? match[1] : 'downloaded-file';
+    return fileName;
+};
+
+const ContentType = {
+    Json: 'application/json',
+    FormData: 'multipart/form-data',
+};
+
+const qsUrlConverter = () => ({ query, path }) => {
+    return {
+        url: path + (query ? `?${serializeQueryWithQs(query)}` : ''),
+    };
+};
+const springBootUrlConverter = () => ({ query, path }) => {
+    return {
+        url: path + (query ? `?${serializeQueryForSpringBoot(query)}` : ''),
+    };
+};
+const createHttpClient = (client, urlConverter = qsUrlConverter()) => {
+    return {
+        request: (req) => {
+            const { url, params } = urlConverter(req);
+            const isBlob = req.format = 'document';
+            const obs = client.request(req.method, url, {
+                params,
+                body: prepareBody(req.body, req.type),
+                responseType: (isBlob ? 'blob' : 'json'),
+                observe: 'response',
+            });
+            return obs.pipe(map((r) => {
+                const { body } = r;
+                if (!isBlob)
+                    return body;
+                const data = body;
+                const contDisp = r.headers.get('content-disposition');
+                return new File([data], getFileNameFromContentDispositionHeader(contDisp), {
+                    type: data.type
+                });
+            }));
+        },
+    };
+};
+const prepareBody = (payload, type) => {
+    if (type === ContentType.FormData) {
+        return convertToFormData(payload);
+    }
+    return payload;
+};
+const convertToFormData = (payload) => {
+    const formData = new FormData();
+    const addProp = (key, val) => {
+        if (Array.isArray(val) || val instanceof FileList) {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore - seems that FileList is iterable despite the warning
+            // TODO change to other iteration method if this is not true
+            for (const valItem of val) {
+                addProp(key, valItem);
+            }
+        }
+        else if (typeof val === 'object' && val != null && !(val instanceof File)) {
+            throw new Error('Object serialization into FormData not supported');
+        }
+        else {
+            formData.append(key, val);
+        }
+    };
+    Object.entries(payload).forEach(([key, val]) => addProp(key, val));
+    return formData;
+};
+
+export { createHttpClient, qsUrlConverter, springBootUrlConverter };

package/dist/index.js

@@ -0,0 +1,338 @@
+'use strict';
+
+var rxjs = require('rxjs');
+var qs = require('qs');
+
+const { isArray } = Array;
+
+function fromPairs(listOfPairs){
+  const toReturn = {};
+  listOfPairs.forEach(([ prop, value ]) => toReturn[ prop ] = value);
+
+  return toReturn
+}
+
+function partitionObject(predicate, iterable){
+  const yes = {};
+  const no = {};
+  Object.entries(iterable).forEach(([ prop, value ]) => {
+    if (predicate(value, prop)){
+      yes[ prop ] = value;
+    } else {
+      no[ prop ] = value;
+    }
+  });
+
+  return [ yes, no ]
+}
+
+function partitionArray(
+  predicate, list, indexed = false
+){
+  const yes = [];
+  const no = [];
+  let counter = -1;
+
+  while (counter++ < list.length - 1){
+    if (
+      indexed ? predicate(list[ counter ], counter) : predicate(list[ counter ])
+    ){
+      yes.push(list[ counter ]);
+    } else {
+      no.push(list[ counter ]);
+    }
+  }
+
+  return [ yes, no ]
+}
+
+function partition(predicate, iterable){
+  if (arguments.length === 1){
+    return listHolder => partition(predicate, listHolder)
+  }
+  if (!isArray(iterable)) return partitionObject(predicate, iterable)
+
+  return partitionArray(predicate, iterable)
+}
+
+var flat = flatten$1;
+flatten$1.flatten = flatten$1;
+flatten$1.unflatten = unflatten;
+
+function isBuffer (obj) {
+  return obj &&
+    obj.constructor &&
+    (typeof obj.constructor.isBuffer === 'function') &&
+    obj.constructor.isBuffer(obj)
+}
+
+function keyIdentity (key) {
+  return key
+}
+
+function flatten$1 (target, opts) {
+  opts = opts || {};
+
+  const delimiter = opts.delimiter || '.';
+  const maxDepth = opts.maxDepth;
+  const transformKey = opts.transformKey || keyIdentity;
+  const output = {};
+
+  function step (object, prev, currentDepth) {
+    currentDepth = currentDepth || 1;
+    Object.keys(object).forEach(function (key) {
+      const value = object[key];
+      const isarray = opts.safe && Array.isArray(value);
+      const type = Object.prototype.toString.call(value);
+      const isbuffer = isBuffer(value);
+      const isobject = (
+        type === '[object Object]' ||
+        type === '[object Array]'
+      );
+
+      const newKey = prev
+        ? prev + delimiter + transformKey(key)
+        : transformKey(key);
+
+      if (!isarray && !isbuffer && isobject && Object.keys(value).length &&
+        (!opts.maxDepth || currentDepth < maxDepth)) {
+        return step(value, newKey, currentDepth + 1)
+      }
+
+      output[newKey] = value;
+    });
+  }
+
+  step(target);
+
+  return output
+}
+
+function unflatten (target, opts) {
+  opts = opts || {};
+
+  const delimiter = opts.delimiter || '.';
+  const overwrite = opts.overwrite || false;
+  const transformKey = opts.transformKey || keyIdentity;
+  const result = {};
+
+  const isbuffer = isBuffer(target);
+  if (isbuffer || Object.prototype.toString.call(target) !== '[object Object]') {
+    return target
+  }
+
+  // safely ensure that the key is
+  // an integer.
+  function getkey (key) {
+    const parsedKey = Number(key);
+
+    return (
+      isNaN(parsedKey) ||
+      key.indexOf('.') !== -1 ||
+      opts.object
+    ) ? key
+      : parsedKey
+  }
+
+  function addKeys (keyPrefix, recipient, target) {
+    return Object.keys(target).reduce(function (result, key) {
+      result[keyPrefix + delimiter + key] = target[key];
+
+      return result
+    }, recipient)
+  }
+
+  function isEmpty (val) {
+    const type = Object.prototype.toString.call(val);
+    const isArray = type === '[object Array]';
+    const isObject = type === '[object Object]';
+
+    if (!val) {
+      return true
+    } else if (isArray) {
+      return !val.length
+    } else if (isObject) {
+      return !Object.keys(val).length
+    }
+  }
+
+  target = Object.keys(target).reduce(function (result, key) {
+    const type = Object.prototype.toString.call(target[key]);
+    const isObject = (type === '[object Object]' || type === '[object Array]');
+    if (!isObject || isEmpty(target[key])) {
+      result[key] = target[key];
+      return result
+    } else {
+      return addKeys(
+        key,
+        result,
+        flatten$1(target[key], opts)
+      )
+    }
+  }, {});
+
+  Object.keys(target).forEach(function (key) {
+    const split = key.split(delimiter).map(transformKey);
+    let key1 = getkey(split.shift());
+    let key2 = getkey(split[0]);
+    let recipient = result;
+
+    while (key2 !== undefined) {
+      if (key1 === '__proto__') {
+        return
+      }
+
+      const type = Object.prototype.toString.call(recipient[key1]);
+      const isobject = (
+        type === '[object Object]' ||
+        type === '[object Array]'
+      );
+
+      // do not write over falsey, non-undefined values if overwrite is false
+      if (!overwrite && !isobject && typeof recipient[key1] !== 'undefined') {
+        return
+      }
+
+      if ((overwrite && !isobject) || (!overwrite && recipient[key1] == null)) {
+        recipient[key1] = (
+          typeof key2 === 'number' &&
+          !opts.object ? [] : {}
+        );
+      }
+
+      recipient = recipient[key1];
+      if (split.length > 0) {
+        key1 = getkey(split.shift());
+        key2 = getkey(split[0]);
+      }
+    }
+
+    // unflatten again for 'messy objects'
+    recipient[key1] = unflatten(target[key], opts);
+  });
+
+  return result
+}
+
+/**
+ *  Brings the 1st level to the 0th level.
+ *  Flats the object by nesting with '.' path separator.
+ */
+const serializeQueryForSpringBoot = (obj) => {
+    const parts = [];
+    Object.entries(obj).forEach(([key, val]) => {
+        if (Array.isArray(val)) {
+            val.forEach((v) => {
+                parts.push([key, v]);
+            });
+        }
+        else if (typeof val === 'object') {
+            objectToParams(val).forEach(([key, val]) => {
+                parts.push([key, val.toString()]);
+            });
+        }
+        else {
+            parts.push([key, val]);
+        }
+    });
+    return parts.map((p) => `${p[0]}=${p[1]}`).join('&');
+};
+const flatten = (obj) => {
+    const r = flat.flatten(obj);
+    //   { empty: {} } would be { empty: {} } instead of empty array
+    return Object.entries(r).filter(([k, v]) => typeof v !== 'object');
+};
+const objectToParams = (obj) => {
+    const [arrayProps, nonArrayProps] = partition((e) => Array.isArray(e[1]), Object.entries(obj));
+    const withoutArrayProps = fromPairs(nonArrayProps);
+    const res = flatten(withoutArrayProps);
+    arrayProps.forEach(([k, vals]) => {
+        vals.forEach((v) => res.push([k, v]));
+    });
+    return res;
+};
+
+// @ts-ignore
+const serializeQueryWithQs = (obj) => {
+    return qs.stringify(obj);
+};
+
+const fileResFilenameRegex = /filename="([^"]+)"/;
+const getFileNameFromContentDispositionHeader = (contentDispositionHeader) => {
+    if (!contentDispositionHeader)
+        return 'download-file';
+    const match = contentDispositionHeader.match(fileResFilenameRegex);
+    const fileName = match ? match[1] : 'downloaded-file';
+    return fileName;
+};
+
+const ContentType = {
+    Json: 'application/json',
+    FormData: 'multipart/form-data',
+};
+
+const qsUrlConverter = () => ({ query, path }) => {
+    return {
+        url: path + (query ? `?${serializeQueryWithQs(query)}` : ''),
+    };
+};
+const springBootUrlConverter = () => ({ query, path }) => {
+    return {
+        url: path + (query ? `?${serializeQueryForSpringBoot(query)}` : ''),
+    };
+};
+const createHttpClient = (client, urlConverter = qsUrlConverter()) => {
+    return {
+        request: (req) => {
+            const { url, params } = urlConverter(req);
+            const isBlob = req.format = 'document';
+            const obs = client.request(req.method, url, {
+                params,
+                body: prepareBody(req.body, req.type),
+                responseType: (isBlob ? 'blob' : 'json'),
+                observe: 'response',
+            });
+            return obs.pipe(rxjs.map((r) => {
+                const { body } = r;
+                if (!isBlob)
+                    return body;
+                const data = body;
+                const contDisp = r.headers.get('content-disposition');
+                return new File([data], getFileNameFromContentDispositionHeader(contDisp), {
+                    type: data.type
+                });
+            }));
+        },
+    };
+};
+const prepareBody = (payload, type) => {
+    if (type === ContentType.FormData) {
+        return convertToFormData(payload);
+    }
+    return payload;
+};
+const convertToFormData = (payload) => {
+    const formData = new FormData();
+    const addProp = (key, val) => {
+        if (Array.isArray(val) || val instanceof FileList) {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore - seems that FileList is iterable despite the warning
+            // TODO change to other iteration method if this is not true
+            for (const valItem of val) {
+                addProp(key, valItem);
+            }
+        }
+        else if (typeof val === 'object' && val != null && !(val instanceof File)) {
+            throw new Error('Object serialization into FormData not supported');
+        }
+        else {
+            formData.append(key, val);
+        }
+    };
+    Object.entries(payload).forEach(([key, val]) => addProp(key, val));
+    return formData;
+};
+
+exports.createHttpClient = createHttpClient;
+exports.qsUrlConverter = qsUrlConverter;
+exports.springBootUrlConverter = springBootUrlConverter;

package/dist/serializeQuery.d.ts

@@ -0,0 +1,2 @@
+export declare const serializeQuery: (obj: any) => any;
+export declare const flattenObject: (obj: any, prefix?: string) => any;

package/dist/types.d.ts

@@ -0,0 +1,19 @@
+import { Observable } from 'rxjs';
+export type ContentType = {};
+export type RequestParams = {};
+export declare const ContentType: {
+    Json: string;
+    FormData: string;
+};
+export type Request = {
+    path: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    format?: 'json';
+    query?: any;
+    body?: any;
+    type?: string;
+    secure?: boolean;
+};
+export type HttpClient<Any = any> = {
+    request: <Data, A = any>(req: Request) => Observable<Data>;
+};

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@ps-aux/api-client-angular",
+  "version": "0.1.0-rc1",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "module": "dist/index.esm.js",
+  "scripts": {
+    "build": "rollup -c",
+    "dev": "rollup -c --watch",
+    "publish": "npm run build && npm --access public publish",
+    "tc": "tsc"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "qs": "^6.11.2",
+    "rxjs": "^7.8.1"
+  },
+  "devDependencies": {
+    "@angular/common": "^16.2.12"
+  }
+}

package/rollup.config.mjs

@@ -0,0 +1,29 @@
+import typescript from 'rollup-plugin-typescript2'
+import resolve from '@rollup/plugin-node-resolve'
+import commonjs from '@rollup/plugin-commonjs'
+
+/**
+ * @type {import('rollup').RollupOptions}
+ */
+const config = {
+    input: 'src/index.ts',
+    output: [
+        {
+            file: `dist/index.js`,
+            format: 'cjs',
+        },
+        {
+            file: `dist/index.esm.js`,
+            format: 'es',
+        },
+    ],
+    plugins: [
+        typescript(),
+        resolve(),
+        commonjs(),
+    ],
+    external: ['qs', 'rxjs'],
+
+}
+export default config
+

package/src/AngularApiHttpClient.ts

@@ -0,0 +1,87 @@
+import { HttpClient as AngularHttpClient, HttpResponse } from '@angular/common/http'
+import { map, Observable } from 'rxjs'
+import {
+    serializeQueryForSpringBoot,
+    serializeQueryWithQs,
+    UrlConverter,
+    ObservableHttpClient,
+    Request, ContentType, getFileNameFromContentDispositionHeader,
+} from '@ps-aux/api-client-common'
+
+export const qsUrlConverter: () => UrlConverter = () => ({ query, path }) => {
+    return {
+        url: path + (query ? `?${serializeQueryWithQs(query)}` : ''),
+    }
+}
+
+export const springBootUrlConverter: () => UrlConverter = () => ({ query, path }) => {
+    return {
+        url: path + (query ? `?${serializeQueryForSpringBoot(query)}` : ''),
+    }
+}
+
+
+export const createHttpClient = (client: AngularHttpClient, urlConverter: UrlConverter = qsUrlConverter()): ObservableHttpClient => {
+    return {
+        request: <D>(req: Request): Observable<D> => {
+            const { url, params } = urlConverter(req)
+
+            const isBlob = req.format = 'document'
+
+            const obs = client.request<D>(
+                req.method,
+                url,
+                {
+                    params,
+                    body: prepareBody(req.body, req.type),
+                    responseType: (isBlob ? 'blob' : 'json') as any,
+                    observe: 'response',
+                })
+
+            return obs.pipe(
+                map((r: HttpResponse<D>) => {
+                    const { body } = r
+
+                    if (!isBlob)
+                        return body as D
+
+                    const data = body as Blob
+
+                    const contDisp = r.headers.get('content-disposition')
+                    return new File([data], getFileNameFromContentDispositionHeader(contDisp), {
+                        type: data.type
+                    }) as D
+                }),
+            )
+        },
+    }
+}
+
+const prepareBody = (payload: any, type?: string): any => {
+    if (type === ContentType.FormData) {
+        return convertToFormData(payload)
+    }
+
+    return payload
+}
+
+const convertToFormData = (payload: Record<string, any>): FormData => {
+    const formData = new FormData()
+    const addProp = (key: string, val: any) => {
+        if (Array.isArray(val) || val instanceof FileList) {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore - seems that FileList is iterable despite the warning
+            // TODO change to other iteration method if this is not true
+            for (const valItem of val) {
+                addProp(key, valItem)
+            }
+        } else if (typeof val === 'object' && val != null && !(val instanceof File)) {
+            throw new Error('Object serialization into FormData not supported')
+        } else {
+            formData.append(key, val)
+        }
+    }
+
+    Object.entries(payload).forEach(([key, val]) => addProp(key, val))
+    return formData
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export { createHttpClient, springBootUrlConverter, qsUrlConverter  } from './AngularApiHttpClient'
+

package/src/serializeQuery.ts

@@ -0,0 +1,45 @@
+// @ts-nocheck
+
+// TODO improve typings and check implementation
+export const serializeQuery = (obj: any): any => {
+  let result = {};
+  if (obj) {
+    Object.entries(obj).forEach(([key, val]) => {
+      if (Array.isArray(val)) {
+        val.map(v => {
+          if (result[key]) {
+            result[key] += `&${key}=${v}`;
+          } else {
+            result[key] = v;
+          }
+        });
+      } else if (typeof val === 'object') {
+        result = { ...result, ...flattenObject(val) };
+      } else {
+        result[key] = val;
+      }
+    });
+  }
+  return result;
+};
+
+export const flattenObject = (obj: any, prefix?: string): any => {
+  let str = {};
+  const pfix = prefix ? prefix + '.' : '';
+
+  for (const p in obj) {
+    if (obj.hasOwnProperty(p)) {
+      if (Array.isArray(obj[p])) {
+        str[pfix + p] = obj[p];
+      } else if (obj[p] === null) {
+        str[pfix + p] = null;
+      } else if (typeof obj[p] === 'object') {
+        str = { ...str, ...flattenObject(obj[p], pfix + p) };
+      } else if (obj[p] !== undefined) {
+        str[pfix + p] = obj[p];
+      }
+    }
+  }
+
+  return str;
+};

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "allowJs": true
+  },
+  "extends": "../../tsconfig.json",
+  "include": [
+    "src/**/*.ts"
+  ]
+}