ng-talkback 21.0.17 → 21.0.19

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

@@ -1,95 +1,91 @@
-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;
-  }
-  sameAs(otherTape) {
-    const otherReq = otherTape.req;
-    const req = this.tape.req;
-    if (!this.isSameUrl(req, otherReq)) {
-      return false;
+import ContentEncoding from './utils/content-encoding.backend';
+import MediaType from './utils/media-type.backend';
+import { ___NS__isEqual } from 'tnp-core/lib-prod';
+export default class TapeMatcher {
+    constructor(tape, options) {
+        this.tape = tape;
+        this.options = options;
     }
-    if (!this.isSameMethod(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.isSameHeaders(req, otherReq)) {
-      return false;
+    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);
+        }
+        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;
     }
-    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);
+    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;
     }
-    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;
-      }
+    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;
     }
-    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;
+    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;
     }
-    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;
-  }
 }
-export {
-  TapeMatcher as default
-};

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

@@ -1,93 +1,94 @@
-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;
-  }
-  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");
+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';
+// const bufferShim = require('buffer-shims')/
+export default class TapeRenderer {
+    constructor(tape) {
+        this.tape = tape;
     }
-  }
-  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;
+    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");
+        }
+    }
+    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 { // 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");
         }
-      } else {
-        return rawBody;
-      }
-    } else {
-      return reqResObj.body.toString("base64");
     }
-  }
 }
-export {
-  TapeRenderer as default
-};

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

