@uploadista/event-emitter-websocket 0.0.3 → 0.0.4

package/.turbo/turbo-build.log

@@ -1,5 +1,22 @@
 
 
-> @uploadista/event-emitter-websocket@0.0.2 build /Users/denislaboureyras/Documents/uploadista/dev/uploadista-workspace/uploadista-sdk/packages/event-emitters/websocket
-> tsc -b
+> @uploadista/event-emitter-websocket@0.0.3 build /Users/denislaboureyras/Documents/uploadista/dev/uploadista-workspace/uploadista-sdk/packages/event-emitters/websocket
+> tsdown
 
+ℹ tsdown v0.15.9 powered by rolldown v1.0.0-beta.44
+ℹ Using tsdown config: /Users/denislaboureyras/Documents/uploadista/dev/uploadista-workspace/uploadista-sdk/packages/event-emitters/websocket/tsdown.config.ts
+ℹ entry: src/index.ts
+ℹ tsconfig: tsconfig.json
+ℹ Build start
+ℹ Cleaning 7 files
+ℹ [CJS] dist/index.cjs  2.67 kB │ gzip: 1.17 kB
+ℹ [CJS] 1 files, total: 2.67 kB
+ℹ [ESM] dist/index.js        2.11 kB │ gzip: 0.94 kB
+ℹ [ESM] dist/index.js.map    9.61 kB │ gzip: 2.72 kB
+ℹ [ESM] dist/index.d.ts.map  1.38 kB │ gzip: 0.50 kB
+ℹ [ESM] dist/index.d.ts      2.10 kB │ gzip: 0.54 kB
+ℹ [ESM] 4 files, total: 15.19 kB
+ℹ [CJS] dist/index.d.cts.map  1.38 kB │ gzip: 0.50 kB
+ℹ [CJS] dist/index.d.cts      2.10 kB │ gzip: 0.54 kB
+ℹ [CJS] 2 files, total: 3.47 kB
+✔ Build complete in 9685ms

package/dist/index.cjs

@@ -0,0 +1 @@
+var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=(e,i,o,s)=>{if(i&&typeof i==`object`||typeof i==`function`)for(var c=r(i),l=0,u=c.length,d;l<u;l++)d=c[l],!a.call(e,d)&&d!==o&&t(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=n(i,d))||s.enumerable});return e},s=(n,r,a)=>(a=n==null?{}:e(i(n)),o(r||!n||!n.__esModule?t(a,`default`,{value:n,enumerable:!0}):a,n));let c=require(`@uploadista/core/errors`);c=s(c);let l=require(`@uploadista/core/types`);l=s(l);let u=require(`effect`);u=s(u);const d=u.Effect.gen(function*(){let e=yield*l.EventBroadcasterService,t=new Map,n=new Map,r=(e,r)=>{let i=n.get(e);if(i)for(let e of i){let n=t.get(e);if(n&&n.readyState===1)try{n.send(r)}catch(t){console.warn(`Failed to send message to connection ${e}:`,t),s(e)}else s(e)}};yield*e.subscribe(`uploadista:events`,e=>{try{let{eventKey:t,message:n}=JSON.parse(e);r(t,n)}catch(e){console.warn(`Failed to parse broadcast message:`,e)}}).pipe(u.Effect.catchAll(e=>(console.error(`Failed to subscribe to broadcast events:`,e),u.Effect.void)));let i=e=>t.get(e)||null,a=()=>t,o=(e,n)=>{t.set(e,n)},s=e=>{t.delete(e);for(let[t,r]of n.entries())r.delete(e),r.size===0&&n.delete(t)};return{getConnection:i,getConnections:a,addConnection:o,removeConnection:s,subscribeToEvents:(e,t)=>{n.has(e)||n.set(e,new Set),n.get(e)?.add(t)},unsubscribeFromEvents:(e,t)=>{let r=n.get(e);r&&(r.delete(t),r.size===0&&n.delete(e))},emitToEvents:(t,n)=>{u.Effect.runPromise(e.publish(`uploadista:events`,JSON.stringify({eventKey:t,message:n}))).catch(e=>{console.error(`Failed to publish event to broadcaster:`,e)})}}});var f=class extends u.Context.Tag(`BaseWebSocketManagerService`)(){};const p=u.Layer.effect(f,d);function m(e){return{emit:(t,n)=>u.Effect.try({try:()=>{e.emitToEvents(t,n)},catch:e=>c.UploadistaError.fromCode(`UNKNOWN_ERROR`,{cause:e})}),subscribe:(t,n)=>u.Effect.try({try:()=>{e.addConnection(n.id,n),e.subscribeToEvents(t,n.id),n.send(JSON.stringify({type:`subscribed`,payload:{eventKey:t},timestamp:new Date().toISOString()}))},catch:e=>c.UploadistaError.fromCode(`UNKNOWN_ERROR`,{cause:e})}),unsubscribe:t=>u.Effect.try({try:()=>{let n=e.getConnections();for(let[r]of n)e.unsubscribeFromEvents(t,r)},catch:e=>c.UploadistaError.fromCode(`UNKNOWN_ERROR`,{cause:e})})}}const h=u.Effect.gen(function*(){return m(yield*f)}),g=e=>u.Layer.effect(l.BaseEventEmitterService,h).pipe(u.Layer.provide(p),u.Layer.provide(e));exports.WebSocketManagerService=f,exports.makeBaseEventEmitter=h,exports.makeWebSocketManager=d,exports.webSocketEventEmitter=g,exports.webSocketManager=p;

package/dist/index.d.cts

