@ethora/chat-component 26.8.2 → 26.9.2

package/dist/VisibilityModal-Dq_1oMwl.js

@@ -0,0 +1,138 @@
+import { jsxs as r, jsx as s } from "react/jsx-runtime";
+import { useState as b, useEffect as x } from "react";
+import { x as o, a as L, p as P, u as z, aG as D, aH as I } from "./main-DaxJ3rMp.js";
+import { S as N, D as C, a as $, b as k, e as w, f as p } from "./SideDrawer-DTXPBfJl.js";
+o.div``;
+o.div`
+  font-size: 16px;
+  font-weight: bold;
+  color: var(--ethora-color-text, #141414);
+`;
+o.p`
+  font-size: 14px;
+  color: var(--ethora-color-text-muted, #6b7280);
+  margin-bottom: 32px;
+`;
+const O = o.div`
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+`, h = o.label`
+  display: flex;
+  align-items: center;
+  font-size: 14px;
+  gap: 8px;
+`, u = o.input`
+  accent-color: ${({ $radioColor: i }) => i || "var(--ethora-color-primary, #0052CD)"};
+  margin: 0px;
+`, R = o.div`
+  padding: 10px 15px;
+  margin-top: 16px;
+  color: ${({ type: i }) => i === "success" ? "#10b981" : "#ef4444"};
+  background: ${({ type: i }) => i === "success" ? "#d1fae5" : "#fee2e2"};
+  border: 1px solid
+    ${({ type: i }) => i === "success" ? "#10b981" : "#ef4444"};
+  border-radius: 4px;
+
+  [data-ethora-color-scheme='dark'] & {
+    color: ${({ type: i }) => i === "success" ? "var(--ethora-color-success, #10b981)" : "var(--ethora-color-danger, #ef4444)"};
+    background: ${({ type: i }) => i === "success" ? "rgba(16, 185, 129, 0.15)" : "rgba(242, 118, 107, 0.15)"};
+    border-color: ${({ type: i }) => i === "success" ? "var(--ethora-color-success, #10b981)" : "var(--ethora-color-danger, #ef4444)"};
+  }
+`, H = ({
+  handleCloseModal: i
+}) => {
+  const S = L(), e = P(), { user: n, config: l } = z(
+    (t) => t.chatSettingStore
+  ), g = (t) => S(I(t)), [a, m] = b(n?.isProfileOpen), [c, v] = b(n?.isAssetsOpen), [f, y] = b(null), d = (t, A) => {
+    y({ message: t, type: A }), setTimeout(() => y(null), 3e3);
+  };
+  return x(() => {
+    a !== n.isProfileOpen && D({ isProfileOpen: a }).then(({ data: t }) => {
+      g(t.user), d(e("notification.saved"), "success");
+    }).catch(() => d(e("toast.error"), "error"));
+  }, [a]), x(() => {
+    c !== n?.isAssetsOpen && D({ isAssetsOpen: c }).then(({ data: t }) => {
+      g(t.user), d(e("notification.saved"), "success");
+    }).catch(() => d(e("toast.error"), "error"));
+  }, [c]), /* @__PURE__ */ r(
+    N,
+    {
+      title: e("settings.visibility.title"),
+      onClose: i,
+      backLabel: e("action.back"),
+      children: [
+        /* @__PURE__ */ r(C, { children: [
+          /* @__PURE__ */ s($, { children: e("settings.visibility.profileLabel") }),
+          /* @__PURE__ */ s(k, { children: /* @__PURE__ */ s(w, { children: /* @__PURE__ */ r(O, { children: [
+            /* @__PURE__ */ r(h, { children: [
+              /* @__PURE__ */ s(
+                u,
+                {
+                  $radioColor: l?.colors?.primary,
+                  type: "radio",
+                  name: "ethora-profile-visibility",
+                  checked: a === !0,
+                  onChange: () => m(!0)
+                }
+              ),
+              e("settings.visibility.open")
+            ] }),
+            /* @__PURE__ */ s(p, { children: e("settings.visibility.openDescription") }),
+            /* @__PURE__ */ r(h, { children: [
+              /* @__PURE__ */ s(
+                u,
+                {
+                  $radioColor: l?.colors?.primary,
+                  type: "radio",
+                  name: "ethora-profile-visibility",
+                  checked: a === !1,
+                  onChange: () => m(!1)
+                }
+              ),
+              e("settings.visibility.restricted")
+            ] }),
+            /* @__PURE__ */ s(p, { children: e("settings.visibility.restrictedDescription") })
+          ] }) }) })
+        ] }),
+        /* @__PURE__ */ r(C, { children: [
+          /* @__PURE__ */ s($, { children: e("settings.visibility.documentsLabel") }),
+          /* @__PURE__ */ s(k, { children: /* @__PURE__ */ s(w, { children: /* @__PURE__ */ r(O, { children: [
+            /* @__PURE__ */ r(h, { children: [
+              /* @__PURE__ */ s(
+                u,
+                {
+                  $radioColor: l?.colors?.primary,
+                  type: "radio",
+                  name: "ethora-documents-visibility",
+                  checked: c === !0,
+                  onChange: () => v(!0)
+                }
+              ),
+              e("settings.visibility.full")
+            ] }),
+            /* @__PURE__ */ s(p, { children: e("settings.visibility.fullDescription") }),
+            /* @__PURE__ */ r(h, { children: [
+              /* @__PURE__ */ s(
+                u,
+                {
+                  $radioColor: l?.colors?.primary,
+                  type: "radio",
+                  name: "ethora-documents-visibility",
+                  checked: c === !1,
+                  onChange: () => v(!1)
+                }
+              ),
+              e("settings.visibility.individual")
+            ] }),
+            /* @__PURE__ */ s(p, { children: e("settings.visibility.individualDescription") })
+          ] }) }) })
+        ] }),
+        f && /* @__PURE__ */ s(R, { type: f.type, children: f.message })
+      ]
+    }
+  );
+};
+export {
+  H as default
+};

