ng-talkback 21.0.14 → 21.0.17

package/lib-prod/server.backend.js

@@ -1,88 +1,82 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const request_handler_backend_1 = require("./request-handler.backend");
-const summary_backend_1 = require("./summary.backend");
-const tape_store_backend_1 = require("./tape-store.backend");
-const http = require("http");
-const lib_prod_1 = require("tnp-core/lib-prod");
+import RequestHandler from "./request-handler.backend";
+import Summary from "./summary.backend";
+import TapeStore from "./tape-store.backend";
+import * as http from "http";
+import { https, fse } from "tnp-core/lib-prod";
 class TalkbackServer {
-    options;
-    tapeStore;
-    requestHandler;
-    closeSignalHandler;
-    server;
-    closed = false;
-    constructor(options) {
-        this.options = options;
-        this.tapeStore = new tape_store_backend_1.default(this.options);
-        this.requestHandler = new request_handler_backend_1.default(this.tapeStore, this.options);
-        this.closeSignalHandler = this.close.bind(this);
+  options;
+  tapeStore;
+  requestHandler;
+  closeSignalHandler;
+  server;
+  closed = false;
+  constructor(options) {
+    this.options = options;
+    this.tapeStore = new TapeStore(this.options);
+    this.requestHandler = new RequestHandler(this.tapeStore, this.options);
+    this.closeSignalHandler = this.close.bind(this);
+  }
+  handleRequest(rawReq, res) {
+    let reqBody = [];
+    rawReq.on("data", (chunk) => {
+      reqBody.push(chunk);
+    }).on("end", async () => {
+      try {
+        const req = {
+          headers: rawReq.headers,
+          url: rawReq.url,
+          method: rawReq.method,
+          body: Buffer.concat(reqBody)
+        };
+        const fRes = await this.requestHandler.handle(req);
+        res.writeHead(fRes.status, fRes.headers);
+        res.end(fRes.body);
+      } catch (ex) {
+        console.error("Error handling request", ex);
+        res.statusCode = 500;
+        res.end();
+      }
+    });
+  }
+  async start(callback) {
+    await this.tapeStore.load();
+    const handleRequest = this.handleRequest.bind(this);
+    const serverFactory = this.options.https.enabled ? () => {
+      const httpsOpts = {
+        key: fse.readFileSync(this.options.https.keyPath),
+        cert: fse.readFileSync(this.options.https.certPath)
+      };
+      return https.createServer(httpsOpts, handleRequest);
+    } : () => http.createServer(handleRequest);
+    this.server = serverFactory();
+    console.log(`Starting talkback on ${this.options.port}`);
+    this.server.listen(this.options.port, callback);
+    process.on("exit", this.closeSignalHandler);
+    process.on("SIGINT", this.closeSignalHandler);
+    process.on("SIGTERM", this.closeSignalHandler);
+    return this.server;
+  }
+  hasTapeBeenUsed(tapeName) {
+    return this.tapeStore.hasTapeBeenUsed(tapeName);
+  }
+  resetTapeUsage() {
+    this.tapeStore.resetTapeUsage();
+  }
+  close(callback) {
+    if (this.closed) {
+      return;
     }
-    handleRequest(rawReq, res) {
-        // console.log(`rawReq: ${rawReq.url}`)
-        let reqBody = [];
-        rawReq.on("data", (chunk) => {
-            reqBody.push(chunk);
-        }).on("end", async () => {
-            try {
-                const req = {
-                    headers: rawReq.headers,
-                    url: rawReq.url,
-                    method: rawReq.method,
-                    body: Buffer.concat(reqBody)
-                };
-                const fRes = await this.requestHandler.handle(req);
-                res.writeHead(fRes.status, fRes.headers);
-                res.end(fRes.body);
-            }
-            catch (ex) {
-                console.error("Error handling request", ex);
-                res.statusCode = 500;
-                res.end();
-            }
-        });
-    }
-    async start(callback) {
-        await this.tapeStore.load();
-        const handleRequest = this.handleRequest.bind(this);
-        const serverFactory = this.options.https.enabled ? () => {
-            const httpsOpts = {
-                key: lib_prod_1.fse.readFileSync(this.options.https.keyPath),
-                cert: lib_prod_1.fse.readFileSync(this.options.https.certPath)
-            };
-            return lib_prod_1.https.createServer(httpsOpts, handleRequest);
-        } : () => http.createServer(handleRequest);
-        this.server = serverFactory();
-        console.log(`Starting talkback on ${this.options.port}`);
-        this.server.listen(this.options.port, callback);
-        process.on("exit", this.closeSignalHandler);
-        process.on("SIGINT", this.closeSignalHandler);
-        process.on("SIGTERM", this.closeSignalHandler);
-        return this.server;
-    }
-    hasTapeBeenUsed(tapeName) {
-        return this.tapeStore.hasTapeBeenUsed(tapeName);
-    }
-    resetTapeUsage() {
-        this.tapeStore.resetTapeUsage();
-    }
-    close(callback) {
-        if (this.closed) {
-            return;
-        }
-        this.closed = true;
-        this.server.close(callback);
-        // @ts-ignore
-        process.removeListener("exit", this.closeSignalHandler);
-        // @ts-ignore
-        process.removeListener("SIGINT", this.closeSignalHandler);
-        // @ts-ignore
-        process.removeListener("SIGTERM", this.closeSignalHandler);
-        if (this.options.summary) {
-            const summary = new summary_backend_1.default(this.tapeStore.tapes, this.options);
-            summary.print();
-        }
+    this.closed = true;
+    this.server.close(callback);
+    process.removeListener("exit", this.closeSignalHandler);
+    process.removeListener("SIGINT", this.closeSignalHandler);
+    process.removeListener("SIGTERM", this.closeSignalHandler);
+    if (this.options.summary) {
+      const summary = new Summary(this.tapeStore.tapes, this.options);
+      summary.print();
     }
+  }
 }
-exports.default = TalkbackServer;
-//# sourceMappingURL=server.backend.js.map
+export {
+  TalkbackServer as default
+};

package/lib-prod/summary.backend.js

@@ -1,25 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 class Summary {
-    tapes;
-    opts;
-    constructor(tapes, opts) {
-        this.tapes = tapes;
-        this.opts = opts;
+  tapes;
+  opts;
+  constructor(tapes, opts) {
+    this.tapes = tapes;
+    this.opts = opts;
+  }
+  print() {
+    console.log(`===== SUMMARY (${this.opts.name}) =====`);
+    const newTapes = this.tapes.filter((t) => t.new);
+    if (newTapes.length > 0) {
+      console.log("New tapes:");
+      newTapes.forEach((t) => console.log(`- ${t.path}`));
     }
-    print() {
-        console.log(`===== SUMMARY (${this.opts.name}) =====`);
-        const newTapes = this.tapes.filter(t => t.new);
-        if (newTapes.length > 0) {
-            console.log("New tapes:");
-            newTapes.forEach(t => console.log(`- ${t.path}`));
-        }
-        const unusedTapes = this.tapes.filter(t => !t.used);
-        if (unusedTapes.length > 0) {
-            console.log("Unused tapes:");
-            unusedTapes.forEach(t => console.log(`- ${t.path}`));
-        }
+    const unusedTapes = this.tapes.filter((t) => !t.used);
+    if (unusedTapes.length > 0) {
+      console.log("Unused tapes:");
+      unusedTapes.forEach((t) => console.log(`- ${t.path}`));
     }
+  }
 }
-exports.default = Summary;
-//# sourceMappingURL=summary.backend.js.map
+export {
+  Summary as default
+};

package/lib-prod/talkback-factory.backend.js

@@ -1,20 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const options_backend_1 = require("./options.backend");
-const tape_store_backend_1 = require("./tape-store.backend");
-const server_backend_1 = require("./server.backend");
-const request_handler_backend_1 = require("./request-handler.backend");
+import Options from "./options.backend";
+import TapeStore from "./tape-store.backend";
+import TalkbackServer from "./server.backend";
+import RequestHandler from "./request-handler.backend";
 class TalkbackFactory {
-    static server(options) {
-        const fullOptions = options_backend_1.default.prepare(options);
-        return new server_backend_1.default(fullOptions);
-    }
-    static async requestHandler(options) {
-        const fullOptions = options_backend_1.default.prepare(options);
-        const tapeStore = new tape_store_backend_1.default(fullOptions);
-        await tapeStore.load();
-        return new request_handler_backend_1.default(tapeStore, fullOptions);
-    }
+  static server(options) {
+    const fullOptions = Options.prepare(options);
+    return new TalkbackServer(fullOptions);
+  }
+  static async requestHandler(options) {
+    const fullOptions = Options.prepare(options);
+    const tapeStore = new TapeStore(fullOptions);
+    await tapeStore.load();
+    return new RequestHandler(tapeStore, fullOptions);
+  }
 }
-exports.default = TalkbackFactory;
-//# sourceMappingURL=talkback-factory.backend.js.map
+export {
+  TalkbackFactory as default
+};

package/lib-prod/tape-matcher.backend.js

@@ -1,97 +1,95 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const content_encoding_backend_1 = require("./utils/content-encoding.backend");
-const media_type_backend_1 = require("./utils/media-type.backend");
-const lib_prod_1 = require("tnp-core/lib-prod");
+import ContentEncoding from "./utils/content-encoding.backend";
+import MediaType from "./utils/media-type.backend";
+import { ___NS__isEqual } from "tnp-core/lib-prod";
 class TapeMatcher {
-    tape;
-    options;
-    constructor(tape, options) {
-        this.tape = tape;
-        this.options = options;
+  tape;
+  options;
+  constructor(tape, options) {
+    this.tape = tape;
+    this.options = options;
+  }
+  sameAs(otherTape) {
+    const otherReq = otherTape.req;
+    const req = this.tape.req;
+    if (!this.isSameUrl(req, otherReq)) {
+      return false;
     }
-    sameAs(otherTape) {
-        const otherReq = otherTape.req;
-        const req = this.tape.req;
-        if (!this.isSameUrl(req, otherReq)) {
-            return false;
-        }
-        if (!this.isSameMethod(req, otherReq)) {
-            return false;
-        }
-        if (!this.isSameHeaders(req, otherReq)) {
-            return false;
-        }
-        return this.options.ignoreBody || this.isSameBody(req, otherReq);
+    if (!this.isSameMethod(req, otherReq)) {
+      return false;
     }
-    isSameBody(req, otherReq) {
-        const mediaType = new media_type_backend_1.default(req);
-        const contentEncoding = new content_encoding_backend_1.default(req);
-        let sameBody;
-        if (contentEncoding.isUncompressed() && mediaType.isJSON() && req.body.length > 0 && otherReq.body.length > 0) {
-            const parsedReqBody = JSON.parse(req.body.toString());
-            const parsedOtherReqBody = JSON.parse(otherReq.body.toString());
-            sameBody = lib_prod_1._.isEqual(parsedReqBody, parsedOtherReqBody);
-        }
-        else {
-            sameBody = req.body.equals(otherReq.body);
-        }
-        if (!sameBody) {
-            if (!this.options.bodyMatcher) {
-                this.options.logger.debug(`Not same BODY ${req.body} vs ${otherReq.body}`);
-                return false;
-            }
-            const bodyMatches = this.options.bodyMatcher(this.tape, otherReq);
-            if (!bodyMatches) {
-                this.options.logger.debug(`Not same bodyMatcher ${req.body} vs ${otherReq.body}`);
-                return false;
-            }
-        }
-        return true;
+    if (!this.isSameHeaders(req, otherReq)) {
+      return false;
     }
-    isSameHeaders(req, otherReq) {
-        const currentHeadersLength = Object.keys(req.headers).length;
-        const otherHeadersLength = Object.keys(otherReq.headers).length;
-        const sameNumberOfHeaders = currentHeadersLength === otherHeadersLength;
-        if (!sameNumberOfHeaders) {
-            this.options.logger.debug(`Not same #HEADERS ${JSON.stringify(req.headers)} vs ${JSON.stringify(otherReq.headers)}`);
-            return false;
-        }
-        let headersSame = true;
-        Object.keys(req.headers).forEach(k => {
-            const entryHeader = req.headers[k];
-            const header = otherReq.headers[k];
-            headersSame = headersSame && entryHeader === header;
-        });
-        if (!headersSame) {
-            this.options.logger.debug(`Not same HEADERS values ${JSON.stringify(req.headers)} vs ${JSON.stringify(otherReq.headers)}`);
-            return false;
-        }
-        return true;
+    return this.options.ignoreBody || this.isSameBody(req, otherReq);
+  }
+  isSameBody(req, otherReq) {
+    const mediaType = new MediaType(req);
+    const contentEncoding = new ContentEncoding(req);
+    let sameBody;
+    if (contentEncoding.isUncompressed() && mediaType.isJSON() && req.body.length > 0 && otherReq.body.length > 0) {
+      const parsedReqBody = JSON.parse(req.body.toString());
+      const parsedOtherReqBody = JSON.parse(otherReq.body.toString());
+      sameBody = ___NS__isEqual(parsedReqBody, parsedOtherReqBody);
+    } else {
+      sameBody = req.body.equals(otherReq.body);
     }
-    isSameMethod(req, otherReq) {
-        const sameMethod = req.method === otherReq.method;
-        if (!sameMethod) {
-            this.options.logger.debug(`Not same METHOD ${req.method} vs ${otherReq.method}`);
-            return false;
-        }
-        return true;
+    if (!sameBody) {
+      if (!this.options.bodyMatcher) {
+        this.options.logger.debug(`Not same BODY ${req.body} vs ${otherReq.body}`);
+        return false;
+      }
+      const bodyMatches = this.options.bodyMatcher(this.tape, otherReq);
+      if (!bodyMatches) {
+        this.options.logger.debug(`Not same bodyMatcher ${req.body} vs ${otherReq.body}`);
+        return false;
+      }
     }
-    isSameUrl(req, otherReq) {
-        const sameURL = req.url === otherReq.url;
-        if (!sameURL) {
-            if (!this.options.urlMatcher) {
-                this.options.logger.debug(`Not same URL ${req.url} vs ${otherReq.url}`);
-                return false;
-            }
-            const urlMatches = this.options.urlMatcher(this.tape, otherReq);
-            if (!urlMatches) {
-                this.options.logger.debug(`Not same urlMatcher ${req.url} vs ${otherReq.url}`);
-                return false;
-            }
-        }
-        return true;
+    return true;
+  }
+  isSameHeaders(req, otherReq) {
+    const currentHeadersLength = Object.keys(req.headers).length;
+    const otherHeadersLength = Object.keys(otherReq.headers).length;
+    const sameNumberOfHeaders = currentHeadersLength === otherHeadersLength;
+    if (!sameNumberOfHeaders) {
+      this.options.logger.debug(`Not same #HEADERS ${JSON.stringify(req.headers)} vs ${JSON.stringify(otherReq.headers)}`);
+      return false;
     }
+    let headersSame = true;
+    Object.keys(req.headers).forEach((k) => {
+      const entryHeader = req.headers[k];
+      const header = otherReq.headers[k];
+      headersSame = headersSame && entryHeader === header;
+    });
+    if (!headersSame) {
+      this.options.logger.debug(`Not same HEADERS values ${JSON.stringify(req.headers)} vs ${JSON.stringify(otherReq.headers)}`);
+      return false;
+    }
+    return true;
+  }
+  isSameMethod(req, otherReq) {
+    const sameMethod = req.method === otherReq.method;
+    if (!sameMethod) {
+      this.options.logger.debug(`Not same METHOD ${req.method} vs ${otherReq.method}`);
+      return false;
+    }
+    return true;
+  }
+  isSameUrl(req, otherReq) {
+    const sameURL = req.url === otherReq.url;
+    if (!sameURL) {
+      if (!this.options.urlMatcher) {
+        this.options.logger.debug(`Not same URL ${req.url} vs ${otherReq.url}`);
+        return false;
+      }
+      const urlMatches = this.options.urlMatcher(this.tape, otherReq);
+      if (!urlMatches) {
+        this.options.logger.debug(`Not same urlMatcher ${req.url} vs ${otherReq.url}`);
+        return false;
+      }
+    }
+    return true;
+  }
 }
-exports.default = TapeMatcher;
-//# sourceMappingURL=tape-matcher.backend.js.map
+export {
+  TapeMatcher as default
+};

package/lib-prod/tape-renderer.backend.js

@@ -1,99 +1,93 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const headers_backend_1 = require("./utils/headers.backend");
-const media_type_backend_1 = require("./utils/media-type.backend");
-const tape_backend_1 = require("./tape.backend");
-const content_encoding_backend_1 = require("./utils/content-encoding.backend");
-const bufferShim = require("buffer-shims");
-// const bufferShim = require('buffer-shims')/
+import Headers from "./utils/headers.backend";
+import MediaType from "./utils/media-type.backend";
+import Tape from "./tape.backend";
+import ContentEncoding from "./utils/content-encoding.backend";
+import * as bufferShim from "buffer-shims";
 class TapeRenderer {
-    tape;
-    constructor(tape) {
-        this.tape = tape;
+  tape;
+  constructor(tape) {
+    this.tape = tape;
+  }
+  static async fromStore(raw, options) {
+    const req = { ...raw.req };
+    req.body = await this.prepareBody(raw, req, req.body, "req");
+    const tape = new Tape(req, options);
+    tape.meta = { ...raw.meta };
+    const baseRes = { ...raw.res };
+    const resBody = await this.prepareBody(tape, baseRes, baseRes.body, "res");
+    tape.res = {
+      ...baseRes,
+      body: resBody
+    };
+    return tape;
+  }
+  static async prepareBody(tape, reqResObj, rawBody, metaPrefix) {
+    const contentEncoding = new ContentEncoding(reqResObj);
+    const isTapeUncompressed = tape.meta[metaPrefix + "Uncompressed"];
+    const isTapeHumanReadable = tape.meta[metaPrefix + "HumanReadable"];
+    const isTapeInPlainText = isTapeUncompressed || contentEncoding.isUncompressed();
+    if (isTapeHumanReadable && isTapeInPlainText) {
+      const mediaType = new MediaType(reqResObj);
+      let bufferContent = rawBody;
+      const isResAnObject = typeof bufferContent === "object";
+      if (isResAnObject && mediaType.isJSON()) {
+        bufferContent = JSON.stringify(bufferContent, null, 2);
+      }
+      if (Headers.read(reqResObj.headers, "content-length")) {
+        Headers.write(reqResObj.headers, "content-length", Buffer.byteLength(bufferContent).toString(), metaPrefix);
+      }
+      if (isTapeUncompressed) {
+        return await contentEncoding.compressedBody(bufferContent);
+      }
+      return bufferShim.from(bufferContent);
+    } else {
+      return bufferShim.from(rawBody, "base64");
     }
-    static async fromStore(raw, options) {
-        const req = { ...raw.req };
-        req.body = await this.prepareBody(raw, req, req.body, "req");
-        const tape = new tape_backend_1.default(req, options);
-        tape.meta = { ...raw.meta };
-        const baseRes = { ...raw.res };
-        const resBody = await this.prepareBody(tape, baseRes, baseRes.body, "res");
-        tape.res = {
-            ...baseRes,
-            body: resBody
-        };
-        return tape;
-    }
-    static async prepareBody(tape, reqResObj, rawBody, metaPrefix) {
-        const contentEncoding = new content_encoding_backend_1.default(reqResObj);
-        const isTapeUncompressed = tape.meta[metaPrefix + "Uncompressed"];
-        const isTapeHumanReadable = tape.meta[metaPrefix + "HumanReadable"];
-        const isTapeInPlainText = isTapeUncompressed || contentEncoding.isUncompressed();
-        if (isTapeHumanReadable && isTapeInPlainText) {
-            const mediaType = new media_type_backend_1.default(reqResObj);
-            let bufferContent = rawBody;
-            const isResAnObject = typeof (bufferContent) === "object";
-            if (isResAnObject && mediaType.isJSON()) {
-                bufferContent = JSON.stringify(bufferContent, null, 2);
-            }
-            if (headers_backend_1.default.read(reqResObj.headers, "content-length")) {
-                headers_backend_1.default.write(reqResObj.headers, "content-length", Buffer.byteLength(bufferContent).toString(), metaPrefix);
-            }
-            if (isTapeUncompressed) {
-                return await contentEncoding.compressedBody(bufferContent);
-            }
-            return bufferShim.from(bufferContent);
-        }
-        else {
-            return bufferShim.from(rawBody, "base64");
-        }
-    }
-    async render() {
-        const reqBody = await this.bodyFor(this.tape.req, "req");
-        const resBody = await this.bodyFor(this.tape.res, "res");
-        return {
-            meta: this.tape.meta,
-            req: {
-                ...this.tape.req,
-                body: reqBody
-            },
-            res: {
-                ...this.tape.res,
-                body: resBody
-            }
-        };
-    }
-    async bodyFor(reqResObj, metaPrefix) {
-        const mediaType = new media_type_backend_1.default(reqResObj);
-        const contentEncoding = new content_encoding_backend_1.default(reqResObj);
-        const bodyLength = reqResObj.body.length;
-        const isUncompressed = contentEncoding.isUncompressed();
-        const contentEncodingSupported = isUncompressed || contentEncoding.supportedAlgorithm();
-        if (mediaType.isHumanReadable() && contentEncodingSupported && bodyLength > 0) {
-            this.tape.meta[metaPrefix + "HumanReadable"] = true;
-            let body = reqResObj.body;
-            if (!isUncompressed) {
-                this.tape.meta[metaPrefix + "Uncompressed"] = true;
-                body = await contentEncoding.uncompressedBody(body);
-            }
-            const rawBody = body.toString("utf8");
-            if (mediaType.isJSON()) {
-                try { // TODO handle this better in future not based on mediaType.isJSON
-                    const parsed = JSON.parse(rawBody);
-                    return parsed;
-                }
-                catch (error) {
-                    return rawBody;
-                }
-            }
-            else {
-                return rawBody;
-            }
-        }
-        else {
-            return reqResObj.body.toString("base64");
+  }
+  async render() {
+    const reqBody = await this.bodyFor(this.tape.req, "req");
+    const resBody = await this.bodyFor(this.tape.res, "res");
+    return {
+      meta: this.tape.meta,
+      req: {
+        ...this.tape.req,
+        body: reqBody
+      },
+      res: {
+        ...this.tape.res,
+        body: resBody
+      }
+    };
+  }
+  async bodyFor(reqResObj, metaPrefix) {
+    const mediaType = new MediaType(reqResObj);
+    const contentEncoding = new ContentEncoding(reqResObj);
+    const bodyLength = reqResObj.body.length;
+    const isUncompressed = contentEncoding.isUncompressed();
+    const contentEncodingSupported = isUncompressed || contentEncoding.supportedAlgorithm();
+    if (mediaType.isHumanReadable() && contentEncodingSupported && bodyLength > 0) {
+      this.tape.meta[metaPrefix + "HumanReadable"] = true;
+      let body = reqResObj.body;
+      if (!isUncompressed) {
+        this.tape.meta[metaPrefix + "Uncompressed"] = true;
+        body = await contentEncoding.uncompressedBody(body);
+      }
+      const rawBody = body.toString("utf8");
+      if (mediaType.isJSON()) {
+        try {
+          const parsed = JSON.parse(rawBody);
+          return parsed;
+        } catch (error) {
+          return rawBody;
         }
+      } else {
+        return rawBody;
+      }
+    } else {
+      return reqResObj.body.toString("base64");
     }
+  }
 }
-exports.default = TapeRenderer;
-//# sourceMappingURL=tape-renderer.backend.js.map
+export {
+  TapeRenderer as default
+};