@@ -0,0 +1,32 @@
+import { BaseEventEmitter, BaseEventEmitterService, EventBroadcasterService, WebSocketConnection } from "@uploadista/core/types";
+import { Context, Effect, Layer } from "effect";
+
+//#region src/websocket-manager.d.ts
+interface WebSocketManager {
+  readonly getConnection: (key: string) => WebSocketConnection | null;
+  readonly getConnections: () => Map<string, WebSocketConnection>;
+  readonly addConnection: (key: string, connection: WebSocketConnection) => void;
+  readonly removeConnection: (key: string) => void;
+  readonly subscribeToEvents: (eventKey: string, connectionId: string) => void;
+  readonly unsubscribeFromEvents: (eventKey: string, connectionId: string) => void;
+  readonly emitToEvents: (eventKey: string, event: string) => void;
+}
+declare const makeWebSocketManager: Effect.Effect<{
+  getConnection: (key: string) => WebSocketConnection | null;
+  getConnections: () => Map<string, WebSocketConnection>;
+  addConnection: (key: string, connection: WebSocketConnection) => void;
+  removeConnection: (key: string) => void;
+  subscribeToEvents: (eventKey: string, connectionId: string) => void;
+  unsubscribeFromEvents: (eventKey: string, connectionId: string) => void;
+  emitToEvents: (eventKey: string, message: string) => void;
+}, never, EventBroadcasterService>;
+declare const WebSocketManagerService_base: Context.TagClass<WebSocketManagerService, "BaseWebSocketManagerService", WebSocketManager>;
+declare class WebSocketManagerService extends WebSocketManagerService_base {}
+declare const webSocketManager: Layer.Layer<WebSocketManagerService, never, EventBroadcasterService>;
+//#endregion
+//#region src/websocket-event-emitter.d.ts
+declare const makeBaseEventEmitter: Effect.Effect<BaseEventEmitter, never, WebSocketManagerService>;
+declare const webSocketEventEmitter: (eventBroadcaster: Layer.Layer<EventBroadcasterService>) => Layer.Layer<BaseEventEmitterService, never, never>;
+//#endregion
+export { type WebSocketManager, WebSocketManagerService, makeBaseEventEmitter, makeWebSocketManager, webSocketEventEmitter, webSocketManager };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/websocket-manager.ts","../src/websocket-event-emitter.ts"],"sourcesContent":[],"mappings":";;;;UAKiB,gBAAA;EAAA,SAAA,aAAgB,EAAA,CAAA,GAAA,EAAA,MAAA,EAAA,GACU,mBADV,GAAA,IAAA;EACU,SAAA,cAAA,EAAA,GAAA,GACV,GADU,CAAA,MAAA,EACE,mBADF,CAAA;EACE,SAAA,aAAA,EAAA,CAAA,GAAA,EAAA,MAAA,EAAA,UAAA,EAG7B,mBAH6B,EAAA,GAAA,IAAA;EAAZ,SAAA,gBAAA,EAAA,CAAA,GAAA,EAAA,MAAA,EAAA,GAAA,IAAA;EAGjB,SAAA,iBAAA,EAAA,CAAA,QAAA,EAAA,MAAA,EAAA,YAAA,EAAA,MAAA,EAAA,GAAA,IAAA;EAAmB,SAAA,qBAAA,EAAA,CAAA,QAAA,EAAA,MAAA,EAAA,YAAA,EAAA,MAAA,EAAA,GAAA,IAAA;EAWtB,SAAA,YAAA,EAiHX,CAAA,QAAA,EAAA,MAAA,EAAA,KAAA,EAAA,MAAA,EAAA,GAAA,IAAA;;AA/DuC,cAlD5B,oBAkD4B,EAlDR,MAAA,CAAA,MAkDQ,CAAA;EAAZ,aAAA,EAAA,CAAA,GAAA,EAAA,MAAA,EAAA,GAJU,mBAIV,GAAA,IAAA;EAMb,cAAA,EAAA,GAAA,GANa,GAMb,CAAA,MAAA,EANyB,mBAMzB,CAAA;2CAAA;EAxDiB,gBAAA,EAAA,CAAA,GAAA,EAAA,MAAA,EAAA,GAAA,IAAA;EAAA,iBAAA,EAAA,CAAA,QAAA,EAAA,MAAA,EAAA,YAAA,EAAA,MAAA,EAAA,GAAA,IAAA;EAiH9B,qBAAA,EAAA,CAAA,QAAA,EAAA,MAAA,EAAA,YAAA,EAAA,MAAA,EAAA,GAAA,IAAA;;;cAAA;cAGU,uBAAA,SAAgC,4BAAA;AAKhC,cAAA,gBAGZ,EAH4B,KAAA,CAAA,KAG5B,CAH4B,uBAG5B,EAAA,KAAA,EAH4B,uBAG5B,CAAA;;;AA5IgB,cCkEJ,oBDlEoB,ECkEA,MAAA,CAAA,MDlEA,CCkEA,gBDlEA,EAAA,KAAA,ECkEA,uBDlEA,CAAA;AACU,cCsE9B,qBDtE8B,EAAA,CAAA,gBAAA,ECuEvB,KAAA,CAAM,KDvEiB,CCuEX,uBDvEW,CAAA,EAAA,GCuEa,KAAA,CAAA,KDvEb,CCuEa,uBDvEb,EAAA,KAAA,EAAA,KAAA,CAAA"}

package/dist/index.d.ts