package/dist/components/MainComponents/SealedAttachmentList.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+import { IAttachment } from '../../types/types';
+/**
+ * Sealed attachments, offered as downloads rather than previews.
+ *
+ * `keys` are positional: keys[i] opens attachments[i] (getDataFromXml lifts
+ * them out of the OMEMO-decrypted <body>). An attachment with no key belongs
+ * to a message we could not decrypt, and renders as unavailable.
+ */
+declare const SealedAttachmentList: React.FC<{
+    attachments: IAttachment[];
+    keys?: string[];
+}>;
+export default SealedAttachmentList;

package/dist/components/RoomComponents/styled/LastMessageSealed.d.ts

@@ -0,0 +1,14 @@
+import { FC } from 'react';
+import { LastMessage } from '../../../types/types';
+interface LastMessageSealedProps extends Pick<LastMessage, 'user'> {
+}
+/**
+ * Room-list preview for a sealed attachment.
+ *
+ * It cannot say what the file is: the name and type are inside the seal and
+ * only come out on download, and the server-held ones are placeholders - an
+ * opaque `originalName` and `application/octet-stream`. So it says exactly
+ * what is known, which is that an encrypted file arrived.
+ */
+declare const LastMessageSealed: FC<LastMessageSealedProps>;
+export default LastMessageSealed;

package/dist/components/RoomComponents/styled/StyledRoomComponents.d.ts

@@ -1,7 +1,9 @@
 import { default as React } from 'react';
 export declare const LastRoomMessageContainer: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
-export declare const LastRoomMessageName: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
-export declare const LastRoomMessageText: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const LastRoomMessageName: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>> & string;
+export declare const LastRoomMessageText: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>> & string;
+/** Thumbnail/icon + label for a media preview, flowing in the same line. */
+export declare const LastRoomMessageMedia: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>> & string;
 export declare const NewMessageMarker: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
 export declare const LastMessageImg: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, never>> & string;
 export declare const ShadeWrapper: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;

package/dist/components/styled/AudioMessage.d.ts

@@ -2,5 +2,43 @@ import { default as React } from 'react';
 interface AudioMessageProps {
     src: string;
 }
+/**
+ * wavesurfer paints into a canvas, and a canvas fill takes a concrete
+ * colour - it cannot read `var(--ethora-color-primary)` or `color-mix()`
+ * portably. So the colours are resolved off the DOM and mixed here.
+ */
+type Rgb = {
+    r: number;
+    g: number;
+    b: number;
+};
+/**
+ * Played and unplayed bar colours for whatever this bubble turned out to
+ * be. The brand colour leads when it can be seen against the bubble; when
+ * it cannot (own-message bubbles, and any host whose primary is close to
+ * its own surface) the bubble's text colour takes over, which is readable
+ * on that surface by definition. Unplayed bars are the same colour mixed
+ * halfway into the surface, so they read as "the rest of the clip" rather
+ * than as a different element.
+ */
+export declare const resolveWaveColors: (primary: string, text: string, surface: Rgb) => {
+    wave: string;
+    progress: string;
+};
+/**
+ * Bars for one voice note.
+ *
+ * NOT the peak envelope wavesurfer draws by itself. Measured on a real QA
+ * recording: two transients hit 0.98 and 0.99 while the speech around them
+ * sits at an RMS of 0.002 to 0.058. Scaled against the peak, those two
+ * samples own the whole 28px and every other bar collapses to a hairline -
+ * the "faint dashed line with a couple of spikes" look these bubbles had.
+ *
+ * So: RMS per bucket (what the ear hears, not the worst sample), scaled
+ * against the 95th percentile so a single click cannot set the scale, then
+ * a square-root curve because loudness is perceived that way, and a floor
+ * so a quiet passage still reads as a bar rather than as nothing.
+ */
+export declare const buildWaveformPeaks: (samples: Float32Array, barCount: number) => number[];
 declare const AudioMessage: React.FC<AudioMessageProps>;
 export default AudioMessage;

