@genai-fi/base 3.0.1

package/dist/services/peer2peer/PeerConnection.d.ts

@@ -0,0 +1,40 @@
+import { default as EventEmitter } from 'eventemitter3';
+import { default as Peer, DataConnection } from 'peerjs';
+import { PeerConnectionType, PeerStatus } from './types';
+export default class PeerConnection extends EventEmitter<'open' | 'data' | 'close' | 'error' | 'crypto' | 'timeout'> {
+    private dataConnection?;
+    readonly peerInstance: Peer;
+    readonly peer: string;
+    private _connType;
+    private pubKey?;
+    private createCrypto?;
+    private encrypt?;
+    private decrypt?;
+    private queue?;
+    private connectTimeout;
+    readonly initiated: boolean;
+    private wsListener?;
+    get connectionType(): PeerConnectionType;
+    get open(): boolean;
+    get connectionId(): string;
+    /** Quality of the connection from 0 to 3. */
+    get quality(): number;
+    /** Create a connection. If the dataConnection parameter is missing then it uses the websocket as a relay. */
+    constructor(peer: string, peerInstance: Peer, initiated: boolean, dataConnection?: DataConnection, dropICE?: boolean);
+    getPublicKey(): string | undefined;
+    /** Set the remote public key */
+    setKey(key: string): Promise<void>;
+    /** Send our public key to the remote */
+    sendCryptoHandshake(): void;
+    /** For websocket data, decrypt it and emit the event */
+    decryptPayload(data: string): Promise<void>;
+    private sendEncrypted;
+    send(data: unknown): void;
+    close(): void;
+}
+export interface IConnectionIO extends EventEmitter<'connect' | 'retry' | 'close' | 'data'> {
+    direction: 'outgoing' | 'incoming';
+    connection: PeerConnection;
+    close: () => void;
+    status: PeerStatus;
+}

package/dist/services/peer2peer/PeerConnection.js