@@ -1,3 +1,32 @@
-export { makeBaseEventEmitter, webSocketEventEmitter, } from "./websocket-event-emitter";
-export { makeWebSocketManager, type WebSocketManager, WebSocketManagerService, webSocketManager, } from "./websocket-manager";
+import { BaseEventEmitter, BaseEventEmitterService, EventBroadcasterService, WebSocketConnection } from "@uploadista/core/types";
+import { Context, Effect, Layer } from "effect";
+
+//#region src/websocket-manager.d.ts
+interface WebSocketManager {
+  readonly getConnection: (key: string) => WebSocketConnection | null;
+  readonly getConnections: () => Map<string, WebSocketConnection>;
+  readonly addConnection: (key: string, connection: WebSocketConnection) => void;
+  readonly removeConnection: (key: string) => void;
+  readonly subscribeToEvents: (eventKey: string, connectionId: string) => void;
+  readonly unsubscribeFromEvents: (eventKey: string, connectionId: string) => void;
+  readonly emitToEvents: (eventKey: string, event: string) => void;
+}
+declare const makeWebSocketManager: Effect.Effect<{
+  getConnection: (key: string) => WebSocketConnection | null;
+  getConnections: () => Map<string, WebSocketConnection>;
+  addConnection: (key: string, connection: WebSocketConnection) => void;
+  removeConnection: (key: string) => void;
+  subscribeToEvents: (eventKey: string, connectionId: string) => void;
+  unsubscribeFromEvents: (eventKey: string, connectionId: string) => void;
+  emitToEvents: (eventKey: string, message: string) => void;
+}, never, EventBroadcasterService>;
+declare const WebSocketManagerService_base: Context.TagClass<WebSocketManagerService, "BaseWebSocketManagerService", WebSocketManager>;
+declare class WebSocketManagerService extends WebSocketManagerService_base {}
+declare const webSocketManager: Layer.Layer<WebSocketManagerService, never, EventBroadcasterService>;
+//#endregion
+//#region src/websocket-event-emitter.d.ts
+declare const makeBaseEventEmitter: Effect.Effect<BaseEventEmitter, never, WebSocketManagerService>;
+declare const webSocketEventEmitter: (eventBroadcaster: Layer.Layer<EventBroadcasterService>) => Layer.Layer<BaseEventEmitterService, never, never>;
+//#endregion
+export { type WebSocketManager, WebSocketManagerService, makeBaseEventEmitter, makeWebSocketManager, webSocketEventEmitter, webSocketManager };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,qBAAqB,GACtB,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EACL,oBAAoB,EACpB,KAAK,gBAAgB,EACrB,uBAAuB,EACvB,gBAAgB,GACjB,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/websocket-manager.ts","../src/websocket-event-emitter.ts"],"sourcesContent":[],"mappings":";;;;UAKiB,gBAAA;EAAA,SAAA,aAAgB,EAAA,CAAA,GAAA,EAAA,MAAA,EAAA,GACU,mBADV,GAAA,IAAA;EACU,SAAA,cAAA,EAAA,GAAA,GACV,GADU,CAAA,MAAA,EACE,mBADF,CAAA;EACE,SAAA,aAAA,EAAA,CAAA,GAAA,EAAA,MAAA,EAAA,UAAA,EAG7B,mBAH6B,EAAA,GAAA,IAAA;EAAZ,SAAA,gBAAA,EAAA,CAAA,GAAA,EAAA,MAAA,EAAA,GAAA,IAAA;EAGjB,SAAA,iBAAA,EAAA,CAAA,QAAA,EAAA,MAAA,EAAA,YAAA,EAAA,MAAA,EAAA,GAAA,IAAA;EAAmB,SAAA,qBAAA,EAAA,CAAA,QAAA,EAAA,MAAA,EAAA,YAAA,EAAA,MAAA,EAAA,GAAA,IAAA;EAWtB,SAAA,YAAA,EAiHX,CAAA,QAAA,EAAA,MAAA,EAAA,KAAA,EAAA,MAAA,EAAA,GAAA,IAAA;;AA/DuC,cAlD5B,oBAkD4B,EAlDR,MAAA,CAAA,MAkDQ,CAAA;EAAZ,aAAA,EAAA,CAAA,GAAA,EAAA,MAAA,EAAA,GAJU,mBAIV,GAAA,IAAA;EAMb,cAAA,EAAA,GAAA,GANa,GAMb,CAAA,MAAA,EANyB,mBAMzB,CAAA;2CAAA;EAxDiB,gBAAA,EAAA,CAAA,GAAA,EAAA,MAAA,EAAA,GAAA,IAAA;EAAA,iBAAA,EAAA,CAAA,QAAA,EAAA,MAAA,EAAA,YAAA,EAAA,MAAA,EAAA,GAAA,IAAA;EAiH9B,qBAAA,EAAA,CAAA,QAAA,EAAA,MAAA,EAAA,YAAA,EAAA,MAAA,EAAA,GAAA,IAAA;;;cAAA;cAGU,uBAAA,SAAgC,4BAAA;AAKhC,cAAA,gBAGZ,EAH4B,KAAA,CAAA,KAG5B,CAH4B,uBAG5B,EAAA,KAAA,EAH4B,uBAG5B,CAAA;;;AA5IgB,cCkEJ,oBDlEoB,ECkEA,MAAA,CAAA,MDlEA,CCkEA,gBDlEA,EAAA,KAAA,ECkEA,uBDlEA,CAAA;AACU,cCsE9B,qBDtE8B,EAAA,CAAA,gBAAA,ECuEvB,KAAA,CAAM,KDvEiB,CCuEX,uBDvEW,CAAA,EAAA,GCuEa,KAAA,CAAA,KDvEb,CCuEa,uBDvEb,EAAA,KAAA,EAAA,KAAA,CAAA"}

package/dist/index.js

