@mherod/get-cookie 2.0.0-rc.29 → 2.0.0-rc.30

package/src/listChromeProfiles.ts

@@ -0,0 +1,45 @@
+import { sync } from "fast-glob";
+import { chromeApplicationSupport } from "./browsers/ChromeApplicationSupport";
+import { dirname } from "path";
+import { readFile } from "fs/promises";
+import { flatMapAsync } from "./util/flatMapAsync";
+import destr from "destr";
+
+export async function listChromeProfilePaths(): Promise<string[]> {
+  return sync(`./**/Cookies`, {
+    cwd: chromeApplicationSupport,
+    absolute: true,
+    onlyFiles: true,
+    deep: 2,
+  }).map((f) => {
+    // parent dir
+    return dirname(f);
+  });
+}
+
+export async function listChromeProfiles(): Promise<ChromeProfile[]> {
+  const paths = await listChromeProfilePaths();
+  return await flatMapAsync(paths, async (p) => {
+    const content = await readFile(`${p}/Preferences`, "utf-8");
+    return await destr(content);
+  });
+}
+
+export type ChromeProfileAccountInfo = {
+  account_id: string;
+  accountcapabilities: any;
+  email: string;
+  full_name: string;
+  gaia: string;
+  given_name: string;
+  hd: string;
+  is_supervised_child: number;
+  is_under_advanced_protection: boolean;
+  last_downloaded_image_url_with_size: string;
+  locale: string;
+  picture_url: string;
+};
+
+export type ChromeProfile = {
+  account_info: ChromeProfileAccountInfo[];
+};

package/src/util/flatMapAsync.test.ts

@@ -0,0 +1,55 @@
+import { flatMapAsync } from "./flatMapAsync";
+
+describe("flatMapAsync", () => {
+  it("should apply async callback to each element, wait for all promises to fulfill and flatten the resulting array", async () => {
+    const array = [1, 2, 3];
+    const callback = async (value: number) => [value, value * 2];
+    const result = await flatMapAsync(array, callback);
+    expect(result).toEqual([1, 2, 2, 4, 3, 6]);
+  });
+
+  it("should handle errors with the provided error callback", async () => {
+    const array = [1, 2, 3];
+    const callback = async (value: number) => {
+      if (value === 2) {
+        throw new Error("Test error");
+      }
+      return [value, value * 2];
+    };
+    const errorCallback = (error: any) => [0];
+    const result = await flatMapAsync(array, callback, errorCallback);
+    expect(result).toEqual([1, 2, 0, 3, 6]);
+  });
+
+  it("should return an empty array when input array is empty", async () => {
+    const array: number[] = [];
+    const callback = async (value: number) => [value, value * 2];
+    const result = await flatMapAsync(array, callback);
+    expect(result).toEqual([]);
+  });
+
+  it("should return an array with single element when input array has one element", async () => {
+    const array = [1];
+    const callback = async (value: number) => [value, value * 2];
+    const result = await flatMapAsync(array, callback);
+    expect(result).toEqual([1, 2]);
+  });
+
+  it("should handle null values in the array", async () => {
+    const array = [1, null, 3];
+    const callback = async (value: number) =>
+      value ? [value, value * 2] : [0];
+    // @ts-expect-error
+    const result = await flatMapAsync(array, callback);
+    expect(result).toEqual([1, 2, 0, 3, 6]);
+  });
+
+  it("should handle undefined values in the array", async () => {
+    const array = [1, undefined, 3];
+    const callback = async (value: number) =>
+      value ? [value, value * 2] : [0];
+    // @ts-expect-error
+    const result = await flatMapAsync(array, callback);
+    expect(result).toEqual([1, 2, 0, 3, 6]);
+  });
+});

package/src/util/flatMapAsync.ts

@@ -0,0 +1,37 @@
+// This utility function applies an async callback to each element of the input array (just like Array.prototype.map),
+// waits for all resulting promises to fulfill (similar to Promise.all), and then flattens the resulting array (like Array.prototype.flat).
+
+export async function flatMapAsync<T, O>(
+  array: T[], // The input array to transform.
+  callback: (value: T, index: number, array: T[]) => Promise<O[]>, // The async function to apply to each input array element.,
+  or?: O[] | ((error: any) => O[] | Promise<O[]>) // An optional callback to handle errors.
+): Promise<O[]> {
+  if (or) {
+    return flatMapAsync(
+      array,
+      async (value: T, index: number, array: T[]) => {
+        try {
+          return await callback(value, index, array);
+        } catch (error) {
+          return typeof or == "function" ? or(error) : or;
+        }
+      }
+      //
+    );
+  }
+
+  // Step 1: Use Array.prototype.map to transform each element of the input array with the provided callback.
+  // This will result in an array of promises.
+  const ps: Promise<O>[] = array.map(callback) as Promise<O>[];
+
+  // Step 2: Use Promise.all to wait for all promises in the array to fulfill.
+  // This will give us an array of fulfilled promise values.
+  const awaitedAll: Awaited<O>[] = await Promise.all(ps);
+
+  // Step 3: Flatten the array of fulfilled promise values into a single array.
+  // Note: The '@ts-ignore' comment is used to suppress TypeScript compiler warnings, as .flat() method might not be recognized
+  // as a valid method for an array of Awaited<O> instances. However, this code assumes that the result of Promise.all
+  // is indeed an array that can be flattened.
+  // @ts-ignore
+  return awaitedAll.flat() as O[];
+}

package/src/IsExportedCookie.ts

@@ -1,9 +0,0 @@
-import ExportedCookie from "./ExportedCookie";
-
-export function isExportedCookie(obj: any): obj is ExportedCookie {
-  return (
-    obj.domain !== undefined &&
-    obj.name !== undefined &&
-    obj.value !== undefined
-  );
-}

package/src/doSqliteQuery1Params.ts

@@ -1,8 +0,0 @@
-import CookieRow from "./CookieRow";
-
-export interface DoSqliteQuery1Params {
-  file: string;
-  sql: string;
-  rowFilter?: (row: any) => boolean;
-  rowTransform: (row: any) => CookieRow;
-}

package/src/utils.ts

@@ -1,25 +0,0 @@
-// noinspection JSUnusedGlobalSymbols
-
-import { exec, ExecException } from "child_process";
-
-export async function execSimple(command: string): Promise<string> {
-  return new Promise((resolve, reject) => {
-    exec(
-      command,
-      { encoding: "binary", maxBuffer: 5 * 1024 },
-      (error: ExecException | null, stdout: string, stderr: string) => {
-        if (error) {
-          reject(error);
-          return;
-        }
-        if (stderr) {
-          reject(error);
-          return;
-        }
-        if (stdout) {
-          resolve(stdout.trim());
-        }
-      }
-    );
-  });
-}