@rozenite/network-activity-plugin 1.0.0-alpha.9 → 1.1.0

package/src/utils/cookieParser.ts

@@ -0,0 +1,126 @@
+import { Cookie, HttpHeaders } from '../shared/client';
+import { getHttpHeader } from './getHttpHeader';
+
+export const parseSetCookieHeader = (setCookieStr: string): Cookie => {
+  const parts = setCookieStr.split(';').map((p) => p.trim());
+  const [nameValue, ...attributes] = parts;
+  const [name, ...valueParts] = nameValue.split('=');
+
+  const value = valueParts.join('=');
+
+  const cookieObj: Cookie = {
+    name: name?.trim() || '',
+    value: value?.trim() || '',
+  };
+
+  attributes.forEach((attr) => {
+    const [attrName, ...attrValueParts] = attr.split('=');
+    const lowerAttrName = attrName.trim().toLowerCase();
+    const attrValue = attrValueParts.join('=');
+
+    switch (lowerAttrName) {
+      case 'domain':
+        cookieObj.domain = attrValue;
+
+        break;
+
+      case 'path':
+        cookieObj.path = attrValue;
+
+        break;
+
+      case 'expires':
+        cookieObj.expires = attrValue;
+
+        break;
+
+      case 'max-age':
+        cookieObj.maxAge = attrValue;
+
+        break;
+
+      case 'secure':
+        cookieObj.secure = true;
+
+        break;
+
+      case 'httponly':
+        cookieObj.httpOnly = true;
+
+        break;
+
+      case 'samesite':
+        cookieObj.sameSite = attrValue;
+
+        break;
+    }
+  });
+
+  return cookieObj;
+};
+
+export const splitSetCookieHeaderByComma = (header: string): string[] => {
+  const regex = /(?:^|,\s)([^=;,]+=[^;]+(?:;[^,]*)*)/g;
+  const matches: string[] = [];
+
+  let match;
+
+  while ((match = regex.exec(header)) !== null) {
+    matches.push(match[1].trim());
+  }
+
+  return matches;
+};
+
+export const parseCookieHeader = (cookieString: string): Cookie[] => {
+  if (!cookieString) return [];
+
+  return cookieString
+    .split(';')
+    .map((cookieStr) => {
+      const [name, ...valueParts] = cookieStr.trim().split('=');
+      const value = valueParts.join('=');
+
+      return {
+        name: name?.trim() || '',
+        value: value?.trim() || '',
+      };
+    })
+    .filter((cookieObj) => cookieObj.name);
+};
+
+export const parseRequestCookiesFromHeaders = (
+  headers: HttpHeaders
+): Cookie[] => {
+  const cookieHeader = getHttpHeader(headers, 'cookie');
+
+  if (!cookieHeader) {
+    return [];
+  }
+
+  const { value } = cookieHeader;
+
+  if (Array.isArray(value)) {
+    return value.flatMap(parseCookieHeader);
+  }
+
+  return parseCookieHeader(value);
+};
+
+export const parseResponseCookiesFromHeaders = (
+  headers: HttpHeaders
+): Cookie[] => {
+  const setCookieHeader = getHttpHeader(headers, 'set-cookie');
+
+  if (!setCookieHeader) {
+    return [];
+  }
+
+  const { value } = setCookieHeader;
+
+  if (Array.isArray(value)) {
+    return value.flatMap(parseSetCookieHeader);
+  }
+
+  return [parseSetCookieHeader(value)];
+};

package/src/utils/getContentTypeMimeType.ts

@@ -0,0 +1,17 @@
+import { HttpHeaders } from '../shared/client';
+import { getHttpHeader } from './getHttpHeader';
+
+export function getContentTypeMime(headers: HttpHeaders) {
+  const contentType = getHttpHeader(headers, 'content-type');
+
+  if (!contentType) {
+    return undefined;
+  }
+
+  const { value } = contentType;
+
+  // Content-Type can't be an array, but if it does we simply get the first element.
+  const actualValue = Array.isArray(value) ? value[0] : value;
+
+  return actualValue.split(';')[0].trim();
+}