@@ -1,2 +1,2 @@
-export { makeBaseEventEmitter, webSocketEventEmitter, } from "./websocket-event-emitter";
-export { makeWebSocketManager, WebSocketManagerService, webSocketManager, } from "./websocket-manager";
+import{UploadistaError as e}from"@uploadista/core/errors";import{BaseEventEmitterService as t,EventBroadcasterService as n}from"@uploadista/core/types";import{Context as r,Effect as i,Layer as a}from"effect";const o=i.gen(function*(){let e=yield*n,t=new Map,r=new Map,a=(e,n)=>{let i=r.get(e);if(i)for(let e of i){let r=t.get(e);if(r&&r.readyState===1)try{r.send(n)}catch(t){console.warn(`Failed to send message to connection ${e}:`,t),l(e)}else l(e)}};yield*e.subscribe(`uploadista:events`,e=>{try{let{eventKey:t,message:n}=JSON.parse(e);a(t,n)}catch(e){console.warn(`Failed to parse broadcast message:`,e)}}).pipe(i.catchAll(e=>(console.error(`Failed to subscribe to broadcast events:`,e),i.void)));let o=e=>t.get(e)||null,s=()=>t,c=(e,n)=>{t.set(e,n)},l=e=>{t.delete(e);for(let[t,n]of r.entries())n.delete(e),n.size===0&&r.delete(t)};return{getConnection:o,getConnections:s,addConnection:c,removeConnection:l,subscribeToEvents:(e,t)=>{r.has(e)||r.set(e,new Set),r.get(e)?.add(t)},unsubscribeFromEvents:(e,t)=>{let n=r.get(e);n&&(n.delete(t),n.size===0&&r.delete(e))},emitToEvents:(t,n)=>{i.runPromise(e.publish(`uploadista:events`,JSON.stringify({eventKey:t,message:n}))).catch(e=>{console.error(`Failed to publish event to broadcaster:`,e)})}}});var s=class extends r.Tag(`BaseWebSocketManagerService`)(){};const c=a.effect(s,o);function l(t){return{emit:(n,r)=>i.try({try:()=>{t.emitToEvents(n,r)},catch:t=>e.fromCode(`UNKNOWN_ERROR`,{cause:t})}),subscribe:(n,r)=>i.try({try:()=>{t.addConnection(r.id,r),t.subscribeToEvents(n,r.id),r.send(JSON.stringify({type:`subscribed`,payload:{eventKey:n},timestamp:new Date().toISOString()}))},catch:t=>e.fromCode(`UNKNOWN_ERROR`,{cause:t})}),unsubscribe:n=>i.try({try:()=>{let e=t.getConnections();for(let[r]of e)t.unsubscribeFromEvents(n,r)},catch:t=>e.fromCode(`UNKNOWN_ERROR`,{cause:t})})}}const u=i.gen(function*(){return l(yield*s)}),d=e=>a.effect(t,u).pipe(a.provide(c),a.provide(e));export{s as WebSocketManagerService,u as makeBaseEventEmitter,o as makeWebSocketManager,d as webSocketEventEmitter,c as webSocketManager};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["webSocketManager"],"sources":["../src/websocket-manager.ts","../src/websocket-event-emitter.ts"],"sourcesContent":["import type { WebSocketConnection } from \"@uploadista/core/types\";\nimport { EventBroadcasterService } from \"@uploadista/core/types\";\nimport { Context, Effect, Layer } from \"effect\";\n\n// Base untyped WebSocketManager - works with raw string messages\nexport interface WebSocketManager {\n  readonly getConnection: (key: string) => WebSocketConnection | null;\n  readonly getConnections: () => Map<string, WebSocketConnection>;\n  readonly addConnection: (\n    key: string,\n    connection: WebSocketConnection,\n  ) => void;\n  readonly removeConnection: (key: string) => void;\n  readonly subscribeToEvents: (eventKey: string, connectionId: string) => void;\n  readonly unsubscribeFromEvents: (\n    eventKey: string,\n    connectionId: string,\n  ) => void;\n  readonly emitToEvents: (eventKey: string, event: string) => void;\n}\n\nexport const makeWebSocketManager = Effect.gen(function* () {\n  const broadcaster = yield* EventBroadcasterService;\n\n  const connections = new Map<string, WebSocketConnection>();\n  const subscriptions = new Map<string, Set<string>>(); // eventKey -> Set<connectionId>\n\n  // Helper to send messages to local connections for a given eventKey\n  const emitToLocalConnections = (eventKey: string, message: string): void => {\n    const connectionIds = subscriptions.get(eventKey);\n    if (!connectionIds) return;\n\n    for (const connectionId of connectionIds) {\n      const connection = connections.get(connectionId);\n      if (connection && connection.readyState === 1) {\n        try {\n          connection.send(message);\n        } catch (error) {\n          console.warn(\n            `Failed to send message to connection ${connectionId}:`,\n            error,\n          );\n          removeConnection(connectionId);\n        }\n      } else {\n        removeConnection(connectionId);\n      }\n    }\n  };\n\n  // Subscribe to broadcast events from other instances\n  yield* broadcaster\n    .subscribe(\"uploadista:events\", (broadcastMessage) => {\n      try {\n        const { eventKey, message } = JSON.parse(broadcastMessage);\n        emitToLocalConnections(eventKey, message);\n      } catch (error) {\n        console.warn(\"Failed to parse broadcast message:\", error);\n      }\n    })\n    .pipe(\n      Effect.catchAll((error) => {\n        console.error(\"Failed to subscribe to broadcast events:\", error);\n        return Effect.void;\n      }),\n    );\n\n  const getConnection = (key: string): WebSocketConnection | null => {\n    return connections.get(key) || null;\n  };\n\n  const getConnections = (): Map<string, WebSocketConnection> => {\n    return connections;\n  };\n\n  const addConnection = (\n    key: string,\n    connection: WebSocketConnection,\n  ): void => {\n    connections.set(key, connection);\n  };\n\n  const removeConnection = (key: string): void => {\n    connections.delete(key);\n    // Clean up subscriptions\n    for (const [eventKey, connectionIds] of subscriptions.entries()) {\n      connectionIds.delete(key);\n      if (connectionIds.size === 0) {\n        subscriptions.delete(eventKey);\n      }\n    }\n  };\n\n  const subscribeToEvents = (eventKey: string, connectionId: string): void => {\n    if (!subscriptions.has(eventKey)) {\n      subscriptions.set(eventKey, new Set());\n    }\n    subscriptions.get(eventKey)?.add(connectionId);\n  };\n\n  const unsubscribeFromEvents = (\n    eventKey: string,\n    connectionId: string,\n  ): void => {\n    const connectionIds = subscriptions.get(eventKey);\n    if (connectionIds) {\n      connectionIds.delete(connectionId);\n      if (connectionIds.size === 0) {\n        subscriptions.delete(eventKey);\n      }\n    }\n  };\n\n  const emitToEvents = (eventKey: string, message: string): void => {\n    // Publish to broadcaster so all instances (including this one) receive it\n    Effect.runPromise(\n      broadcaster.publish(\n        \"uploadista:events\",\n        JSON.stringify({ eventKey, message }),\n      ),\n    ).catch((error) => {\n      console.error(\"Failed to publish event to broadcaster:\", error);\n    });\n  };\n\n  return {\n    getConnection,\n    getConnections,\n    addConnection,\n    removeConnection,\n    subscribeToEvents,\n    unsubscribeFromEvents,\n    emitToEvents,\n  };\n});\n\n// Context tags\nexport class WebSocketManagerService extends Context.Tag(\n  \"BaseWebSocketManagerService\",\n)<WebSocketManagerService, WebSocketManager>() {}\n\n// Base layer\nexport const webSocketManager = Layer.effect(\n  WebSocketManagerService,\n  makeWebSocketManager,\n);\n","import { UploadistaError } from \"@uploadista/core/errors\";\nimport type {\n  WebSocketConnection,\n  WebSocketMessage,\n} from \"@uploadista/core/types\";\nimport {\n  type BaseEventEmitter,\n  BaseEventEmitterService,\n  type EventBroadcasterService,\n} from \"@uploadista/core/types\";\nimport { Effect, Layer } from \"effect\";\nimport {\n  type WebSocketManager,\n  WebSocketManagerService,\n  webSocketManager,\n} from \"./websocket-manager\";\n\nexport function webSocketBaseEventEmitter(\n  webSocketManager: WebSocketManager,\n): BaseEventEmitter {\n  return {\n    emit: (eventKey: string, message: string) => {\n      return Effect.try({\n        try: () => {\n          webSocketManager.emitToEvents(eventKey, message);\n        },\n        catch: (cause) => {\n          return UploadistaError.fromCode(\"UNKNOWN_ERROR\", { cause });\n        },\n      });\n    },\n    subscribe: (eventKey: string, connection: WebSocketConnection) => {\n      return Effect.try({\n        try: () => {\n          webSocketManager.addConnection(connection.id, connection);\n          webSocketManager.subscribeToEvents(eventKey, connection.id);\n\n          // Send confirmation message\n          connection.send(\n            JSON.stringify({\n              type: \"subscribed\",\n              payload: { eventKey },\n              timestamp: new Date().toISOString(),\n            } satisfies WebSocketMessage),\n          );\n        },\n        catch: (cause) => {\n          return UploadistaError.fromCode(\"UNKNOWN_ERROR\", { cause });\n        },\n      });\n    },\n    unsubscribe: (eventKey: string) => {\n      return Effect.try({\n        try: () => {\n          // Note: We need connectionId for proper cleanup, but the interface only provides eventKey\n          // For now, we'll remove all connections for this eventKey\n          // This could be improved by tracking connection mapping\n          const connections = webSocketManager.getConnections();\n          for (const [connectionId] of connections) {\n            webSocketManager.unsubscribeFromEvents(eventKey, connectionId);\n          }\n        },\n        catch: (cause) => {\n          return UploadistaError.fromCode(\"UNKNOWN_ERROR\", { cause });\n        },\n      });\n    },\n  };\n}\n\n// Effect-based implementation using webSocketManagerService\nexport const makeBaseEventEmitter = Effect.gen(function* () {\n  const webSocketManager = yield* WebSocketManagerService;\n  return webSocketBaseEventEmitter(webSocketManager);\n});\n\nexport const webSocketEventEmitter = (\n  eventBroadcaster: Layer.Layer<EventBroadcasterService>,\n) =>\n  Layer.effect(BaseEventEmitterService, makeBaseEventEmitter).pipe(\n    Layer.provide(webSocketManager),\n    Layer.provide(eventBroadcaster),\n  );\n"],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@uploadista/event-emitter-websocket",
   "type": "module",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "WebSocket event emitter for Uploadista",
   "license": "MIT",
   "author": "Uploadista",