@@ -0,0 +1,155 @@
+var u = Object.defineProperty;
+var f = (h, c, e) => c in h ? u(h, c, { enumerable: !0, configurable: !0, writable: !0, value: e }) : h[c] = e;
+var o = (h, c, e) => f(h, typeof c != "symbol" ? c + "" : c, e);
+import { E as m } from "../../index-SOhdqzHq.js";
+import { createAsym as w } from "../../util/crypto.js";
+import { base64ToBytes as d, bytesToBase64 as l } from "../../util/base64.js";
+import y from "./error.js";
+const T = 1e4;
+class K extends m {
+  /** Create a connection. If the dataConnection parameter is missing then it uses the websocket as a relay. */
+  constructor(e, s, r, t, a) {
+    super();
+    o(this, "dataConnection");
+    o(this, "peerInstance");
+    o(this, "peer");
+    o(this, "_connType", "server");
+    o(this, "pubKey");
+    o(this, "createCrypto");
+    o(this, "encrypt");
+    o(this, "decrypt");
+    o(this, "queue");
+    o(this, "connectTimeout", -1);
+    o(this, "initiated");
+    o(this, "wsListener");
+    if (this.initiated = r, this.peerInstance = s, this.dataConnection = t, this.peer = e, t)
+      this._connType = "relay", t.on("open", () => {
+        clearTimeout(this.connectTimeout), this.connectTimeout = -1, t.peerConnection.getStats().then((i) => {
+          i.forEach((n) => {
+            if (n.type === "candidate-pair" && (n.state === "succeeded" || n.state === "in-progress")) {
+              const p = i.get(n.remoteCandidateId);
+              (p == null ? void 0 : p.candidateType) === "relay" ? this._connType = "relay" : p && (this._connType = "p2p");
+            }
+          }), this._connType === "server" && console.warn("Failed to find p2p candidate", Array.from(i)), this.emit("open", this);
+        });
+      }), t.on("close", () => {
+        this.emit("close", this, !1);
+      }), t.on("data", (i) => {
+        this.emit("data", i, this);
+      }), t.on("error", (i) => {
+        this.emit("error", i, this);
+      }), t.on("iceStateChanged", (i) => {
+        i === "disconnected" && t.open && t.close(), a && i === "checking" && (t.close(), this.emit("close", this, !1));
+      });
+    else {
+      this._connType = "server", w().then(({ createSymCrypto: n, publicKey: p }) => {
+        this.createCrypto = n, this.pubKey = p, this.sendCryptoHandshake(), this.emit("crypto");
+      }).catch(() => {
+        this.emit("error", { type: "no-crypto" }, this), this.close();
+      });
+      const i = (n) => {
+        n.src === this.peer && n.payload && (n.type === "KEY" ? this.setKey(n.payload) : n.type === "DATA" && this.decryptPayload(n.payload));
+      };
+      this.wsListener = i, this.peerInstance.socket.on("message", i), this.peerInstance.once("disconnected", () => {
+        this.wsListener && (this.peerInstance.socket.off("message", this.wsListener), this.wsListener = void 0), this.emit("close", this, !1);
+      });
+    }
+    this.initiated && (this.connectTimeout = window.setTimeout(() => {
+      this.connectTimeout = -1, this.open ? console.warn("Timeout, but already open") : (console.warn("Connect timeout", this), this.close(), this.emit("timeout", this));
+    }, T));
+  }
+  get connectionType() {
+    return this._connType;
+  }
+  get open() {
+    return this.dataConnection ? this.dataConnection.open : !!this.encrypt;
+  }
+  get connectionId() {
+    return this.peer;
+  }
+  /** Quality of the connection from 0 to 3. */
+  get quality() {
+    if (!this.open) return 0;
+    switch (this.connectionType) {
+      case "p2p":
+        return 3;
+      case "relay":
+        return 2;
+      case "server":
+        return 1;
+    }
+  }
+  getPublicKey() {
+    return this.pubKey;
+  }
+  /** Set the remote public key */
+  async setKey(e) {
+    if (this.dataConnection)
+      throw new y("Public key is not needed on P2P connection");
+    if (this.createCrypto) {
+      this.encrypt && console.warn("Key already received");
+      const { encrypt: s, decrypt: r } = await this.createCrypto(e);
+      this.encrypt = s, this.decrypt = r, clearTimeout(this.connectTimeout), this.connectTimeout = -1, this.emit("open", this), this.queue && (this.queue.forEach((t) => {
+        this.decryptPayload(t);
+      }), this.queue = void 0);
+    } else
+      this.once("crypto", () => {
+        this.setKey(e);
+      });
+  }
+  /** Send our public key to the remote */
+  sendCryptoHandshake() {
+    this.peerInstance.open && this.peerInstance.socket.send({
+      type: "KEY",
+      src: this.peerInstance.id,
+      dst: this.peer,
+      payload: this.pubKey
+    });
+  }
+  /** For websocket data, decrypt it and emit the event */
+  async decryptPayload(e) {
+    if (this.decrypt) {
+      const s = JSON.parse(e);
+      if (!s || !s.data || !s.iv) throw new y("Invalid encrypted packet");
+      const r = await d(s.data), t = await d(s.iv);
+      try {
+        const a = await this.decrypt(new Uint8Array(r), new Uint8Array(t));
+        this.emit("data", JSON.parse(a), this);
+      } catch {
+        console.error("Decryption error");
+      }
+    } else {
+      const s = this.queue || [];
+      s.push(e), this.queue = s;
+    }
+  }
+  async sendEncrypted(e) {
+    if (this.encrypt) {
+      const s = await this.encrypt(JSON.stringify(e)), r = await l(s[0]), t = await l(s[1]), a = JSON.stringify({
+        data: r,
+        iv: t
+      });
+      this.peerInstance.socket.send({
+        type: "DATA",
+        src: this.peerInstance.id,
+        dst: this.peer,
+        payload: a
+      });
+    } else
+      throw new y("Failed to send, no key");
+  }
+  send(e) {
+    this.dataConnection ? this.dataConnection.send(e) : this.sendEncrypted(e);
+  }
+  close() {
+    if (this.connectTimeout >= 0 && (clearTimeout(this.connectTimeout), this.connectTimeout = -1), this.dataConnection) {
+      this.dataConnection.removeAllListeners();
+      const e = this.dataConnection.open;
+      this.dataConnection.close(), e && this.emit("close", this, !0);
+    } else this.open && (this.encrypt = void 0, this.decrypt = void 0, this.emit("close", this, !0));
+    this.wsListener && (this.peerInstance.socket.off("message", this.wsListener), this.wsListener = void 0);
+  }
+}
+export {
+  K as default
+};