package/dist/e2ee/fileEnvelope.d.ts

@@ -0,0 +1,48 @@
+/** What the server must not learn, and the receiver needs to render. */
+export interface FileEnvelopeMeta {
+    mimetype: string;
+    originalname: string;
+    size: number;
+}
+export interface SealedFile {
+    /** Ciphertext, ready to upload. */
+    ciphertext: Uint8Array;
+    /** Base64 of the 48-byte key material. Belongs in the encrypted <body>. */
+    keyMaterial: string;
+    /** Random, extension-free name to upload under. */
+    filename: string;
+}
+/**
+ * MAGIC(8) | version(1) | headerLen(4, big-endian) | headerJSON | fileBytes
+ *
+ * Length-prefixed rather than delimited: a JSON header is arbitrary text and
+ * the body is arbitrary bytes, so there is no separator that cannot occur in
+ * either.
+ */
+export declare function encodeFileEnvelope(meta: FileEnvelopeMeta, bytes: Uint8Array): Uint8Array;
+export declare function decodeFileEnvelope(envelope: Uint8Array): {
+    meta: FileEnvelopeMeta;
+    bytes: Uint8Array;
+};
+/**
+ * Seal a file for upload.
+ *
+ * Reuses the OMEMO payload primitives (AES-256-CBC + truncated HMAC, fresh
+ * random key per call) so attachments and message bodies are protected by the
+ * same construction rather than a second, separately-reviewed one.
+ */
+export declare function sealFileForUpload(file: File | Blob): Promise<SealedFile>;
+/** Inverse of sealFileForUpload, for the receiving side. */
+export declare function openSealedFile(ciphertext: Uint8Array, keyMaterial: string): {
+    meta: FileEnvelopeMeta;
+    bytes: Uint8Array;
+};
+/**
+ * Pull the attachment keys out of a decrypted media <body>.
+ *
+ * The sender put `{v:1,keys:[...]}` there instead of the usual literal
+ * "media" (see sendMediaMessage). Returns undefined for anything else, so
+ * an ordinary media message - or one from a build that predates sealing -
+ * falls through untouched.
+ */
+export declare function parseSealedMediaBody(body?: string): string[] | undefined;

package/dist/{handleCopyClick-tizCFAb8.js → handleCopyClick-Cv8OCQA-.js}

@@ -1,4 +1,4 @@
-import { v as e, x as t } from "./main-DkokKp7d.js";
+import { x as e, z as t } from "./main-DaxJ3rMp.js";
 const i = e.div`
   display: flex;
   flex-direction: column;
@@ -59,7 +59,7 @@ const i = e.div`
   padding: var(--ethora-space-1, 4px) var(--ethora-space-3, 12px);
   border-radius: var(--ethora-radius-full, 999px);
   background: var(--ethora-color-primary-soft, #e7edf9);
-  color: var(--ethora-color-primary, #0052cd);
+  color: var(--ethora-color-primary-text, var(--ethora-color-primary, #0052cd));
   font-size: var(--ethora-font-size-xs, 12px);
   font-weight: var(--ethora-font-weight-semibold, 600);
 

package/dist/helpers/sealedAttachments.d.ts

@@ -0,0 +1,25 @@
+import { FileEnvelopeMeta } from '../e2ee/fileEnvelope';
+export interface OpenedAttachment {
+    bytes: Uint8Array;
+    meta: FileEnvelopeMeta;
+}
+/**
+ * Fetch and decrypt one sealed attachment.
+ *
+ * `url` must already carry the viewer's `?ft=` token where the file is
+ * membership-gated - this is a plain fetch of whatever it is given.
+ */
+export declare function openSealedAttachment(url: string, keyMaterial: string, fetchImpl?: typeof fetch): Promise<OpenedAttachment>;
+/** Hands a blob to the browser as a download. Injectable for tests. */
+export type SaveBlob = (blob: Blob, fileName: string) => void;
+/**
+ * Fetch, decrypt and save one sealed attachment under its real filename.
+ *
+ * Returns the recovered metadata so the caller can label the card with the
+ * real name once it is known - before the first download there is no way to
+ * know it, because it lives inside the seal.
+ */
+export declare function saveSealedAttachment(url: string, keyMaterial: string, deps?: {
+    fetchImpl?: typeof fetch;
+    save?: SaveBlob;
+}): Promise<FileEnvelopeMeta>;