@@ -14,13 +14,14 @@
   },
   "dependencies": {
     "effect": "3.18.4",
-    "@uploadista/core": "0.0.3"
+    "@uploadista/core": "0.0.4"
   },
   "devDependencies": {
-    "@uploadista/typescript-config": "0.0.3"
+    "tsdown": "0.15.9",
+    "@uploadista/typescript-config": "0.0.4"
   },
   "scripts": {
-    "build": "tsc -b",
+    "build": "tsdown",
     "format": "biome format --write ./src",
     "lint": "biome lint --write ./src",
     "check": "biome check --write ./src"

package/tsdown.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+  entry: {
+    index: "src/index.ts",
+  },
+  minify: true,
+  format: ["esm", "cjs"],
+  dts: true,
+  outDir: "dist",
+});

package/dist/test-generic.d.ts

@@ -1,36 +0,0 @@
-declare const uploadEventEmitter: import("@uploadista/core").EventEmitter<{
-    type: import("@uploadista/core").UploadEventType.UPLOAD_STARTED | import("@uploadista/core").UploadEventType.UPLOAD_COMPLETE;
-    data: {
-        id: string;
-        offset: number;
-        storage: {
-            id: string;
-            type: string;
-            path?: string | undefined;
-            uploadId?: string | undefined;
-            bucket?: string | undefined;
-        };
-        size?: number | undefined;
-        metadata?: Record<string, string> | undefined;
-        creationDate?: string | undefined;
-        url?: string | undefined;
-        sizeIsDeferred?: boolean | undefined;
-    };
-} | {
-    type: import("@uploadista/core").UploadEventType.UPLOAD_PROGRESS;
-    data: {
-        id: string;
-        progress: number;
-        total: number;
-    };
-} | {
-    type: import("@uploadista/core").UploadEventType.UPLOAD_FAILED;
-    data: {
-        id: string;
-        error: string;
-    };
-}>;
-declare const flowEventEmitter: import("@uploadista/core").EventEmitter<FlowEvent>;
-declare const combinedEventEmitter: import("@uploadista/core").EventEmitter<any>;
-export { uploadEventEmitter, flowEventEmitter, combinedEventEmitter };
-//# sourceMappingURL=test-generic.d.ts.map