package/dist/services/peer2peer/error.d.ts

@@ -0,0 +1,2 @@
+export default class P2PException extends Error {
+}

package/dist/services/peer2peer/error.js

@@ -0,0 +1,5 @@
+class r extends Error {
+}
+export {
+  r as default
+};

package/dist/services/peer2peer/types.d.ts

@@ -0,0 +1,38 @@
+export type PeerStatus = 'connecting' | 'ready' | 'failed';
+export type PeerErrorType = 'none' | 'id-in-use' | 'peer-not-found' | 'no-signaling' | 'missing-ice' | 'unknown' | 'bad-browser';
+export type PeerConnectionType = 'p2p' | 'relay' | 'server';
+export interface PeerEvent {
+    event: string;
+}
+interface PeerCloseEvent extends PeerEvent {
+    event: 'eter:close';
+}
+interface PeerPingEvent extends PeerEvent {
+    event: 'ping';
+}
+interface PeerJoinEvent extends PeerEvent {
+    event: 'eter:join';
+}
+interface PeerWelcomeEvent extends PeerEvent {
+    event: 'eter:welcome';
+}
+interface PeerChainEvent extends PeerEvent {
+    event: 'eter:connect';
+    code: string;
+}
+export interface PeerJSMessage {
+    type: string;
+    dst: string;
+    src: string;
+    payload?: string;
+}
+export type BuiltinEvent = PeerWelcomeEvent | PeerCloseEvent | PeerJoinEvent | PeerChainEvent | PeerPingEvent;
+export type SenderType<T> = (data: T | BuiltinEvent, exclude?: string[]) => void;
+export interface Connection<T extends PeerEvent> {
+    send: (data: T) => void;
+    open: boolean;
+    quality: number;
+    connectionType: PeerConnectionType;
+    connectionId: string;
+}
+export {};

package/dist/services/peer2peer/types.js

@@ -0,0 +1 @@
+

package/dist/state/webrtcState.d.ts

@@ -0,0 +1,12 @@
+import { CommunicationRelayConfiguration } from '../components/ConnectionStatus/ice';
+type WebRTCPermissions = 'disabled' | 'unset' | 'full' | 'relay';
+export declare const webrtcActive: import('jotai').PrimitiveAtom<WebRTCPermissions> & {
+    init: WebRTCPermissions;
+};
+export declare const iceConfig: import('jotai').PrimitiveAtom<CommunicationRelayConfiguration | undefined> & {
+    init: CommunicationRelayConfiguration | undefined;
+};
+export declare const webrtcCandidate: import('jotai').PrimitiveAtom<"unset" | "relay" | "other"> & {
+    init: "unset" | "relay" | "other";
+};
+export {};

package/dist/state/webrtcState.js

@@ -0,0 +1,6 @@
+import { i, w as t, a as c } from "../webrtcState-D0nJpE9Z.js";
+export {
+  i as iceConfig,
+  t as webrtcActive,
+  c as webrtcCandidate
+};

package/dist/style/theme.d.ts

@@ -0,0 +1 @@
+export declare const theme: import('@mui/material').Theme;

package/dist/style/theme.js

@@ -0,0 +1,33 @@
+import { c as s } from "../createTheme-BIcG8YPQ.js";
+import '../assets/theme.css';const t = "#008297", a = {
+  primary: t
+};
+var e, o;
+const i = ((o = (e = globalThis == null ? void 0 : globalThis.process) == null ? void 0 : e.env) == null ? void 0 : o.NODE_ENV) === "test", m = s({
+  palette: {
+    primary: {
+      main: i ? "#fff" : a.primary
+    },
+    success: {
+      main: "#00972e"
+    }
+  },
+  typography: {
+    fontFamily: [
+      "Andika",
+      "-apple-system",
+      "BlinkMacSystemFont",
+      '"Segoe UI"',
+      "Roboto",
+      '"Helvetica Neue"',
+      "Arial",
+      "sans-serif",
+      '"Apple Color Emoji"',
+      '"Segoe UI Emoji"',
+      '"Segoe UI Symbol"'
+    ].join(",")
+  }
+});
+export {
+  m as theme
+};

package/dist/style.module-DSFm2eLD.js

