@civet/common 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aaron Burmeister
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,4 @@
+# @civet/common [![npm version](https://badge.fury.io/js/%40civet%2Fcommon.svg)](http://npmjs.com/package/%40civet%2Fcommon)
+
+This is a Civet module.
+Please visit [civet.js.org](http://civet.js.org) for more information.

package/dist/FetchProvider.d.ts

@@ -0,0 +1,23 @@
+import { DataProvider, Meta, AbortSignalProxy } from '@civet/core';
+export type FetchProviderOptions<Item = unknown, MetaType extends Meta = Meta, ResponseType extends Item | Item[] | void = Item | Item[] | void> = {
+    baseURL?: string;
+    modifyRequest?: (url: URL, request: RequestInit, meta: MetaType) => Promise<void> | void;
+    getResponse?: (url: URL, request: RequestInit, response: Response, meta: MetaType) => Promise<ResponseType> | ResponseType;
+    handleError?: (url: URL, request: RequestInit, response: Response, meta: MetaType) => Promise<ResponseType> | ResponseType;
+};
+export type FetchOptions<Item = unknown, MetaType extends Meta = Meta, ResponseType extends Item | Item[] = Item | Item[]> = {
+    json?: boolean;
+    noJson?: boolean;
+    noText?: boolean;
+    getResponse?: (url: URL, request: RequestInit, response: Response, meta: MetaType) => Promise<ResponseType> | ResponseType;
+    handleError?: (url: URL, request: RequestInit, response: Response, meta: MetaType) => Promise<ResponseType> | ResponseType;
+};
+export default 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(resource: string, query: Query & {
+        method?: RequestInit['method'];
+    }, 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>(resource: string, query: QueryI, options?: OptionsI | undefined, meta?: MetaTypeI, abortSignal?: AbortSignalProxy): Promise<ResponseTypeI>;
+}
+export type FetchProviderType = InstanceType<typeof FetchProvider>;

package/dist/SSEReceiver.d.ts

@@ -0,0 +1,16 @@
+import { GenericDataProvider, 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[];
+};
+export type SSEOptions<Resource extends ResourceContextValue<GenericDataProvider>, EventType = MessageEvent> = {
+    events?: string[];
+    getEvents?: (resource: Resource, 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> {
+    readonly eventSource: EventSource;
+    private options;
+    constructor(eventSource: EventSource, options?: SSEReceiverOptions<Resource, EventType>);
+    handleSubscribe(resource: Resource, options: Options | undefined, handler: (events: EventType[]) => void): () => void;
+}
+export type SSEReceiverType = InstanceType<typeof SSEReceiver>;

package/dist/main.d.ts

@@ -0,0 +1,4 @@
+export { default as FetchProvider } from './FetchProvider';
+export type { FetchOptions, FetchProviderOptions, FetchProviderType, } from './FetchProvider';
+export { default as SSEReceiver } from './SSEReceiver';
+export type { SSEOptions, SSEReceiverOptions, SSEReceiverType, } from './SSEReceiver';

package/dist/main.js

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

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@civet/common",
+  "version": "1.0.0",
+  "description": "Civet",
+  "author": {
+    "name": "Aaron Burmeister"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/civet-org/common.git"
+  },
+  "bugs": {
+    "url": "https://github.com/civet-org/common/issues"
+  },
+  "homepage": "https://civet.js.org/",
+  "license": "MIT",
+  "type": "module",
+  "keywords": [
+    "civet",
+    "react",
+    "data",
+    "rest"
+  ],
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/main.js",
+  "types": "./dist/main.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/main.d.ts",
+        "default": "./dist/main.js"
+      }
+    }
+  },
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b ./tsconfig-build.json && vite build",
+    "lint": "eslint . --max-warnings 0",
+    "lint:fix": "npm run lint -- --fix",
+    "prettify": "prettier . --write",
+    "preview": "vite preview",
+    "postversion": "git commit -am$npm_package_version",
+    "prepublishOnly": "npm run build"
+  },
+  "peerDependencies": {
+    "@civet/core": ">=6.0",
+    "@civet/events": ">=3.0",
+    "react": ">=18.0",
+    "react-dom": ">=18.0"
+  },
+  "devDependencies": {
+    "@civet/core": "^6.0.2",
+    "@civet/events": "^3.0.1",
+    "@eslint/js": "^9.35.0",
+    "@types/react": "^19.1.12",
+    "@types/react-dom": "^19.1.9",
+    "@vitejs/plugin-react": "^5.0.2",
+    "eslint": "^9.35.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-import-resolver-alias": "^1.1.2",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-prettier": "^5.5.4",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "eslint-plugin-react-refresh": "^0.5.0",
+    "eslint-plugin-unused-imports": "^4.2.0",
+    "globals": "^17.3.0",
+    "prettier": "^3.6.2",
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1",
+    "typescript": "^5.9.2",
+    "typescript-eslint": "^8.43.0",
+    "vite": "^7.1.5",
+    "vite-plugin-dts": "^4.5.4",
+    "vite-tsconfig-paths": "^6.1.1"
+  }
+}