package/dist/test-generic.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"test-generic.d.ts","sourceRoot":"","sources":["../src/test-generic.ts"],"names":[],"mappings":"AAUA,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACgC,CAAC;AACzD,QAAA,MAAM,gBAAgB,oDAAqD,CAAC;AAC5E,QAAA,MAAM,oBAAoB,8CAER,CAAC;AAGnB,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/test-generic.js

@@ -1,12 +0,0 @@
-import { webSocketEventEmitterStore } from "./websocket-event-emitter";
-import { createWebSocketManager } from "./websocket-manager";
-// Test that we can create websocket managers for both event types
-const uploadManager = createWebSocketManager();
-const flowManager = createWebSocketManager();
-const combinedManager = createWebSocketManager();
-// Test that we can create event emitters for both types
-const uploadEventEmitter = webSocketEventEmitterStore(uploadManager);
-const flowEventEmitter = webSocketEventEmitterStore(flowManager);
-const combinedEventEmitter = webSocketEventEmitterStore(combinedManager);
-// This file just tests compilation - no runtime code needed
-export { uploadEventEmitter, flowEventEmitter, combinedEventEmitter };

package/dist/websocket-event-emitter.d.ts

@@ -1,7 +0,0 @@
-import { type BaseEventEmitter, BaseEventEmitterService, type EventBroadcasterService } from "@uploadista/core/types";
-import { Effect, Layer } from "effect";
-import { type WebSocketManager, WebSocketManagerService } from "./websocket-manager";
-export declare function webSocketBaseEventEmitter(webSocketManager: WebSocketManager): BaseEventEmitter;
-export declare const makeBaseEventEmitter: Effect.Effect<BaseEventEmitter, never, WebSocketManagerService>;
-export declare const webSocketEventEmitter: (eventBroadcaster: Layer.Layer<EventBroadcasterService>) => Layer.Layer<BaseEventEmitterService, never, never>;
-//# sourceMappingURL=websocket-event-emitter.d.ts.map

package/dist/websocket-event-emitter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"websocket-event-emitter.d.ts","sourceRoot":"","sources":["../src/websocket-event-emitter.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,KAAK,gBAAgB,EACrB,uBAAuB,EACvB,KAAK,uBAAuB,EAC7B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,EACL,KAAK,gBAAgB,EACrB,uBAAuB,EAExB,MAAM,qBAAqB,CAAC;AAE7B,wBAAgB,yBAAyB,CACvC,gBAAgB,EAAE,gBAAgB,GACjC,gBAAgB,CAiDlB;AAGD,eAAO,MAAM,oBAAoB,iEAG/B,CAAC;AAEH,eAAO,MAAM,qBAAqB,GAChC,kBAAkB,KAAK,CAAC,KAAK,CAAC,uBAAuB,CAAC,uDAKrD,CAAC"}

package/dist/websocket-event-emitter.js