@@ -0,0 +1,9 @@
+import './assets/style.css';const t = "_title_1bpz2_3", e = "_content_1bpz2_8", r = "_errorTitle_1bpz2_18", o = "_errorContent_1bpz2_23", n = {
+  title: t,
+  content: e,
+  errorTitle: r,
+  errorContent: o
+};
+export {
+  n as s
+};

package/dist/util/backoff.d.ts

@@ -0,0 +1 @@
+export declare function expBackoff(count: number, max?: number): number;

package/dist/util/backoff.js

@@ -0,0 +1,6 @@
+function o(t, n = 3) {
+  return Math.pow(2, Math.min(t, n)) * 1e3;
+}
+export {
+  o as expBackoff
+};

package/dist/util/base64.d.ts

@@ -0,0 +1,2 @@
+export declare function bytesToBase64(bytes: BlobPart, type?: string): Promise<string>;
+export declare function base64ToBytes(data: string): Promise<ArrayBuffer>;

package/dist/util/base64.js

@@ -0,0 +1,19 @@
+async function c(e, t = "application/octet-stream") {
+  return await new Promise((n, s) => {
+    const a = Object.assign(new FileReader(), {
+      onload: () => {
+        const r = a.result, o = r.indexOf(","), i = r.substring(o + 1);
+        n(i);
+      },
+      onerror: () => s(a.error)
+    });
+    a.readAsDataURL(new File([e], "", { type: t }));
+  });
+}
+async function d(e) {
+  return await (await fetch(`data:application/octet-stream;base64,${e}`)).arrayBuffer();
+}
+export {
+  d as base64ToBytes,
+  c as bytesToBase64
+};

package/dist/util/canvas.d.ts

@@ -0,0 +1,7 @@
+export declare function cropTo(image: HTMLImageElement | HTMLVideoElement, size: number, flipped: boolean, canvas: HTMLCanvasElement): HTMLCanvasElement;
+export declare function canvasFromFile(file: File, size?: number): Promise<HTMLCanvasElement>;
+export declare function canvasesFromFiles(files: File[], size?: number): Promise<HTMLCanvasElement[]>;
+export declare function canvasFromImage(image: HTMLImageElement, size?: number): Promise<HTMLCanvasElement>;
+export declare function canvasFromURL(url: string, size?: number): Promise<HTMLCanvasElement>;
+export declare function canvasFromDataTransfer(item: DataTransfer | DragEvent, size?: number): Promise<HTMLCanvasElement[]>;
+export declare function urlFromDataTransfer(item: DataTransfer | DragEvent, size?: number): Promise<string[]>;

package/dist/util/canvas.js

