@abraca/nuxt 0.1.0

package/dist/runtime/utils/VoiceClient.js

@@ -0,0 +1,599 @@
+import { createNanoEvents } from "nanoevents";
+import { VoiceErrorCode, createVoiceError } from "./voiceErrors.js";
+const ICE_SERVERS = [
+  { urls: "stun:stun.l.google.com:19302" },
+  { urls: "stun:stun1.l.google.com:19302" }
+];
+function computeRms(buf) {
+  let sum = 0;
+  for (let i = 0; i < buf.length; i++) sum += buf[i] * buf[i];
+  return Math.sqrt(sum / buf.length) / 255;
+}
+export class VoiceClient {
+  constructor(url) {
+    this.url = url;
+  }
+  ws = null;
+  audioCtx = null;
+  _masterVolume = 1;
+  localStream = null;
+  _localVideoStream = null;
+  _localScreenStream = null;
+  localAudioTimer = null;
+  peerConnections = /* @__PURE__ */ new Map();
+  peerAudio = /* @__PURE__ */ new Map();
+  peers = /* @__PURE__ */ new Map();
+  emitter = createNanoEvents();
+  myPeerId = null;
+  _muted = false;
+  _videoEnabled = false;
+  _screenEnabled = false;
+  _profile = null;
+  _status = "idle";
+  /** Serialises async message handling so messages never run concurrently. */
+  _msgQueue = Promise.resolve();
+  on(event, handler) {
+    return this.emitter.on(event, handler);
+  }
+  get status() {
+    return this._status;
+  }
+  get isMuted() {
+    return this._muted;
+  }
+  get videoEnabled() {
+    return this._videoEnabled;
+  }
+  get screenEnabled() {
+    return this._screenEnabled;
+  }
+  get localVideoStream() {
+    return this._localVideoStream;
+  }
+  get localScreenStream() {
+    return this._localScreenStream;
+  }
+  setStatus(s) {
+    this._status = s;
+    this.emitter.emit("statusChange", s);
+  }
+  send(msg) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+  async connect() {
+    if (this._status === "connecting" || this._status === "connected") return;
+    if (typeof window !== "undefined" && !window.isSecureContext) {
+      this.emitter.emit("error", createVoiceError(VoiceErrorCode.INSECURE_CONTEXT));
+      return;
+    }
+    this.setStatus("connecting");
+    try {
+      this.localStream = await navigator.mediaDevices.getUserMedia({
+        audio: true,
+        video: false
+      });
+    } catch (e) {
+      const name = e?.name ?? "";
+      const code = name === "NotAllowedError" || name === "PermissionDeniedError" ? VoiceErrorCode.MICROPHONE_PERMISSION_DENIED : name === "NotFoundError" ? VoiceErrorCode.MICROPHONE_NOT_FOUND : VoiceErrorCode.MEDIA_GENERIC;
+      this.emitter.emit("error", createVoiceError(code, e?.message));
+      this.setStatus("disconnected");
+      return;
+    }
+    this.audioCtx = new AudioContext();
+    if (this.audioCtx.state === "suspended") {
+      await this.audioCtx.resume();
+    }
+    const localSource = this.audioCtx.createMediaStreamSource(this.localStream);
+    const localAnalyser = this.audioCtx.createAnalyser();
+    localAnalyser.fftSize = 256;
+    localSource.connect(localAnalyser);
+    const localBuf = new Uint8Array(localAnalyser.frequencyBinCount);
+    this.localAudioTimer = setInterval(() => {
+      localAnalyser.getByteFrequencyData(localBuf);
+      this.emitter.emit("localAudioLevel", computeRms(localBuf));
+    }, 100);
+    try {
+      this.ws = new WebSocket(this.url);
+    } catch (e) {
+      this.emitter.emit("error", createVoiceError(VoiceErrorCode.CONNECT_FAILED, e?.message));
+      this.setStatus("disconnected");
+      return;
+    }
+    this.ws.addEventListener("message", (ev) => {
+      let msg;
+      try {
+        msg = JSON.parse(ev.data);
+      } catch {
+        return;
+      }
+      this._msgQueue = this._msgQueue.then(() => this.handleMessage(msg)).catch((err) => {
+        this.emitter.emit(
+          "error",
+          createVoiceError(VoiceErrorCode.UNKNOWN, String(err?.message ?? err))
+        );
+      });
+    });
+    this.ws.addEventListener("error", () => {
+      this.emitter.emit("error", createVoiceError(VoiceErrorCode.WEBSOCKET_ERROR));
+    });
+    this.ws.addEventListener("close", () => {
+      if (this._status === "connected" || this._status === "connecting") {
+        this.setStatus("disconnected");
+      }
+    });
+  }
+  async handleMessage(msg) {
+    switch (msg.type) {
+      case "welcome": {
+        this.myPeerId = msg.peer_id;
+        this.setStatus("connected");
+        if (this._profile) {
+          this.send({ type: "profile", name: this._profile.name, color: this._profile.color });
+        }
+        for (const info of msg.peers ?? []) {
+          const peer = this.addPeer(info.peer_id, info.user_id, info.muted);
+          if (info.video) peer.remoteVideo = true;
+          if (info.screen) peer.remoteScreen = true;
+          if (info.name) peer.displayName = info.name;
+          if (info.color) peer.color = info.color;
+          this.emitter.emit("peerJoined", peer);
+          await this.initiateOffer(info.peer_id);
+        }
+        break;
+      }
+      case "joined": {
+        const peer = this.addPeer(msg.peer_id, msg.user_id, msg.muted ?? false);
+        if (msg.video) peer.remoteVideo = true;
+        if (msg.screen) peer.remoteScreen = true;
+        if (msg.name) peer.displayName = msg.name;
+        if (msg.color) peer.color = msg.color;
+        this.emitter.emit("peerJoined", peer);
+        break;
+      }
+      case "left": {
+        const peerId = msg.peer_id;
+        this.emitter.emit("peerVideoStream", peerId, null, "camera");
+        this.emitter.emit("peerVideoStream", peerId, null, "screen");
+        this.removePeer(peerId);
+        this.emitter.emit("peerLeft", peerId);
+        break;
+      }
+      case "offer": {
+        await this.handleOffer(msg.from, msg.sdp);
+        break;
+      }
+      case "answer": {
+        const pc = this.peerConnections.get(msg.from);
+        if (pc) {
+          try {
+            await pc.setRemoteDescription(
+              new RTCSessionDescription({ type: "answer", sdp: msg.sdp })
+            );
+          } catch (e) {
+            this.emitter.emit("error", createVoiceError(VoiceErrorCode.ANSWER_FAILED, e?.message));
+          }
+        }
+        break;
+      }
+      case "ice": {
+        const pc = this.peerConnections.get(msg.from);
+        if (pc && msg.candidate) {
+          try {
+            await pc.addIceCandidate(new RTCIceCandidate(JSON.parse(msg.candidate)));
+          } catch (e) {
+            this.emitter.emit("error", createVoiceError(VoiceErrorCode.ICE_FAILED, e?.message));
+          }
+        }
+        break;
+      }
+      case "mute": {
+        const peer = this.peers.get(msg.peer_id);
+        if (peer) {
+          peer.remoteMuted = msg.muted;
+          this.emitter.emit("remoteMute", msg.peer_id, msg.muted);
+        }
+        break;
+      }
+      case "media-state": {
+        const peer = this.peers.get(msg.peer_id);
+        if (peer) {
+          peer.remoteVideo = msg.video;
+          peer.remoteScreen = msg.screen;
+          this.emitter.emit("peerMediaState", msg.peer_id, msg.video, msg.screen);
+        }
+        break;
+      }
+      case "profile": {
+        const peer = this.peers.get(msg.peer_id);
+        if (peer) {
+          peer.displayName = msg.name;
+          peer.color = msg.color;
+          this.emitter.emit("peerProfile", msg.peer_id, msg.name, msg.color);
+        }
+        break;
+      }
+      case "ping": {
+        this.send({ type: "pong" });
+        break;
+      }
+      case "error": {
+        const code = msg.code === "room_full" ? VoiceErrorCode.ROOM_FULL : msg.code === "forbidden" ? VoiceErrorCode.ROOM_FORBIDDEN : VoiceErrorCode.UNKNOWN;
+        this.emitter.emit("error", createVoiceError(code, msg.message));
+        break;
+      }
+    }
+  }
+  addPeer(peerId, userId, remoteMuted) {
+    const peer = {
+      id: peerId,
+      userId,
+      stream: null,
+      videoStream: null,
+      screenStream: null,
+      remoteMuted,
+      localMuted: false,
+      audioLevel: 0,
+      remoteVideo: false,
+      remoteScreen: false,
+      displayName: null,
+      color: null
+    };
+    this.peers.set(peerId, peer);
+    return peer;
+  }
+  removePeer(peerId) {
+    this.closePeerConnection(peerId);
+    const pa = this.peerAudio.get(peerId);
+    if (pa) {
+      clearInterval(pa.timer);
+      pa.audio.pause();
+      pa.audio.srcObject = null;
+      pa.source?.disconnect();
+      pa.analyser?.disconnect();
+      this.peerAudio.delete(peerId);
+    }
+    this.peers.delete(peerId);
+  }
+  wirePcEvents(pc, peerId) {
+    pc.onicecandidate = (e) => {
+      if (e.candidate) {
+        this.send({ type: "ice", to: peerId, candidate: JSON.stringify(e.candidate) });
+      }
+    };
+    pc.onconnectionstatechange = () => {
+      if (pc.connectionState === "failed") {
+        this.emitter.emit("error", createVoiceError(VoiceErrorCode.PEER_CONNECTION_FAILED, peerId));
+      }
+    };
+    pc.oniceconnectionstatechange = () => {
+      if (pc.iceConnectionState === "failed") {
+        this.emitter.emit("error", createVoiceError(VoiceErrorCode.ICE_FAILED, `ICE negotiation failed for peer ${peerId}`));
+      }
+    };
+    pc.ontrack = (e) => {
+      const peer = this.peers.get(peerId);
+      if (!peer) return;
+      const transceiver = e.transceiver;
+      const transceivers = pc.getTransceivers();
+      const idx = transceivers.indexOf(transceiver);
+      if (idx === 0) {
+        const audioStream = e.streams[0] ?? new MediaStream([e.track]);
+        peer.stream = audioStream;
+        this.emitter.emit("peerStream", peer);
+        this.setupPeerAudio(peerId, audioStream);
+      } else if (idx === 1) {
+        const videoStream = new MediaStream([e.track]);
+        peer.videoStream = videoStream;
+        this.emitter.emit("peerVideoStream", peerId, videoStream, "camera");
+      } else if (idx === 2) {
+        const screenStream = new MediaStream([e.track]);
+        peer.screenStream = screenStream;
+        this.emitter.emit("peerVideoStream", peerId, screenStream, "screen");
+      }
+    };
+  }
+  closePeerConnection(peerId) {
+    const existing = this.peerConnections.get(peerId);
+    if (existing) {
+      existing.ontrack = null;
+      existing.onicecandidate = null;
+      existing.onconnectionstatechange = null;
+      existing.oniceconnectionstatechange = null;
+      existing.close();
+      this.peerConnections.delete(peerId);
+    }
+  }
+  /**
+   * Create a new PC as the offerer — pre-creates the 3-transceiver layout
+   * (audio, camera video, screen video) so the offer SDP defines the m-line order.
+   */
+  createPeerConnectionForOffer(peerId) {
+    this.closePeerConnection(peerId);
+    const pc = new RTCPeerConnection({ iceServers: ICE_SERVERS });
+    this.peerConnections.set(peerId, pc);
+    const audioTrack = this.localStream?.getAudioTracks()[0] ?? null;
+    if (audioTrack) {
+      pc.addTransceiver(audioTrack, { direction: "sendrecv", streams: [this.localStream] });
+    } else {
+      pc.addTransceiver("audio", { direction: "recvonly" });
+    }
+    const cameraTrack = this._localVideoStream?.getVideoTracks()[0] ?? null;
+    if (cameraTrack) {
+      pc.addTransceiver(cameraTrack, { direction: "sendrecv", streams: [this._localVideoStream] });
+    } else {
+      pc.addTransceiver("video", { direction: "recvonly" });
+    }
+    const screenTrack = this._localScreenStream?.getVideoTracks()[0] ?? null;
+    if (screenTrack) {
+      pc.addTransceiver(screenTrack, { direction: "sendrecv", streams: [this._localScreenStream] });
+    } else {
+      pc.addTransceiver("video", { direction: "recvonly" });
+    }
+    this.wirePcEvents(pc, peerId);
+    return pc;
+  }
+  /**
+   * Create a new PC as the answerer — does NOT pre-create transceivers.
+   * `setRemoteDescription(offer)` will create them to match the offer's m-lines.
+   */
+  createPeerConnectionForAnswer(peerId) {
+    this.closePeerConnection(peerId);
+    const pc = new RTCPeerConnection({ iceServers: ICE_SERVERS });
+    this.peerConnections.set(peerId, pc);
+    this.wirePcEvents(pc, peerId);
+    return pc;
+  }
+  attachLocalTracksToAnswer(pc) {
+    const transceivers = pc.getTransceivers();
+    const audioTrack = this.localStream?.getAudioTracks()[0] ?? null;
+    if (transceivers[0] && audioTrack) {
+      transceivers[0].sender.replaceTrack(audioTrack);
+      transceivers[0].direction = "sendrecv";
+    }
+    const cameraTrack = this._localVideoStream?.getVideoTracks()[0] ?? null;
+    if (transceivers[1] && cameraTrack) {
+      transceivers[1].sender.replaceTrack(cameraTrack);
+      transceivers[1].direction = "sendrecv";
+    }
+    const screenTrack = this._localScreenStream?.getVideoTracks()[0] ?? null;
+    if (transceivers[2] && screenTrack) {
+      transceivers[2].sender.replaceTrack(screenTrack);
+      transceivers[2].direction = "sendrecv";
+    }
+  }
+  setupPeerAudio(peerId, stream) {
+    const old = this.peerAudio.get(peerId);
+    if (old) {
+      clearInterval(old.timer);
+      old.audio.pause();
+      old.audio.srcObject = null;
+      old.source?.disconnect();
+      old.analyser?.disconnect();
+    }
+    const audio = new Audio();
+    audio.srcObject = stream;
+    audio.autoplay = true;
+    const peer = this.peers.get(peerId);
+    audio.volume = peer?.localMuted ? 0 : this._masterVolume;
+    audio.play().catch((err) => {
+      this.emitter.emit(
+        "error",
+        createVoiceError(VoiceErrorCode.UNKNOWN, `Audio playback blocked: ${err?.message}`)
+      );
+    });
+    let source = null;
+    let analyser = null;
+    let timer;
+    if (this.audioCtx) {
+      if (this.audioCtx.state === "suspended") {
+        this.audioCtx.resume();
+      }
+      source = this.audioCtx.createMediaStreamSource(stream);
+      analyser = this.audioCtx.createAnalyser();
+      analyser.fftSize = 256;
+      source.connect(analyser);
+      const buf = new Uint8Array(analyser.frequencyBinCount);
+      const a = analyser;
+      timer = setInterval(() => {
+        if (!this.peers.has(peerId)) return;
+        a.getByteFrequencyData(buf);
+        const level = computeRms(buf);
+        const p = this.peers.get(peerId);
+        if (p) p.audioLevel = level;
+        this.emitter.emit("audioLevel", peerId, level);
+      }, 100);
+    } else {
+      timer = setInterval(() => {
+      }, 6e4);
+    }
+    this.peerAudio.set(peerId, { audio, source, analyser, timer });
+  }
+  async initiateOffer(peerId) {
+    const pc = this.createPeerConnectionForOffer(peerId);
+    try {
+      const offer = await pc.createOffer();
+      await pc.setLocalDescription(offer);
+      this.send({ type: "offer", to: peerId, sdp: offer.sdp });
+    } catch (e) {
+      this.emitter.emit("error", createVoiceError(VoiceErrorCode.OFFER_FAILED, e?.message));
+    }
+  }
+  async handleOffer(fromPeerId, sdp) {
+    let pc = this.peerConnections.get(fromPeerId);
+    const isNew = !pc;
+    if (!pc) {
+      pc = this.createPeerConnectionForAnswer(fromPeerId);
+    }
+    try {
+      await pc.setRemoteDescription(new RTCSessionDescription({ type: "offer", sdp }));
+      if (isNew) {
+        this.attachLocalTracksToAnswer(pc);
+      }
+      const answer = await pc.createAnswer();
+      await pc.setLocalDescription(answer);
+      this.send({ type: "answer", to: fromPeerId, sdp: answer.sdp });
+    } catch (e) {
+      this.emitter.emit("error", createVoiceError(VoiceErrorCode.ANSWER_FAILED, e?.message));
+    }
+  }
+  async renegotiateAll() {
+    for (const [peerId, pc] of this.peerConnections) {
+      if (pc.signalingState !== "stable") continue;
+      try {
+        const offer = await pc.createOffer();
+        await pc.setLocalDescription(offer);
+        this.send({ type: "offer", to: peerId, sdp: offer.sdp });
+      } catch (e) {
+        this.emitter.emit("error", createVoiceError(VoiceErrorCode.OFFER_FAILED, e?.message));
+      }
+    }
+  }
+  async toggleMute() {
+    this._muted = !this._muted;
+    if (this.localStream) {
+      for (const track of this.localStream.getAudioTracks()) {
+        track.enabled = !this._muted;
+      }
+    }
+    this.send({ type: "mute", muted: this._muted });
+    this.emitter.emit("mute", this._muted);
+  }
+  async toggleVideo() {
+    if (this._videoEnabled) {
+      this._localVideoStream?.getTracks().forEach((t) => t.stop());
+      this._localVideoStream = null;
+      this._videoEnabled = false;
+      for (const pc of this.peerConnections.values()) {
+        const transceivers = pc.getTransceivers();
+        if (transceivers[1]) {
+          await transceivers[1].sender.replaceTrack(null);
+          transceivers[1].direction = "recvonly";
+        }
+      }
+    } else {
+      try {
+        this._localVideoStream = await navigator.mediaDevices.getUserMedia({ video: true });
+      } catch (e) {
+        const name = e?.name ?? "";
+        const code = name === "NotAllowedError" || name === "PermissionDeniedError" ? VoiceErrorCode.CAMERA_PERMISSION_DENIED : name === "NotFoundError" ? VoiceErrorCode.CAMERA_NOT_FOUND : VoiceErrorCode.MEDIA_GENERIC;
+        this.emitter.emit("error", createVoiceError(code, e?.message));
+        return;
+      }
+      this._videoEnabled = true;
+      const track = this._localVideoStream.getVideoTracks()[0];
+      for (const pc of this.peerConnections.values()) {
+        const transceivers = pc.getTransceivers();
+        if (transceivers[1]) {
+          await transceivers[1].sender.replaceTrack(track);
+          transceivers[1].direction = "sendrecv";
+        }
+      }
+    }
+    this.send({ type: "media-state", video: this._videoEnabled, screen: this._screenEnabled });
+    this.emitter.emit("videoChange", this._videoEnabled);
+    await this.renegotiateAll();
+  }
+  async toggleScreen() {
+    if (this._screenEnabled) {
+      this._localScreenStream?.getTracks().forEach((t) => t.stop());
+      this._localScreenStream = null;
+      this._screenEnabled = false;
+      for (const pc of this.peerConnections.values()) {
+        const transceivers = pc.getTransceivers();
+        if (transceivers[2]) {
+          await transceivers[2].sender.replaceTrack(null);
+          transceivers[2].direction = "recvonly";
+        }
+      }
+    } else {
+      try {
+        this._localScreenStream = await navigator.mediaDevices.getDisplayMedia({ video: true });
+      } catch (e) {
+        this.emitter.emit("error", createVoiceError(VoiceErrorCode.SCREENSHARE_FAILED, e?.message));
+        return;
+      }
+      this._screenEnabled = true;
+      const track = this._localScreenStream.getVideoTracks()[0];
+      track.addEventListener("ended", () => {
+        this._localScreenStream = null;
+        this._screenEnabled = false;
+        for (const pc of this.peerConnections.values()) {
+          const transceivers = pc.getTransceivers();
+          if (transceivers[2]) {
+            transceivers[2].sender.replaceTrack(null);
+            transceivers[2].direction = "recvonly";
+          }
+        }
+        this.send({ type: "media-state", video: this._videoEnabled, screen: false });
+        this.emitter.emit("screenChange", false);
+        this.renegotiateAll();
+      });
+      for (const pc of this.peerConnections.values()) {
+        const transceivers = pc.getTransceivers();
+        if (transceivers[2]) {
+          await transceivers[2].sender.replaceTrack(track);
+          transceivers[2].direction = "sendrecv";
+        }
+      }
+    }
+    this.send({ type: "media-state", video: this._videoEnabled, screen: this._screenEnabled });
+    this.emitter.emit("screenChange", this._screenEnabled);
+    await this.renegotiateAll();
+  }
+  setProfile(name, color) {
+    this._profile = { name, color };
+    if (this._status === "connected") {
+      this.send({ type: "profile", name, color });
+    }
+  }
+  togglePeerMute(peerId) {
+    const peer = this.peers.get(peerId);
+    if (!peer) return;
+    peer.localMuted = !peer.localMuted;
+    const pa = this.peerAudio.get(peerId);
+    if (pa) pa.audio.volume = peer.localMuted ? 0 : this._masterVolume;
+  }
+  setPeerVolume(peerId, volume) {
+    const clamped = Math.max(0, Math.min(volume, 1));
+    const pa = this.peerAudio.get(peerId);
+    if (pa) pa.audio.volume = clamped * this._masterVolume;
+    const peer = this.peers.get(peerId);
+    if (peer) peer.localMuted = clamped === 0;
+  }
+  setMasterVolume(volume) {
+    this._masterVolume = Math.max(0, Math.min(volume, 1));
+    for (const [peerId, pa] of this.peerAudio) {
+      const peer = this.peers.get(peerId);
+      if (peer?.localMuted) continue;
+      pa.audio.volume = this._masterVolume;
+    }
+  }
+  disconnect() {
+    this.send({ type: "leave" });
+    if (this.localAudioTimer !== null) {
+      clearInterval(this.localAudioTimer);
+      this.localAudioTimer = null;
+    }
+    for (const peerId of [...this.peerConnections.keys()]) {
+      this.removePeer(peerId);
+    }
+    this.ws?.close();
+    this.ws = null;
+    this.localStream?.getTracks().forEach((t) => t.stop());
+    this.localStream = null;
+    this._localVideoStream?.getTracks().forEach((t) => t.stop());
+    this._localVideoStream = null;
+    this._localScreenStream?.getTracks().forEach((t) => t.stop());
+    this._localScreenStream = null;
+    this.audioCtx?.close();
+    this.audioCtx = null;
+    this.peers.clear();
+    this.myPeerId = null;
+    this._muted = false;
+    this._videoEnabled = false;
+    this._screenEnabled = false;
+    this.setStatus("idle");
+  }
+}