@@ -1,94 +1,92 @@
-import { fse, path, json5, mkdirp } from "tnp-core/lib-prod";
-import Tape from "./tape.backend";
-import TapeMatcher from "./tape-matcher.backend";
-import TapeRenderer from "./tape-renderer.backend";
-class TapeStore {
-  path;
-  options;
-  tapes;
-  constructor(options) {
-    this.path = path.normalize(options.path + "/");
-    this.options = options;
-    this.tapes = [];
-  }
-  async load() {
-    mkdirp.sync(this.path);
-    await this.loadTapesAtDir(this.path);
-    console.log(`Loaded ${this.tapes.length} tapes`);
-  }
-  async loadTapesAtDir(directory) {
-    const items = fse.readdirSync(directory);
-    for (let i = 0; i < items.length; i++) {
-      const filename = items[i];
-      const fullPath = `${directory}${filename}`;
-      const stat = fse.statSync(fullPath);
-      if (!stat.isDirectory()) {
-        try {
-          const data = fse.readFileSync(fullPath, "utf8");
-          const raw = json5.parse(data);
-          const tape = await Tape.fromStore(raw, this.options);
-          tape.path = filename;
-          this.tapes.push(tape);
-        } catch (e) {
-          console.log(`Error reading tape ${fullPath}`, e.message);
+import { fse, path, json5, mkdirp } from 'tnp-core/lib-prod';
+import Tape from './tape.backend';
+import TapeMatcher from './tape-matcher.backend';
+import TapeRenderer from './tape-renderer.backend';
+export default class TapeStore {
+    constructor(options) {
+        this.path = path.normalize(options.path + "/");
+        this.options = options;
+        this.tapes = [];
+    }
+    async load() {
+        mkdirp.sync(this.path);
+        await this.loadTapesAtDir(this.path);
+        console.log(`Loaded ${this.tapes.length} tapes`);
+    }
+    async loadTapesAtDir(directory) {
+        const items = fse.readdirSync(directory);
+        for (let i = 0; i < items.length; i++) {
+            const filename = items[i];
+            const fullPath = `${directory}${filename}`;
+            const stat = fse.statSync(fullPath);
+            if (!stat.isDirectory()) {
+                try {
+                    const data = fse.readFileSync(fullPath, "utf8");
+                    const raw = json5.parse(data);
+                    const tape = await Tape.fromStore(raw, this.options);
+                    tape.path = filename;
+                    this.tapes.push(tape);
+                }
+                catch (e) {
+                    console.log(`Error reading tape ${fullPath}`, e.message);
+                }
+            }
+            else {
+                this.loadTapesAtDir(fullPath + "/");
+            }
         }
-      } else {
-        this.loadTapesAtDir(fullPath + "/");
-      }
     }
-  }
-  find(newTape) {
-    const foundTape = this.tapes.find((t) => {
-      this.options.logger.debug(`Comparing against tape ${t.path}`);
-      return new TapeMatcher(t, this.options).sameAs(newTape);
-    });
-    if (foundTape) {
-      foundTape.used = true;
-      this.options.logger.log(`Found matching tape for ${newTape.req.url} at ${foundTape.path}`);
-      return foundTape;
+    find(newTape) {
+        const foundTape = this.tapes.find(t => {
+            this.options.logger.debug(`Comparing against tape ${t.path}`);
+            return new TapeMatcher(t, this.options).sameAs(newTape);
+        });
+        if (foundTape) {
+            foundTape.used = true;
+            this.options.logger.log(`Found matching tape for ${newTape.req.url} at ${foundTape.path}`);
+            return foundTape;
+        }
     }
-  }
-  async save(tape) {
-    tape.new = true;
-    tape.used = true;
-    const tapePath = tape.path;
-    let fullFilename;
-    if (tapePath) {
-      fullFilename = path.join(this.path, tapePath);
-    } else {
-      this.tapes.push(tape);
-      fullFilename = this.createTapePath(tape);
-      tape.path = path.relative(this.path, fullFilename);
+    async save(tape) {
+        tape.new = true;
+        tape.used = true;
+        const tapePath = tape.path;
+        let fullFilename;
+        if (tapePath) {
+            fullFilename = path.join(this.path, tapePath);
+        }
+        else {
+            // If the tape doesn't have a path then it's new
+            this.tapes.push(tape);
+            fullFilename = this.createTapePath(tape);
+            tape.path = path.relative(this.path, fullFilename);
+        }
+        this.options.logger.log(`Saving request ${tape.req.url} at ${tape.path}`);
+        const tapeRenderer = new TapeRenderer(tape);
+        const toSave = await tapeRenderer.render();
+        fse.writeFileSync(fullFilename, json5.stringify(toSave, null, 4));
     }
-    this.options.logger.log(`Saving request ${tape.req.url} at ${tape.path}`);
-    const tapeRenderer = new TapeRenderer(tape);
-    const toSave = await tapeRenderer.render();
-    fse.writeFileSync(fullFilename, json5.stringify(toSave, null, 4));
-  }
-  currentTapeId() {
-    return this.tapes.length;
-  }
-  hasTapeBeenUsed(tapeName) {
-    return this.tapes.some((t) => t.used && t.path === tapeName);
-  }
-  resetTapeUsage() {
-    return this.tapes.forEach((t) => t.used = false);
-  }
-  createTapePath(tape) {
-    const currentTapeId = this.currentTapeId();
-    let tapePath = `unnamed-${currentTapeId}.json5`;
-    if (this.options.tapeNameGenerator) {
-      tapePath = this.options.tapeNameGenerator(currentTapeId, tape);
+    currentTapeId() {
+        return this.tapes.length;
     }
-    let result = path.normalize(path.join(this.options.path, tapePath));
-    if (!result.endsWith(".json5")) {
-      result = `${result}.json5`;
+    hasTapeBeenUsed(tapeName) {
+        return this.tapes.some(t => t.used && t.path === tapeName);
+    }
+    resetTapeUsage() {
+        return this.tapes.forEach(t => t.used = false);
+    }
+    createTapePath(tape) {
+        const currentTapeId = this.currentTapeId();
+        let tapePath = `unnamed-${currentTapeId}.json5`;
+        if (this.options.tapeNameGenerator) {
+            tapePath = this.options.tapeNameGenerator(currentTapeId, tape);
+        }
+        let result = path.normalize(path.join(this.options.path, tapePath));
+        if (!result.endsWith(".json5")) {
+            result = `${result}.json5`;
+        }
+        const dir = path.dirname(result);
+        mkdirp.sync(dir);
+        return result;
     }
-    const dir = path.dirname(result);
-    mkdirp.sync(dir);
-    return result;
-  }
 }
-export {
-  TapeStore as default
-};