@@ -0,0 +1,92 @@
+function f(t, e, s, r) {
+  let n = t.width, o = t.height;
+  t instanceof HTMLVideoElement && (n = t.videoWidth, o = t.videoHeight);
+  const a = Math.min(n, o), c = e / a, l = Math.ceil(n * c), d = Math.ceil(o * c), h = l - e, u = d - e;
+  r.width = r.height = e;
+  const i = r.getContext("2d");
+  return i && (i.drawImage(t, ~~(h / 2) * -1, ~~(u / 2) * -1, l, d), s && (i.scale(-1, 1), i.drawImage(r, e * -1, 0))), r;
+}
+function m(t, e = 224) {
+  return new Promise((s, r) => {
+    const n = new FileReader();
+    n.onabort = () => r(), n.onerror = () => r(), n.onload = () => {
+      var c, l;
+      const o = document.createElement("canvas");
+      o.width = e, o.height = e;
+      const a = new Image();
+      a.onload = () => {
+        f(a, e, !1, o), s(o);
+      }, a.onerror = () => {
+        s(o);
+      }, a.src = n.result, ((l = (c = global == null ? void 0 : global.process) == null ? void 0 : c.env) == null ? void 0 : l.NODE_ENV) === "test" && a.onload(new Event("onload"));
+    }, n.readAsDataURL(t);
+  });
+}
+async function v(t, e = 224) {
+  const s = t.filter((n) => n.type.startsWith("image/"));
+  if (s.length === 0)
+    return [];
+  const r = s.map((n) => m(n, e));
+  return Promise.all(r);
+}
+function g(t, e = 224) {
+  return new Promise((s, r) => {
+    const n = document.createElement("canvas");
+    n.width = e, n.height = e, t.onload = () => {
+      f(t, e, !1, n), s(n);
+    }, t.onerror = r, t.onabort = r;
+  });
+}
+function w(t, e = 224) {
+  return new Promise((s, r) => {
+    const n = document.createElement("canvas");
+    n.width = e, n.height = e;
+    const o = new Image();
+    o.crossOrigin = "anonymous", o.onload = () => {
+      f(o, e, !1, n), s(n);
+    }, o.onerror = r, o.onabort = r, o.src = t;
+  });
+}
+async function p(t, e = 224) {
+  var s;
+  if ("files" in t && ((s = t.files) == null ? void 0 : s.length) > 0) {
+    const n = Array.from(t.files).filter((a) => a.type.startsWith("image/"));
+    if (n.length === 0)
+      return [];
+    const o = n.map((a) => m(a, e));
+    return Promise.all(o);
+  }
+  if ("html" in t && typeof t.html == "string") {
+    const r = document.createElement("html");
+    r.innerHTML = t.html;
+    const n = r.getElementsByTagName("img");
+    if (n.length > 0) {
+      const o = Array.from(n).map((a) => (a.crossOrigin = "anonymous", g(a, e)));
+      return Promise.all(o);
+    }
+  }
+  if ("dataTransfer" in t && t.dataTransfer) {
+    const r = t.dataTransfer.types;
+    if (r && r.includes("text/uri-list")) {
+      const n = t.dataTransfer.getData("text/uri-list");
+      if (n.length > 0) {
+        const a = n.split(`
+`).map((c) => w(c), e);
+        return Promise.all(a);
+      }
+    }
+  }
+  return [];
+}
+async function y(t, e = 224) {
+  return (await p(t, e)).map((r) => r.toDataURL());
+}
+export {
+  p as canvasFromDataTransfer,
+  m as canvasFromFile,
+  g as canvasFromImage,
+  w as canvasFromURL,
+  v as canvasesFromFiles,
+  f as cropTo,
+  y as urlFromDataTransfer
+};

package/dist/util/crypto.d.ts

@@ -0,0 +1,7 @@
+export declare function createAsym(): Promise<{
+    createSymCrypto: (rkey: string) => Promise<{
+        encrypt: (data: string) => Promise<[ArrayBuffer, Uint8Array]>;
+        decrypt: (data: ArrayBuffer, iv: Uint8Array) => Promise<string>;
+    }>;
+    publicKey: string;
+}>;

package/dist/util/crypto.js

@@ -0,0 +1,50 @@
+function y(e) {
+  return new TextDecoder().decode(e);
+}
+function o(e) {
+  return new TextEncoder().encode(e);
+}
+async function s() {
+  const e = await crypto.subtle.generateKey(
+    {
+      name: "ECDH",
+      namedCurve: "P-384"
+    },
+    !0,
+    ["deriveKey", "deriveKey"]
+  );
+  return {
+    createSymCrypto: async (r) => {
+      const n = await crypto.subtle.importKey(
+        "jwk",
+        JSON.parse(r),
+        { name: "ECDH", namedCurve: "P-384" },
+        !1,
+        []
+      ), a = await crypto.subtle.deriveKey(
+        {
+          name: "ECDH",
+          public: n
+        },
+        e.privateKey,
+        {
+          name: "AES-GCM",
+          length: 256
+        },
+        !1,
+        ["encrypt", "decrypt"]
+      );
+      return {
+        encrypt: async (c) => {
+          const t = crypto.getRandomValues(new Uint8Array(12));
+          return [await crypto.subtle.encrypt({ name: "AES-GCM", iv: t }, a, o(c)), t];
+        },
+        decrypt: async (c, t) => y(await crypto.subtle.decrypt({ name: "AES-GCM", iv: t }, a, c))
+      };
+    },
+    publicKey: JSON.stringify(await crypto.subtle.exportKey("jwk", e.publicKey))
+  };
+}
+export {
+  s as createAsym
+};

package/dist/util/randomId.d.ts

@@ -0,0 +1 @@
+export default function randomId(length?: number): string;

package/dist/util/randomId.js

@@ -0,0 +1,8 @@
+const a = "0123456789";
+function e(t = 8) {
+  const r = new Uint32Array(t);
+  return crypto.getRandomValues(r), Array.from(r).map((n) => a.charAt(n % a.length)).join("");
+}
+export {
+  e as default
+};