package/dist/runtime/utils/avatarStyle.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Split-border avatar: inner filled with primaryColor, border = left half primary / right half neutral.
+ *
+ * CSS rules:
+ * - Colors cannot appear in non-final background layers; use linear-gradient(c,c) as a solid-color image instead.
+ * - UAvatar has overflow:hidden which clips border-area backgrounds; override with overflow:visible.
+ *   Border-radius still clips the background shape, and text initials don't need overflow clipping.
+ */
+export declare function avatarBorderStyle(primaryColor: string, neutralColorName: string): string;
+/**
+ * Same as avatarBorderStyle but accepts a color name and resolves to CSS variables.
+ * Use this for the local user where the identity color name is known (identity colors = ui colors).
+ */
+export declare function avatarStyleFromName(primaryColorName: string, neutralColorName: string): string;
+export declare function avatarGradient(primaryColor: string, neutralColorName: string): string;

package/dist/runtime/utils/avatarStyle.js

@@ -0,0 +1,20 @@
+export function avatarBorderStyle(primaryColor, neutralColorName) {
+  const neutral = `var(--color-${neutralColorName}-400, #888)`;
+  return [
+    "border: 2px solid transparent",
+    `background: linear-gradient(${primaryColor}, ${primaryColor}) padding-box, conic-gradient(${primaryColor} 180deg, ${neutral} 180deg) border-box`,
+    "overflow: visible"
+  ].join("; ");
+}
+export function avatarStyleFromName(primaryColorName, neutralColorName) {
+  const primary = `var(--color-${primaryColorName}-400)`;
+  const neutral = `var(--color-${neutralColorName}-400, #888)`;
+  return [
+    "border: 2px solid transparent",
+    `background: linear-gradient(${primary}, ${primary}) padding-box, conic-gradient(${primary} 180deg, ${neutral} 180deg) border-box`,
+    "overflow: visible"
+  ].join("; ");
+}
+export function avatarGradient(primaryColor, neutralColorName) {
+  return `linear-gradient(135deg, ${primaryColor} 0%, var(--color-${neutralColorName}-400, #888) 100%)`;
+}

package/dist/runtime/utils/colorPalettes.d.ts

@@ -0,0 +1,13 @@
+export interface ColorShade {
+    shade: number;
+    hex: string;
+}
+export interface ColorPalette {
+    name: string;
+    shades: ColorShade[];
+}
+export declare const COLOR_PALETTES: ColorPalette[];
+export declare function findPaletteByHex(hex: string): {
+    palette: ColorPalette;
+    shade: ColorShade;
+} | null;