@@ -1,57 +0,0 @@
-import { UploadistaError } from "@uploadista/core/errors";
-import { BaseEventEmitterService, } from "@uploadista/core/types";
-import { Effect, Layer } from "effect";
-import { WebSocketManagerService, webSocketManager, } from "./websocket-manager";
-export function webSocketBaseEventEmitter(webSocketManager) {
-    return {
-        emit: (eventKey, message) => {
-            return Effect.try({
-                try: () => {
-                    webSocketManager.emitToEvents(eventKey, message);
-                },
-                catch: (cause) => {
-                    return UploadistaError.fromCode("UNKNOWN_ERROR", { cause });
-                },
-            });
-        },
-        subscribe: (eventKey, connection) => {
-            return Effect.try({
-                try: () => {
-                    webSocketManager.addConnection(connection.id, connection);
-                    webSocketManager.subscribeToEvents(eventKey, connection.id);
-                    // Send confirmation message
-                    connection.send(JSON.stringify({
-                        type: "subscribed",
-                        payload: { eventKey },
-                        timestamp: new Date().toISOString(),
-                    }));
-                },
-                catch: (cause) => {
-                    return UploadistaError.fromCode("UNKNOWN_ERROR", { cause });
-                },
-            });
-        },
-        unsubscribe: (eventKey) => {
-            return Effect.try({
-                try: () => {
-                    // Note: We need connectionId for proper cleanup, but the interface only provides eventKey
-                    // For now, we'll remove all connections for this eventKey
-                    // This could be improved by tracking connection mapping
-                    const connections = webSocketManager.getConnections();
-                    for (const [connectionId] of connections) {
-                        webSocketManager.unsubscribeFromEvents(eventKey, connectionId);
-                    }
-                },
-                catch: (cause) => {
-                    return UploadistaError.fromCode("UNKNOWN_ERROR", { cause });
-                },
-            });
-        },
-    };
-}
-// Effect-based implementation using webSocketManagerService
-export const makeBaseEventEmitter = Effect.gen(function* () {
-    const webSocketManager = yield* WebSocketManagerService;
-    return webSocketBaseEventEmitter(webSocketManager);
-});
-export const webSocketEventEmitter = (eventBroadcaster) => Layer.effect(BaseEventEmitterService, makeBaseEventEmitter).pipe(Layer.provide(webSocketManager), Layer.provide(eventBroadcaster));

package/dist/websocket-manager.d.ts

@@ -1,27 +0,0 @@
-import type { WebSocketConnection } from "@uploadista/core/types";
-import { EventBroadcasterService } from "@uploadista/core/types";
-import { Context, Effect, Layer } from "effect";
-export interface WebSocketManager {
-    readonly getConnection: (key: string) => WebSocketConnection | null;
-    readonly getConnections: () => Map<string, WebSocketConnection>;
-    readonly addConnection: (key: string, connection: WebSocketConnection) => void;
-    readonly removeConnection: (key: string) => void;
-    readonly subscribeToEvents: (eventKey: string, connectionId: string) => void;
-    readonly unsubscribeFromEvents: (eventKey: string, connectionId: string) => void;
-    readonly emitToEvents: (eventKey: string, event: string) => void;
-}
-export declare const makeWebSocketManager: Effect.Effect<{
-    getConnection: (key: string) => WebSocketConnection | null;
-    getConnections: () => Map<string, WebSocketConnection>;
-    addConnection: (key: string, connection: WebSocketConnection) => void;
-    removeConnection: (key: string) => void;
-    subscribeToEvents: (eventKey: string, connectionId: string) => void;
-    unsubscribeFromEvents: (eventKey: string, connectionId: string) => void;
-    emitToEvents: (eventKey: string, message: string) => void;
-}, never, EventBroadcasterService>;
-declare const WebSocketManagerService_base: Context.TagClass<WebSocketManagerService, "BaseWebSocketManagerService", WebSocketManager>;
-export declare class WebSocketManagerService extends WebSocketManagerService_base {
-}
-export declare const webSocketManager: Layer.Layer<WebSocketManagerService, never, EventBroadcasterService>;
-export {};
-//# sourceMappingURL=websocket-manager.d.ts.map

package/dist/websocket-manager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"websocket-manager.d.ts","sourceRoot":"","sources":["../src/websocket-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAGhD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,aAAa,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,mBAAmB,GAAG,IAAI,CAAC;IACpE,QAAQ,CAAC,cAAc,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IAChE,QAAQ,CAAC,aAAa,EAAE,CACtB,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,mBAAmB,KAC5B,IAAI,CAAC;IACV,QAAQ,CAAC,gBAAgB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IACjD,QAAQ,CAAC,iBAAiB,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7E,QAAQ,CAAC,qBAAqB,EAAE,CAC9B,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,KACjB,IAAI,CAAC;IACV,QAAQ,CAAC,YAAY,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CAClE;AAED,eAAO,MAAM,oBAAoB;yBA8CH,MAAM,KAAG,mBAAmB,GAAG,IAAI;0BAIpC,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC;yBAKpD,MAAM,cACC,mBAAmB,KAC9B,IAAI;4BAIwB,MAAM,KAAG,IAAI;kCAWP,MAAM,gBAAgB,MAAM,KAAG,IAAI;sCAQ5D,MAAM,gBACF,MAAM,KACnB,IAAI;6BAUyB,MAAM,WAAW,MAAM,KAAG,IAAI;kCAqB9D,CAAC;;AAGH,qBAAa,uBAAwB,SAAQ,4BAEC;CAAG;AAGjD,eAAO,MAAM,gBAAgB,sEAG5B,CAAC"}

package/dist/websocket-manager.js

