@civet/common 1.2.0 → 2.0.0

package/dist/FetchProvider.d.ts

@@ -16,6 +16,7 @@ declare class FetchProvider<Item = unknown, ResponseType extends Item | Item[] =
     private options;
     constructor(options?: FetchProviderOptions<Item, MetaType, ResponseType>);
     handleGet(url: string, query: Query, options: Options | undefined, meta: MetaType, abortSignal: AbortSignalProxy): Promise<ResponseType>;
+    normalizeResource(resource: string): string;
     request<ResponseTypeI extends ResponseType = ResponseType, QueryI extends Query = Query, OptionsI extends Options = Options, MetaTypeI extends MetaType = MetaType>(url: string, query: QueryI, options?: OptionsI | undefined, meta?: MetaTypeI, abortSignal?: AbortSignalProxy): Promise<ResponseTypeI>;
 }
 declare const FetchProviderWithPlugins: import('@civet/core').DataProviderImplementationWithPlugin<typeof FetchProvider, unknown, {

package/dist/SSEReceiver.d.ts

@@ -1,16 +1,16 @@
-import { GenericDataProvider, ResourceContextValue } from '@civet/core';
+import { GenericDataProvider, Notifier, ResourceContextValue } from '@civet/core';
 import { EventReceiver } from '@civet/events';
 export type SSEReceiverOptions<Resource extends ResourceContextValue<GenericDataProvider>, EventType = MessageEvent> = {
-    getEvents?: (resource: Resource, type: string, event: MessageEvent) => Promise<EventType[]> | EventType[];
+    getEvents?: (resource: Resource | undefined, type: string, event: MessageEvent) => Promise<EventType[]> | EventType[];
 };
 export type SSEOptions<Resource extends ResourceContextValue<GenericDataProvider>, EventType = MessageEvent> = {
     events?: string[];
-    getEvents?: (resource: Resource, type: string, event: MessageEvent) => Promise<EventType[]> | EventType[];
+    getEvents?: (resource: Resource | undefined, type: string, event: MessageEvent) => Promise<EventType[]> | EventType[];
 };
-export default class SSEReceiver<Resource extends ResourceContextValue<GenericDataProvider>, EventType = MessageEvent, Options extends SSEOptions<Resource, EventType> = SSEOptions<Resource, EventType>> extends EventReceiver<Resource, EventType, Options> {
+export default class SSEReceiver<Resource extends ResourceContextValue<GenericDataProvider>, EventType = MessageEvent, Options extends SSEOptions<Resource, EventType> = SSEOptions<Resource, EventType>> extends EventReceiver<EventType, Resource, Options> {
     readonly eventSource: EventSource;
     private options;
     constructor(eventSource: EventSource, options?: SSEReceiverOptions<Resource, EventType>);
-    handleSubscribe(resource: Resource, options: Options | undefined, handler: (events: EventType[]) => void): () => void;
+    handleSubscribe(resourceNotifier: Notifier<[Resource | undefined]>, options: Options | undefined, handler: (events: EventType[]) => void): () => void;
 }
 export type SSEReceiverType = InstanceType<typeof SSEReceiver>;

package/dist/main.js

@@ -1,37 +1,40 @@
-import { DataProvider as d, Meta as h } from "@civet/core";
-import { eventPlugin as p, EventReceiver as f } from "@civet/events";
-class v extends d {
+import { DataProvider as d, Meta as l } from "@civet/core";
+import { eventPlugin as p, EventReceiver as v } from "@civet/events";
+class f extends d {
   options;
-  constructor(n = {}) {
-    super(), this.options = n;
+  constructor(r = {}) {
+    super(), this.options = r;
   }
-  handleGet(n, r, t, e, c) {
-    return this.request(n, r, t, e, c);
+  handleGet(r, s, t, e, u) {
+    return this.request(r, s, t, e, u);
   }
-  async request(n, r, t, e, c) {
-    e = e instanceof h ? e : new h(e);
+  normalizeResource(r) {
+    return new URL(r, this.options.baseURL).toString();
+  }
+  async request(r, s, t, e, u) {
+    e = e instanceof l ? e : new l(e);
     const i = new AbortController();
-    c?.listen(i.abort.bind(i));
-    const s = new URL(n, this.options.baseURL), u = new Headers(r?.headers), a = { ...r, headers: u };
-    await this.options.modifyRequest?.(s, a, e);
-    const o = await fetch(s.toString(), {
-      ...a,
+    u?.listen(i.abort.bind(i));
+    const a = new URL(r), c = new Headers(s?.headers), n = { ...s, headers: c };
+    await this.options.modifyRequest?.(a, n, e);
+    const o = await fetch(a.toString(), {
+      ...n,
       signal: AbortSignal.any(
-        [a.signal, i.signal].filter((g) => g != null)
+        [n.signal, i.signal].filter((g) => g != null)
       )
     });
     if (!o.ok) {
       if (t?.handleError)
         return t.handleError(
-          s,
           a,
+          n,
           o,
           e
         );
       if (this.options.handleError)
         return this.options.handleError(
-          s,
           a,
+          n,
           o,
           e
         );
@@ -39,15 +42,15 @@ class v extends d {
     }
     if (t?.getResponse)
       return t.getResponse(
-        s,
         a,
+        n,
         o,
         e
       );
     if (this.options.getResponse)
       return this.options.getResponse(
-        s,
         a,
+        n,
         o,
         e
       );
@@ -59,25 +62,30 @@ class v extends d {
     throw new Error("unprocessable response");
   }
 }
-const b = p(v);
-class R extends f {
+const w = p(f);
+class R extends v {
   eventSource;
   options;
-  constructor(n, r = {}) {
-    super(), this.eventSource = n, this.options = r;
+  constructor(r, s = {}) {
+    super(), this.eventSource = r, this.options = s;
   }
-  handleSubscribe(n, r, t) {
-    const e = new AbortController();
-    return (r?.events?.length ? r.events : ["message"]).forEach((i) => {
+  handleSubscribe(r, s, t) {
+    let e;
+    const u = r.subscribe(
+      (c) => {
+        e = c;
+      }
+    ), i = new AbortController();
+    return i.signal.addEventListener("abort", u), (s?.events?.length ? s.events : ["message"]).forEach((c) => {
       this.eventSource.addEventListener(
-        i,
-        async (s) => r?.getEvents ? t(await r.getEvents(n, i, s)) : this.options.getEvents ? t(await this.options.getEvents(n, i, s)) : t([s]),
-        { signal: e.signal }
+        c,
+        async (n) => s?.getEvents ? t(await s.getEvents(e, c, n)) : this.options.getEvents ? t(await this.options.getEvents(e, c, n)) : t([n]),
+        { signal: i.signal }
       );
-    }), e.abort.bind(e);
+    }), i.abort.bind(i);
   }
 }
 export {
-  b as FetchProvider,
+  w as FetchProvider,
   R as SSEReceiver
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@civet/common",
-  "version": "1.2.0",
+  "version": "2.0.0",
   "description": "Civet",
   "author": {
     "name": "Aaron Burmeister"
@@ -51,8 +51,8 @@
     "react-dom": ">=18.0"
   },
   "devDependencies": {
-    "@civet/core": "^6.0.2",
-    "@civet/events": "^3.0.1",
+    "@civet/core": "^6.1.1",
+    "@civet/events": "^4.0.1",
     "@eslint/js": "^9.35.0",
     "@types/react": "^19.1.12",
     "@types/react-dom": "^19.1.9",