package/src/utils/getHttpHeader.ts

@@ -0,0 +1,17 @@
+import { HttpHeaders, XHRHeaders } from '../shared/client';
+
+// Utility to get header value and actual key case-insensitively
+export function getHttpHeader<T extends HttpHeaders | XHRHeaders>(
+  headers: T,
+  name: string
+) {
+  const lowerName = name.toLowerCase();
+
+  for (const key in headers) {
+    if (key.toLowerCase() === lowerName) {
+      return { value: headers[key], originalKey: key };
+    }
+  }
+
+  return undefined;
+}

package/src/utils/getHttpHeaderValueAsString.ts

@@ -0,0 +1,13 @@
+/**
+ * Combines multiple HTTP header values according to RFC 7230 Section 3.2.2
+ *
+ * Per RFC 7230 Section 3.2.2: "A recipient MAY combine multiple header fields
+ * with the same field name into one 'field-name: field-value' pair, without
+ * changing the semantics of the message, by appending each subsequent field
+ * value to the combined field value in order, separated by a comma."
+ *
+ * @see https://tools.ietf.org/html/rfc7230#section-3.2.2
+ */
+export function getHttpHeaderValueAsString(value: string | string[]): string {
+  return Array.isArray(value) ? value.join(', ') : value;
+}

package/src/utils/getStringSizeInBytes.ts

@@ -0,0 +1,3 @@
+export const getStringSizeInBytes = (value: string) => {
+  return new TextEncoder().encode(value).length;
+};

package/src/utils/inferContentTypeFromPostData.ts

@@ -0,0 +1,9 @@
+import { RequestPostData } from '../shared/client';
+
+export function inferContentTypeFromPostData(postData: RequestPostData) {
+  if (postData?.type === 'form-data') {
+    return 'multipart/form-data';
+  }
+
+  return undefined;
+}

package/src/utils/safeStringify.ts

@@ -0,0 +1,7 @@
+export function safeStringify(data: unknown): string {
+  try {
+    return typeof data === 'string' ? data : JSON.stringify(data);
+  } catch {
+    return String(data);
+  }
+}

package/src/utils/typeChecks.ts

@@ -0,0 +1,27 @@
+export const isBlob = (value: unknown): value is Blob => value instanceof Blob;
+
+export const isArrayBuffer = (
+  value: unknown
+): value is ArrayBuffer | ArrayBufferView =>
+  value instanceof ArrayBuffer || ArrayBuffer.isView(value);
+
+export const isFormData = (value: unknown): value is FormData =>
+  value instanceof FormData;
+
+export const isNullOrUndefined = (value: unknown): value is null | undefined =>
+  value === null || value === undefined;
+
+export const isString = (value: unknown): value is string =>
+  typeof value === 'string';
+
+export const isNumber = (value: unknown): value is number =>
+  typeof value === 'number' && !isNaN(value);
+
+export const isBoolean = (value: unknown): value is boolean =>
+  typeof value === 'boolean';
+
+export const isObject = (value: unknown): value is object =>
+  typeof value === 'object' && value !== null;
+
+export const isArray = (value: unknown): value is unknown[] =>
+  Array.isArray(value);

package/dist/src/ui/utils/getHttpHeaderValue.d.ts

@@ -1,2 +0,0 @@
-import { HttpHeaders } from '../../shared/client';
-export declare function getHttpHeaderValue(headers: HttpHeaders, name: string): string | undefined;

package/src/ui/utils/getHttpHeaderValue.ts

@@ -1,14 +0,0 @@
-import { HttpHeaders } from "../../shared/client";
-
-// Utility to get header value case-insensitively
-export function getHttpHeaderValue(headers: HttpHeaders, name: string) {
-  const lowerName = name.toLowerCase();
-
-  for (const key in headers) {
-    if (key.toLowerCase() === lowerName) {
-      return headers[key];
-    }
-  }
-  
-  return undefined;
-}