Extract parse and format helpers to separate file

Author: tobli

Diff for: src/ts/helpers/parse.ts

@@ -0,0 +1,70 @@
+import {roundNumber} from "./misc";
+
+/**
+ * Type safe and null safe way to transform, filter and format an input value, e.g. parse a Date from a string,
+ * rejecting invalid dates, and formatting it as a localized string. If the input value is undefined, or the parseFn
+ * returns undefined, the function returns undefined.
+ * @param input
+ * @param parseFn an optional function to transform and/or filter the input value.
+ * @param formatFn an optional function to format the parsed input value.
+ * @returns {string} a formatted string representation of the input, or undefined.
+ */
+export function parseAndFormat<S, T>(input?: S,
+                                     parseFn: ((_: S) => T) = identity,
+                                     formatFn: ((_: T) => string) = identity): string {
+  if (input === undefined) {
+    return undefined;
+  }
+  const parsed = parseFn(input);
+  if (parsed === undefined) {
+    return undefined;
+  }
+  return formatFn(parsed);
+}
+
+function identity<T>(source: T): T {
+  return source;
+}
+
+export function parseDate(input: string): Date {
+  const date = new Date(input);
+  if (isNaN(date.getTime())) {
+    return undefined;
+  }
+  return date;
+}
+
+export function parseNonNegative(input: string | number): number {
+  const filter = (n) => (n >= 0);
+  return parseToNumber(input, filter);
+}
+
+export function parsePositive(input: string | number): number {
+  const filter = (n) => (n > 0);
+  return parseToNumber(input, filter);
+}
+
+function parseToNumber(input: string | number, filterFn: (_: number) => boolean): number {
+  const filter = (n: number) => filterFn(n) ? n : undefined;
+
+  if (typeof input === "string") {
+    const n = parseInt(input, 10);
+    if (!isFinite(n)) {
+      return undefined;
+    }
+    return filter(n);
+  }
+  return filter(input);
+}
+
+export function formatMilliseconds(millis: number): string {
+  return `${millis} ms`;
+}
+
+export function formatDateLocalized(date: Date): string {
+  return `${date.toUTCString()}</br>(local time: ${date.toLocaleString()})`;
+}
+
+export function formatBytes(bytes: number): string {
+  return `${bytes} bytes (~${roundNumber(bytes / 1024, 1)} kb)`;
+}

Diff for: src/ts/waterfall/details-overlay/extract-details-keys.ts

@@ -1,67 +1,11 @@
 import {getHeader} from "../../helpers/har";
+import {
+  formatBytes, formatDateLocalized, formatMilliseconds, parseAndFormat, parseDate,
+  parseNonNegative, parsePositive,
+} from "../../helpers/parse";
 import {Entry, Header} from "../../typing/har";
 import {WaterfallEntry} from "../../typing/waterfall";
 
-function parseAndFormat<S, T>(source?: S,
-                              parseFn: ((_: S) => T) = identity,
-                              formatFn: ((_: T) => string) = identity): string {
-  if (source === undefined) {
-    return undefined;
-  }
-  const parsed = parseFn(source);
-  if (parsed === undefined) {
-    return undefined;
-  }
-  return formatFn(parsed);
-}
-
-function identity<T>(source: T): T {
-  return source;
-}
-
-function parseDate(s: string): Date {
-  const date = new Date(s);
-  if (isNaN(date.getTime())) {
-    return undefined;
-  }
-  return date;
-}
-
-function parseNonNegative(input: string | number): number {
-  const criteria = (n: number) => (n < 0);
-  return parseToNumber(input, criteria);
-}
-
-function parsePositive(input: string | number): number {
-  const criteria = (n: number) => (n <= 0);
-  return parseToNumber(input, criteria);
-}
-
-function parseToNumber(input: string | number, criteria: (_: number) => boolean): number {
-  const parse = (n: number) => criteria(n) ? undefined : n;
-
-  if (typeof input === "string") {
-    const n = parseInt(input, 10);
-    if (!isFinite(n)) {
-      return undefined;
-    }
-    return parse(n);
-  }
-  return parse(input);
-}
-
-function formatMilliseconds(millis: number): string {
-  return `${millis} ms`;
-}
-
-function formatDateLocalized(d: Date): string {
-  return `${d.toUTCString()}</br>(local time: ${d.toLocaleString()})`;
-}
-
-function formatBytes(size: number): string {
-  return `${size} byte (~${Math.round(size / 1024 * 10) / 10}kb)`;
-}
-
 /** get experimental feature (usually WebPageTest) */
 let getExp = (harEntry: Entry, name: string): string => {
   return harEntry[name] || harEntry["_" + name] || harEntry.request[name] || harEntry.request["_" + name] || "";