@@ -1,97 +0,0 @@
-import { EventBroadcasterService } from "@uploadista/core/types";
-import { Context, Effect, Layer } from "effect";
-export const makeWebSocketManager = Effect.gen(function* () {
-    const broadcaster = yield* EventBroadcasterService;
-    const connections = new Map();
-    const subscriptions = new Map(); // eventKey -> Set<connectionId>
-    // Helper to send messages to local connections for a given eventKey
-    const emitToLocalConnections = (eventKey, message) => {
-        const connectionIds = subscriptions.get(eventKey);
-        if (!connectionIds)
-            return;
-        for (const connectionId of connectionIds) {
-            const connection = connections.get(connectionId);
-            if (connection && connection.readyState === 1) {
-                try {
-                    connection.send(message);
-                }
-                catch (error) {
-                    console.warn(`Failed to send message to connection ${connectionId}:`, error);
-                    removeConnection(connectionId);
-                }
-            }
-            else {
-                removeConnection(connectionId);
-            }
-        }
-    };
-    // Subscribe to broadcast events from other instances
-    yield* broadcaster
-        .subscribe("uploadista:events", (broadcastMessage) => {
-        try {
-            const { eventKey, message } = JSON.parse(broadcastMessage);
-            emitToLocalConnections(eventKey, message);
-        }
-        catch (error) {
-            console.warn("Failed to parse broadcast message:", error);
-        }
-    })
-        .pipe(Effect.catchAll((error) => {
-        console.error("Failed to subscribe to broadcast events:", error);
-        return Effect.void;
-    }));
-    const getConnection = (key) => {
-        return connections.get(key) || null;
-    };
-    const getConnections = () => {
-        return connections;
-    };
-    const addConnection = (key, connection) => {
-        connections.set(key, connection);
-    };
-    const removeConnection = (key) => {
-        connections.delete(key);
-        // Clean up subscriptions
-        for (const [eventKey, connectionIds] of subscriptions.entries()) {
-            connectionIds.delete(key);
-            if (connectionIds.size === 0) {
-                subscriptions.delete(eventKey);
-            }
-        }
-    };
-    const subscribeToEvents = (eventKey, connectionId) => {
-        if (!subscriptions.has(eventKey)) {
-            subscriptions.set(eventKey, new Set());
-        }
-        subscriptions.get(eventKey)?.add(connectionId);
-    };
-    const unsubscribeFromEvents = (eventKey, connectionId) => {
-        const connectionIds = subscriptions.get(eventKey);
-        if (connectionIds) {
-            connectionIds.delete(connectionId);
-            if (connectionIds.size === 0) {
-                subscriptions.delete(eventKey);
-            }
-        }
-    };
-    const emitToEvents = (eventKey, message) => {
-        // Publish to broadcaster so all instances (including this one) receive it
-        Effect.runPromise(broadcaster.publish("uploadista:events", JSON.stringify({ eventKey, message }))).catch((error) => {
-            console.error("Failed to publish event to broadcaster:", error);
-        });
-    };
-    return {
-        getConnection,
-        getConnections,
-        addConnection,
-        removeConnection,
-        subscribeToEvents,
-        unsubscribeFromEvents,
-        emitToEvents,
-    };
-});
-// Context tags
-export class WebSocketManagerService extends Context.Tag("BaseWebSocketManagerService")() {
-}
-// Base layer
-export const webSocketManager = Layer.effect(WebSocketManagerService, makeWebSocketManager);

package/dist/websocket-server.d.ts

@@ -1,10 +0,0 @@
-import { Context, Effect, Layer } from "effect";
-export interface WebSocketServer {
-    handleConnection(key: string, websocket: WebSocket): Effect.Effect<void, never>;
-    broadcastEvent(event: unknown): Effect.Effect<void, never>;
-    getConnectionCount(): number;
-}
-export declare function webSocketServer(): WebSocketServer;
-export declare const WebSocketServer: Context.Tag<WebSocketServer, WebSocketServer>;
-export declare const WebSocketServerLayer: Layer.Layer<WebSocketServer, never, never>;
-//# sourceMappingURL=websocket-server.d.ts.map

package/dist/websocket-server.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"websocket-server.d.ts","sourceRoot":"","sources":["../src/websocket-server.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAGhD,MAAM,WAAW,eAAe;IAC9B,gBAAgB,CACd,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,SAAS,GACnB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAC9B,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAC3D,kBAAkB,IAAI,MAAM,CAAC;CAC9B;AAED,wBAAgB,eAAe,IAAI,eAAe,CAgEjD;AAED,eAAO,MAAM,eAAe,+CAC4B,CAAC;AAEzD,eAAO,MAAM,oBAAoB,4CAGhC,CAAC"}

package/dist/websocket-server.js

@@ -1,56 +0,0 @@
-import { Context, Effect, Layer } from "effect";
-import { createWebSocketManager } from "./websocket-event-emitter";
-export function webSocketServer() {
-    const webSocketManager = createWebSocketManager();
-    const handleConnection = (key, websocket) => {
-        return Effect.sync(() => {
-            const connection = {
-                id: key,
-                send: (data) => websocket.send(data),
-                close: (code, reason) => websocket.close(code, reason),
-                readyState: websocket.readyState,
-            };
-            webSocketManager.addConnection(key, connection);
-            websocket.addEventListener("close", () => {
-                webSocketManager.removeConnection(key);
-            });
-            websocket.addEventListener("error", () => {
-                webSocketManager.removeConnection(key);
-            });
-            // Send a welcome message
-            websocket.send(JSON.stringify({
-                type: "connection",
-                message: "WebSocket connection established",
-                key,
-            }));
-        });
-    };
-    const broadcastEvent = (event) => {
-        return Effect.sync(() => {
-            // Since we removed the generic broadcast method, we can use emitToUpload for specific upload events
-            // Or add a generic broadcast method if needed
-            const connections = webSocketManager.getConnections();
-            const message = JSON.stringify(event);
-            for (const [_key, connection] of connections) {
-                if (connection.readyState === 1) {
-                    try {
-                        connection.send(message);
-                    }
-                    catch (error) {
-                        console.warn(`Failed to send broadcast message:`, error);
-                    }
-                }
-            }
-        });
-    };
-    const getConnectionCount = () => {
-        return webSocketManager.getConnections().size ?? 0;
-    };
-    return {
-        handleConnection,
-        broadcastEvent,
-        getConnectionCount,
-    };
-}
-export const WebSocketServer = Context.GenericTag("WebSocketServer");
-export const WebSocketServerLayer = Layer.effect(WebSocketServer, Effect.succeed(webSocketServer()));