@absolutejs/voice 0.0.1

package/dist/vue/index.js

@@ -0,0 +1,496 @@
+// @bun
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __name = (target, name) => {
+  Object.defineProperty(target, "name", {
+    value: name,
+    enumerable: false,
+    configurable: true
+  });
+  return target;
+};
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => (key in obj) ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== undefined && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({
+  kind: __decoratorStrings[kind],
+  name,
+  metadata,
+  addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null))
+});
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length;i < n; i++)
+    flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : {
+    get [name]() {
+      return __privateGet(this, extra);
+    },
+    set [name](x) {
+      __privateSet(this, extra, x);
+    }
+  }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1;i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => (name in x) };
+      if (k ^ 3)
+        access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2)
+        access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? undefined : { get: desc.get, set: desc.set } : target, ctx);
+    done._ = 1;
+    if (k ^ 4 || it === undefined)
+      __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null)
+      __typeError("Object expected");
+    else
+      __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+
+// src/vue/useVoiceStream.ts
+import { onUnmounted, ref, shallowRef } from "vue";
+
+// src/client/actions.ts
+var serverMessageToAction = (message) => {
+  switch (message.type) {
+    case "assistant":
+      return {
+        text: message.text,
+        type: "assistant"
+      };
+    case "complete":
+      return {
+        sessionId: message.sessionId,
+        type: "complete"
+      };
+    case "error":
+      return {
+        message: message.message,
+        type: "error"
+      };
+    case "final":
+      return {
+        transcript: message.transcript,
+        type: "final"
+      };
+    case "partial":
+      return {
+        transcript: message.transcript,
+        type: "partial"
+      };
+    case "session":
+      return {
+        sessionId: message.sessionId,
+        status: message.status,
+        type: "session"
+      };
+    case "turn":
+      return {
+        turn: message.turn,
+        type: "turn"
+      };
+    default:
+      return null;
+  }
+};
+
+// src/client/connection.ts
+var WS_OPEN = 1;
+var WS_CLOSED = 3;
+var WS_NORMAL_CLOSURE = 1000;
+var DEFAULT_MAX_RECONNECT_ATTEMPTS = 10;
+var DEFAULT_PING_INTERVAL = 30000;
+var RECONNECT_DELAY_MS = 500;
+var noop = () => {};
+var noopUnsubscribe = () => noop;
+var NOOP_CONNECTION = {
+  close: noop,
+  endTurn: noop,
+  getReadyState: () => WS_CLOSED,
+  getSessionId: () => "",
+  send: noop,
+  sendAudio: noop,
+  subscribe: noopUnsubscribe
+};
+var createSessionId = () => crypto.randomUUID();
+var buildWsUrl = (path, sessionId) => {
+  const { hostname, port, protocol } = window.location;
+  const wsProtocol = protocol === "https:" ? "wss:" : "ws:";
+  const portSuffix = port ? `:${port}` : "";
+  const url = new URL(`${wsProtocol}//${hostname}${portSuffix}${path}`);
+  url.searchParams.set("sessionId", sessionId);
+  return url.toString();
+};
+var isVoiceServerMessage = (value) => {
+  if (!value || typeof value !== "object" || !("type" in value)) {
+    return false;
+  }
+  switch (value.type) {
+    case "assistant":
+    case "complete":
+    case "error":
+    case "final":
+    case "partial":
+    case "pong":
+    case "session":
+    case "turn":
+      return true;
+    default:
+      return false;
+  }
+};
+var parseServerMessage = (event) => {
+  if (typeof event.data !== "string") {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(event.data);
+    return isVoiceServerMessage(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+};
+var createVoiceConnection = (path, options = {}) => {
+  if (typeof window === "undefined") {
+    return NOOP_CONNECTION;
+  }
+  const listeners = new Set;
+  const shouldReconnect = options.reconnect !== false;
+  const maxReconnectAttempts = options.maxReconnectAttempts ?? DEFAULT_MAX_RECONNECT_ATTEMPTS;
+  const pingInterval = options.pingInterval ?? DEFAULT_PING_INTERVAL;
+  const state = {
+    isConnected: false,
+    pendingMessages: [],
+    pingInterval: null,
+    reconnectAttempts: 0,
+    reconnectTimeout: null,
+    sessionId: options.sessionId ?? createSessionId(),
+    ws: null
+  };
+  const clearTimers = () => {
+    if (state.pingInterval) {
+      clearInterval(state.pingInterval);
+      state.pingInterval = null;
+    }
+    if (state.reconnectTimeout) {
+      clearTimeout(state.reconnectTimeout);
+      state.reconnectTimeout = null;
+    }
+  };
+  const flushPendingMessages = () => {
+    if (state.ws?.readyState !== WS_OPEN) {
+      return;
+    }
+    while (state.pendingMessages.length > 0) {
+      const next = state.pendingMessages.shift();
+      if (next !== undefined) {
+        state.ws.send(next);
+      }
+    }
+  };
+  const scheduleReconnect = () => {
+    state.reconnectAttempts += 1;
+    state.reconnectTimeout = setTimeout(() => {
+      if (state.reconnectAttempts > maxReconnectAttempts) {
+        return;
+      }
+      connect();
+    }, RECONNECT_DELAY_MS);
+  };
+  const connect = () => {
+    const ws = new WebSocket(buildWsUrl(path, state.sessionId));
+    ws.binaryType = "arraybuffer";
+    ws.onopen = () => {
+      state.isConnected = true;
+      state.reconnectAttempts = 0;
+      flushPendingMessages();
+      listeners.forEach((listener) => listener({
+        sessionId: state.sessionId,
+        status: "active",
+        type: "session"
+      }));
+      state.pingInterval = setInterval(() => {
+        if (ws.readyState === WS_OPEN) {
+          ws.send(JSON.stringify({ type: "ping" }));
+        }
+      }, pingInterval);
+    };
+    ws.onmessage = (event) => {
+      const parsed = parseServerMessage(event);
+      if (!parsed) {
+        return;
+      }
+      if (parsed.type === "session") {
+        state.sessionId = parsed.sessionId;
+      }
+      listeners.forEach((listener) => listener(parsed));
+    };
+    ws.onclose = (event) => {
+      state.isConnected = false;
+      clearTimers();
+      const reconnectable = shouldReconnect && event.code !== WS_NORMAL_CLOSURE && state.reconnectAttempts < maxReconnectAttempts;
+      if (reconnectable) {
+        scheduleReconnect();
+      }
+    };
+    state.ws = ws;
+  };
+  const sendSerialized = (value) => {
+    if (state.ws?.readyState === WS_OPEN) {
+      state.ws.send(value);
+      return;
+    }
+    state.pendingMessages.push(value);
+  };
+  const send = (message) => {
+    sendSerialized(JSON.stringify(message));
+  };
+  const sendAudio = (audio) => {
+    sendSerialized(audio);
+  };
+  const endTurn = () => {
+    send({ type: "end_turn" });
+  };
+  const close = () => {
+    clearTimers();
+    if (state.ws) {
+      state.ws.close(WS_NORMAL_CLOSURE);
+      state.ws = null;
+    }
+    state.isConnected = false;
+    listeners.clear();
+  };
+  const subscribe = (callback) => {
+    listeners.add(callback);
+    return () => {
+      listeners.delete(callback);
+    };
+  };
+  connect();
+  return {
+    close,
+    endTurn,
+    getReadyState: () => state.ws?.readyState ?? WS_CLOSED,
+    getSessionId: () => state.sessionId,
+    send,
+    sendAudio,
+    subscribe
+  };
+};
+
+// src/client/store.ts
+var createInitialState = () => ({
+  assistantTexts: [],
+  error: null,
+  isConnected: false,
+  partial: "",
+  sessionId: null,
+  status: "idle",
+  turns: []
+});
+var createVoiceStreamStore = () => {
+  let state = createInitialState();
+  const subscribers = new Set;
+  const notify = () => {
+    subscribers.forEach((subscriber) => subscriber());
+  };
+  const dispatch = (action) => {
+    switch (action.type) {
+      case "assistant":
+        state = {
+          ...state,
+          assistantTexts: [...state.assistantTexts, action.text]
+        };
+        break;
+      case "complete":
+        state = {
+          ...state,
+          sessionId: action.sessionId,
+          status: "completed"
+        };
+        break;
+      case "connected":
+        state = {
+          ...state,
+          isConnected: true
+        };
+        break;
+      case "disconnected":
+        state = {
+          ...state,
+          isConnected: false
+        };
+        break;
+      case "error":
+        state = {
+          ...state,
+          error: action.message
+        };
+        break;
+      case "final":
+        state = {
+          ...state,
+          partial: "",
+          turns: state.turns.map((turn) => turn)
+        };
+        break;
+      case "partial":
+        state = {
+          ...state,
+          partial: action.transcript.text
+        };
+        break;
+      case "session":
+        state = {
+          ...state,
+          error: null,
+          sessionId: action.sessionId,
+          status: action.status
+        };
+        break;
+      case "turn":
+        state = {
+          ...state,
+          partial: "",
+          turns: [...state.turns, action.turn]
+        };
+        break;
+    }
+    notify();
+  };
+  return {
+    dispatch,
+    getServerSnapshot: () => state,
+    getSnapshot: () => state,
+    subscribe: (subscriber) => {
+      subscribers.add(subscriber);
+      return () => {
+        subscribers.delete(subscriber);
+      };
+    }
+  };
+};
+
+// src/client/createVoiceStream.ts
+var createVoiceStream = (path, options = {}) => {
+  const connection = createVoiceConnection(path, options);
+  const store = createVoiceStreamStore();
+  const subscribers = new Set;
+  const notify = () => {
+    subscribers.forEach((subscriber) => subscriber());
+  };
+  const unsubscribeConnection = connection.subscribe((message) => {
+    const action = serverMessageToAction(message);
+    if (action) {
+      store.dispatch(action);
+      notify();
+    }
+  });
+  store.dispatch({ type: "connected" });
+  return {
+    close() {
+      unsubscribeConnection();
+      connection.close();
+      store.dispatch({ type: "disconnected" });
+      notify();
+    },
+    endTurn() {
+      connection.endTurn();
+    },
+    get error() {
+      return store.getSnapshot().error;
+    },
+    get isConnected() {
+      return store.getSnapshot().isConnected;
+    },
+    get partial() {
+      return store.getSnapshot().partial;
+    },
+    get sessionId() {
+      return connection.getSessionId();
+    },
+    get status() {
+      return store.getSnapshot().status;
+    },
+    get turns() {
+      return store.getSnapshot().turns;
+    },
+    get assistantTexts() {
+      return store.getSnapshot().assistantTexts;
+    },
+    sendAudio(audio) {
+      connection.sendAudio(audio);
+    },
+    subscribe(subscriber) {
+      subscribers.add(subscriber);
+      return () => {
+        subscribers.delete(subscriber);
+      };
+    }
+  };
+};
+
+// src/vue/useVoiceStream.ts
+var useVoiceStream = (path, options = {}) => {
+  const stream = createVoiceStream(path, options);
+  const assistantTexts = shallowRef([]);
+  const error = ref(null);
+  const isConnected = ref(false);
+  const partial = ref("");
+  const sessionId = ref(stream.sessionId);
+  const status = ref(stream.status);
+  const turns = shallowRef([]);
+  const sync = () => {
+    assistantTexts.value = [...stream.assistantTexts];
+    error.value = stream.error;
+    isConnected.value = stream.isConnected;
+    partial.value = stream.partial;
+    sessionId.value = stream.sessionId;
+    status.value = stream.status;
+    turns.value = [...stream.turns];
+  };
+  const unsubscribe = stream.subscribe(sync);
+  sync();
+  const destroy = () => {
+    unsubscribe();
+    stream.close();
+  };
+  onUnmounted(destroy);
+  return {
+    assistantTexts,
+    close: () => destroy(),
+    endTurn: () => stream.endTurn(),
+    error,
+    isConnected,
+    partial,
+    sendAudio: (audio) => stream.sendAudio(audio),
+    sessionId,
+    status,
+    turns
+  };
+};
+export {
+  useVoiceStream
+};

package/package.json

@@ -0,0 +1,100 @@
+{
+	"name": "@absolutejs/voice",
+	"version": "0.0.1",
+	"description": "Voice primitives and Elysia plugin for AbsoluteJS",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/absolutejs/voice.git"
+	},
+	"files": [
+		"dist",
+		"README.md"
+	],
+	"main": "./dist/index.js",
+	"types": "./dist/src/index.d.ts",
+	"license": "CC BY-NC 4.0",
+	"author": "Alex Kahn",
+	"scripts": {
+		"build": "rm -rf dist && bun build ./src/index.ts ./src/client/index.ts ./src/react/index.ts ./src/vue/index.ts ./src/svelte/index.ts ./src/angular/index.ts --outdir dist --target bun --external elysia --external react --external vue --external @angular/core --external @absolutejs/absolute && tsc --emitDeclarationOnly --project tsconfig.json",
+		"format": "prettier --write \"./**/*.{js,jsx,ts,tsx,json,md}\"",
+		"lint": "eslint ./src",
+		"release": "bun run format && bun run build && bun publish",
+		"test": "echo \"Error: no test specified\" && exit 1",
+		"typecheck": "bun run tsc --noEmit"
+	},
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"types": "./dist/src/index.d.ts"
+		},
+		"./client": {
+			"browser": "./dist/client/index.js",
+			"import": "./dist/client/index.js",
+			"types": "./dist/src/client/index.d.ts"
+		},
+		"./react": {
+			"browser": "./dist/react/index.js",
+			"import": "./dist/react/index.js",
+			"types": "./dist/src/react/index.d.ts"
+		},
+		"./vue": {
+			"browser": "./dist/vue/index.js",
+			"import": "./dist/vue/index.js",
+			"types": "./dist/src/vue/index.d.ts"
+		},
+		"./svelte": {
+			"import": "./dist/svelte/index.js",
+			"types": "./dist/src/svelte/index.d.ts"
+		},
+		"./angular": {
+			"import": "./dist/angular/index.js",
+			"types": "./dist/src/angular/index.d.ts"
+		}
+	},
+	"typesVersions": {
+		"*": {
+			"client": [
+				"dist/src/client/index.d.ts"
+			],
+			"react": [
+				"dist/src/react/index.d.ts"
+			],
+			"svelte": [
+				"dist/src/svelte/index.d.ts"
+			],
+			"vue": [
+				"dist/src/vue/index.d.ts"
+			],
+			"angular": [
+				"dist/src/angular/index.d.ts"
+			]
+		}
+	},
+	"peerDependencies": {
+		"@absolutejs/absolute": ">=0.19.0-beta.646",
+		"@angular/core": ">=21.0.0",
+		"elysia": ">=1.4.18",
+		"react": ">=19.0.0",
+		"vue": ">=3.5.0"
+	},
+	"peerDependenciesMeta": {
+		"@angular/core": {
+			"optional": true
+		},
+		"react": {
+			"optional": true
+		},
+		"vue": {
+			"optional": true
+		}
+	},
+	"devDependencies": {
+		"@angular/core": "^21.0.0",
+		"@types/bun": "1.3.9",
+		"@types/react": "19.2.0",
+		"elysia": "1.4.18",
+		"react": "19.2.1",
+		"typescript": "^5.9.3",
+		"vue": "3.5.27"
+	}
+}