devtools-tracing 1.0.0

package/lib/front_end/core/platform/MimeType.ts

@@ -0,0 +1,175 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+export const enum MimeType {
+  HTML = 'text/html',
+  XML = 'text/xml',
+  PLAIN = 'text/plain',
+  XHTML = 'application/xhtml+xml',
+  SVG = 'image/svg+xml',
+  CSS = 'text/css',
+  XSL = 'text/xsl',
+  VTT = 'text/vtt',
+  PDF = 'application/pdf',
+  EVENTSTREAM = 'text/event-stream',
+}
+
+/**
+ * MIME types other than the ones with the "text" type that have text content.
+ */
+const ADDITIONAL_TEXT_MIME_TYPES = new Set([
+  'application/ecmascript',
+  'application/javascript',
+  'application/json',
+  'application/json+protobuf',
+  'application/mpegurl',
+  'application/vnd.apple.mpegurl',
+  'application/vnd.dart',
+  'application/xml',
+  'application/x-aspx',
+  'application/x-javascript',
+  'application/x-jsp',
+  'application/x-httpd-php',
+  'application/x-mpegurl',
+  'audio/mpegurl',
+  'audio/x-mpegurl',
+]);
+
+/**
+ * @returns true iff `mimeType` has textual content. Concretely we return true if:
+ *   - `mimeType` starts with "text/" or "multipart/"
+ *   - `mimeType` ends with "+xml"
+ *   - `mimeType` contains "json"
+ *   - if `mimeType` is one of a predefined list textual mime types.
+ */
+export function isTextType(mimeType: string): boolean {
+  return mimeType.startsWith('text/') || mimeType.startsWith('multipart/') || mimeType.includes('json') ||
+      mimeType.endsWith('+xml') || ADDITIONAL_TEXT_MIME_TYPES.has(mimeType);
+}
+
+/**
+ * Port of net::HttpUtils::ParseContentType to extract mimeType and charset from
+ * the 'Content-Type' header.
+ */
+export function parseContentType(contentType: string): {mimeType: string|null, charset: string|null} {
+  if (contentType === '*/*') {
+    return {mimeType: null, charset: null};
+  }
+
+  const {mimeType, params} = parseMimeType(contentType);
+  const charset = params.get('charset')?.toLowerCase().trim() ?? null;
+  return {mimeType, charset};
+}
+
+function parseMimeType(contentType: string): {mimeType: string|null, params: Map<string, string>} {
+  // Remove any leading and trailing whitespace. Note that String.prototype.trim removes a lot more
+  // than what the spec considers whitespace. We are fine with that.
+  contentType = contentType.trim();
+
+  // The mimetype is basically everything until the first ';' (but trimmed).
+  let mimeTypeEnd = findFirstIndexOf(contentType, ' \t;(');
+  if (mimeTypeEnd < 0) {
+    mimeTypeEnd = contentType.length;
+  }
+
+  const slashPos = contentType.indexOf('/');
+  if (slashPos < 0 || slashPos > mimeTypeEnd) {
+    return {mimeType: null, params: new Map()};
+  }
+  const mimeType = contentType.substring(0, mimeTypeEnd).toLowerCase();
+
+  // Iterate over parameters. We can't split the string around semicolons because quoted
+  // strings may include semicolons.
+  const params = new Map<string, string>();
+  let offset = contentType.indexOf(';', mimeTypeEnd);
+  while (offset >= 0 && offset < contentType.length) {
+    // Trim off the semicolon.
+    ++offset;
+
+    // Trim off whitespace
+    offset = findFirstIndexNotOf(contentType, ' \t', offset);
+    if (offset < 0) {
+      continue;
+    }
+    const paramNameStart = offset;
+
+    // Extend parameter name until we run into semicolon or equals sign.
+    offset = findFirstIndexOf(contentType, ';=', offset);
+    if (offset < 0 || contentType[offset] === ';') {
+      // Nothing more to do if no more input or there is no parameter value.
+      continue;
+    }
+
+    const paramName = contentType.substring(paramNameStart, offset).toLowerCase();
+
+    //  Trim off the '='.
+    ++offset;
+
+    // Trim off whitespace.
+    offset = findFirstIndexNotOf(contentType, ' \t', offset);
+
+    let paramValue = '';
+    if (offset < 0 || contentType[offset] === ';') {
+      // Nothing to do here: the value is an unquoted string of only whitespace.
+      continue;
+    } else if (contentType[offset] !== '"') {
+      // Not a quote so we can copy the value as-is.
+      const valueStart = offset;
+      offset = contentType.indexOf(';', offset);
+      const valueEnd = offset >= 0 ? offset : contentType.length;
+
+      paramValue = contentType.substring(valueStart, valueEnd).trimEnd();
+    } else {
+      // Otherwise append data with special handling for backslashes, until a close quote.
+      // Don't trim whitespace for quoted strings.
+
+      // Trim off the opening quote '"'
+      ++offset;
+
+      while (offset < contentType.length && contentType[offset] !== '"') {
+        // Skip over backslash and append the next character, when not at the end
+        // of the string. Otherwise, copy the next character (which may be a backslash).
+        if (contentType[offset] === '\\' && offset + 1 < contentType.length) {
+          ++offset;
+        }
+        paramValue += contentType[offset];
+        ++offset;
+      }
+
+      offset = contentType.indexOf(';', offset);
+    }
+    if (!params.has(paramName)) {
+      // The first one wins!
+      params.set(paramName, paramValue);
+    }
+  }
+
+  return {mimeType, params};
+}
+
+/**
+ * @returns the smallest index of any character in 'characters' or -1 if none of
+ * the characters occur in 'searchString'
+ */
+function findFirstIndexOf(searchString: string, characters: string, pos = 0): number {
+  for (let i = pos; i < searchString.length; i++) {
+    if (characters.includes(searchString[i])) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+/**
+ * @returns the smallest index of any character not in 'characters' or -1 if only
+ * 'characters' occur in 'searchString'
+ */
+function findFirstIndexNotOf(searchString: string, characters: string, pos = 0): number {
+  for (let i = pos; i < searchString.length; i++) {
+    if (!characters.includes(searchString[i])) {
+      return i;
+    }
+  }
+  return -1;
+}

package/lib/front_end/core/platform/NumberUtilities.ts

@@ -0,0 +1,80 @@
+// Copyright 2020 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+export const clamp = (num: number, min: number, max: number): number => {
+  let clampedNumber = num;
+  if (num < min) {
+    clampedNumber = min;
+  } else if (num > max) {
+    clampedNumber = max;
+  }
+  return clampedNumber;
+};
+
+export const mod = (m: number, n: number): number => {
+  return ((m % n) + n) % n;
+};
+
+export const toFixedIfFloating = (value: string): string => {
+  if (!value || Number.isNaN(Number(value))) {
+    return value;
+  }
+  const number = Number(value);
+  return number % 1 ? number.toFixed(3) : String(number);
+};
+
+/**
+ * Rounds a number (including float) down.
+ */
+export const floor = (value: number, precision = 0): number => {
+  // Allows for rounding to the nearest whole number.
+  // Ex: 1 / 10 -> round down to nearest 10th place
+  // Ex: 1 / 5 -> round down to nearest 5
+  // Ex: 1 / 50 -> round down to nearest 50
+  if (precision > 0 && precision < 1) {
+    precision = 1 / precision;
+    return Math.floor(value / precision) * precision;
+  }
+
+  const mult = Math.pow(10, precision);
+  return Math.floor(value * mult) / mult;
+};
+
+/**
+ * Computes the great common divisor for two numbers.
+ * If the numbers are floats, they will be rounded to an integer.
+ */
+export const greatestCommonDivisor = (a: number, b: number): number => {
+  a = Math.round(a);
+  b = Math.round(b);
+  while (b !== 0) {
+    const t = b;
+    b = a % b;
+    a = t;
+  }
+  return a;
+};
+
+const commonRatios = new Map([
+  ['8∶5', '16∶10'],
+]);
+
+export const aspectRatio = (width: number, height: number): string => {
+  const divisor = greatestCommonDivisor(width, height);
+  if (divisor !== 0) {
+    width /= divisor;
+    height /= divisor;
+  }
+  const result = `${width}∶${height}`;
+  return commonRatios.get(result) || result;
+};
+
+export const withThousandsSeparator = function(num: number): string {
+  let str = String(num);
+  const re = /(\d+)(\d{3})/;
+  while (str.match(re)) {
+    str = str.replace(re, '$1\xA0$2');
+  }  // \xa0 is a non-breaking space
+  return str;
+};