package/dist/util/zip.d.ts

@@ -0,0 +1,13 @@
+import { default as JSZip } from 'jszip';
+export declare function getZipBlob(content: string | ArrayBuffer | File, progress?: (percent: number) => void): Promise<Blob>;
+export interface ZipData {
+    [key: string]: unknown;
+    images?: Map<string, string>;
+}
+export declare function loadZipFile(file: File | Blob | ArrayBuffer | string): Promise<ZipData>;
+type ZipOutput<T extends JSZip.OutputType> = ReturnType<typeof JSZip.prototype.generateAsync<T>>;
+export declare function createZip<T extends JSZip.OutputType>(type: T, data: ZipData): Promise<ZipOutput<T>>;
+export declare function createZipBlob(data: ZipData): Promise<Blob>;
+export declare function createZipArrayBuffer(data: ZipData): Promise<ArrayBuffer>;
+export declare function saveZipFile(data: ZipData, name?: string): Promise<Blob>;
+export {};

package/dist/util/zip.js

@@ -0,0 +1,94 @@
+import { J as l, F as b } from "../FileSaver.min-DhePf63e.js";
+async function m(n, e) {
+  if (typeof n == "string") {
+    e && e(0);
+    const i = await fetch(n);
+    if (i.status !== 200)
+      throw console.error(i), new Error("zip_fetch_failed");
+    const t = [];
+    if (i.body) {
+      const a = i.body.getReader(), f = parseInt(i.headers.get("Content-Length") || "1");
+      let s = 0;
+      for (; s < f; ) {
+        const { done: r, value: o } = await a.read();
+        if (r)
+          break;
+        t.push(o), s += o.length, e && e(Math.floor(s / f * 100));
+      }
+    }
+    return new Blob(t);
+  } else if (n instanceof File) {
+    const i = await n.arrayBuffer();
+    return e && e(100), new Blob([i]);
+  } else
+    return e && e(100), new Blob([n]);
+}
+async function h(n) {
+  const e = n instanceof Blob ? n : m(n), i = await l.loadAsync(e), t = {}, a = [];
+  return i.forEach((f, s) => {
+    if (/\.json$/.test(s.name))
+      a.push(
+        s.async("string").then((r) => {
+          const o = s.name.replace(".json", "");
+          t[o] = JSON.parse(r);
+        })
+      );
+    else if (/\.bin$/.test(s.name))
+      a.push(
+        s.async("arraybuffer").then((r) => {
+          const o = s.name.replace(".bin", "");
+          t[o] = r;
+        })
+      );
+    else {
+      const r = s.name.split("/");
+      if (r.length === 2 && r[1] && (r[0] === "images" || r[0] === "samples")) {
+        t.images = /* @__PURE__ */ new Map();
+        const o = r[1].split(".");
+        o.length === 2 && a.push(
+          s.async("base64").then((u) => {
+            var c;
+            (c = t.images) == null || c.set(
+              o[0],
+              `data:image/${o[1] === "png" ? "png" : "jpeg"};base64,${u}`
+            );
+          })
+        );
+      }
+    }
+  }), await Promise.all(a), t;
+}
+async function p(n, e) {
+  const i = new l();
+  if (e.images) {
+    const t = i.folder("images");
+    t && e.images.forEach((a, f) => {
+      const s = a.split(";base64,");
+      t.file(`${f}.${s[0] === "png" ? "png" : "jpg"}`, s[1], { base64: !0 });
+    });
+  }
+  for (const t in e) {
+    if (t === "images") continue;
+    const a = e[t];
+    a instanceof ArrayBuffer ? i.file(`${t}.bin`, a) : i.file(`${t}.json`, JSON.stringify(e[t], void 0, 4));
+  }
+  return i.generateAsync({ type: n });
+}
+async function y(n) {
+  return p("blob", n);
+}
+async function w(n) {
+  return p("arraybuffer", n);
+}
+async function B(n, e) {
+  const i = await y(n);
+  return b.saveAs(i, `${e || "data"}.zip`), i;
+}
+export {
+  p as createZip,
+  w as createZipArrayBuffer,
+  y as createZipBlob,
+  m as getZipBlob,
+  h as loadZipFile,
+  B as saveZipFile
+};