@civet/common 2.0.0 → 2.1.1

package/dist/FetchProvider.d.ts

@@ -15,8 +15,8 @@ export type FetchOptions<Item = unknown, MetaType extends Meta = Meta, ResponseT
 declare class FetchProvider<Item = unknown, ResponseType extends Item | Item[] = Item | Item[], Query extends RequestInit | undefined = RequestInit | undefined, MetaType extends Meta = Meta, Options extends FetchOptions<Item, MetaType, ResponseType> = FetchOptions<Item, MetaType, ResponseType>> extends DataProvider<Item, Query, Options, MetaType, ResponseType> {
     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;
+    handleGet(url: string, query: Query, options: Options | undefined, meta: MetaType, abortSignal: AbortSignalProxy): Promise<ResponseType>;
     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,6 +1,7 @@
 import { GenericDataProvider, Notifier, ResourceContextValue } from '@civet/core';
 import { EventReceiver } from '@civet/events';
 export type SSEReceiverOptions<Resource extends ResourceContextValue<GenericDataProvider>, EventType = MessageEvent> = {
+    events?: string[];
     getEvents?: (resource: Resource | undefined, type: string, event: MessageEvent) => Promise<EventType[]> | EventType[];
 };
 export type SSEOptions<Resource extends ResourceContextValue<GenericDataProvider>, EventType = MessageEvent> = {

package/dist/main.js

@@ -1,88 +1,90 @@
 import { DataProvider as d, Meta as l } from "@civet/core";
-import { eventPlugin as p, EventReceiver as v } from "@civet/events";
-class f extends d {
+import { eventPlugin as p, EventReceiver as f } from "@civet/events";
+class v extends d {
   options;
   constructor(r = {}) {
     super(), this.options = r;
   }
-  handleGet(r, s, t, e, u) {
-    return this.request(r, s, t, e, u);
-  }
   normalizeResource(r) {
     return new URL(r, this.options.baseURL).toString();
   }
-  async request(r, s, t, e, u) {
+  handleGet(r, n, t, e, u) {
+    return this.request(r, n, t, e, u);
+  }
+  async request(r, n, t, e, u) {
     e = e instanceof l ? e : new l(e);
-    const i = new AbortController();
-    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,
+    const a = new AbortController();
+    u?.listen(a.abort.bind(a));
+    const s = new URL(r, this.options.baseURL), c = new Headers(n?.headers), o = { ...n, headers: c };
+    await this.options.modifyRequest?.(s, o, e);
+    const i = await fetch(s.toString(), {
+      ...o,
       signal: AbortSignal.any(
-        [n.signal, i.signal].filter((g) => g != null)
+        [o.signal, a.signal].filter((g) => g != null)
       )
     });
-    if (!o.ok) {
+    if (!i.ok) {
       if (t?.handleError)
         return t.handleError(
-          a,
-          n,
+          s,
           o,
+          i,
           e
         );
       if (this.options.handleError)
         return this.options.handleError(
-          a,
-          n,
+          s,
           o,
+          i,
           e
         );
-      throw new Error(o.statusText);
+      throw new Error(i.statusText);
     }
     if (t?.getResponse)
       return t.getResponse(
-        a,
-        n,
+        s,
         o,
+        i,
         e
       );
     if (this.options.getResponse)
       return this.options.getResponse(
-        a,
-        n,
+        s,
         o,
+        i,
         e
       );
     if (t?.json || !t?.noJson && /^application\/[^+]*[+]?(json);?.*$/.test(
-      o.headers.get("Content-Type") ?? ""
+      i.headers.get("Content-Type") ?? ""
     ))
-      return o.json();
-    if (!t?.noText) return o.text();
+      return i.json();
+    if (!t?.noText) return i.text();
     throw new Error("unprocessable response");
   }
 }
-const w = p(f);
-class R extends v {
+const w = p(v);
+class R extends f {
   eventSource;
   options;
-  constructor(r, s = {}) {
-    super(), this.eventSource = r, this.options = s;
+  constructor(r, n = {}) {
+    super(), this.eventSource = r, this.options = n;
   }
-  handleSubscribe(r, s, t) {
+  handleSubscribe(r, n, 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) => {
+    ), a = new AbortController();
+    a.signal.addEventListener("abort", u);
+    let s = [];
+    return n?.events ? s = n.events : this.options.events && (s = this.options.events), s.length === 0 && (s = ["message"]), s.forEach((c) => {
       this.eventSource.addEventListener(
         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 }
+        async (o) => n?.getEvents ? t(await n.getEvents(e, c, o)) : this.options.getEvents ? t(await this.options.getEvents(e, c, o)) : t([o]),
+        { signal: a.signal }
       );
-    }), i.abort.bind(i);
+    }), a.abort.bind(a);
   }
 }
 export {

package/package.json

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