statocysts 0.0.4 → 0.1.0

package/dist/browser.d.ts

@@ -0,0 +1,9 @@
+import { a as DEFAULT_EXTRACTOR, c as ServiceProvider, i as slackProvider, l as defineProvider, n as SlackData, o as DefineProviderContext, r as SlackOptions, s as DefineProviderOptions, t as jsonProvider } from "./index-pwxPZaBo.js";
+import { FetchOptions } from "ofetch";
+
+//#region src/browser.d.ts
+type Protocol = 'json:' | 'slack:';
+declare const SUPPORTED_PROTOCOLS: readonly ["json:", "slack:"];
+declare function send(url: string | URL, message: string, options?: FetchOptions): Promise<void>;
+//#endregion
+export { DEFAULT_EXTRACTOR, DefineProviderContext, DefineProviderOptions, Protocol, SUPPORTED_PROTOCOLS, ServiceProvider, SlackData, SlackOptions, defineProvider, jsonProvider, send, slackProvider };

package/dist/browser.js

@@ -0,0 +1,19 @@
+import { a as assert, i as defineProvider, n as slackProvider, r as DEFAULT_EXTRACTOR, t as jsonProvider } from "./shared-DLVVDcdQ.js";
+import { ofetch } from "ofetch";
+
+//#region src/browser.ts
+const SUPPORTED_PROTOCOLS = ["json:", "slack:"];
+const providers = {
+	"json:": jsonProvider,
+	"slack:": slackProvider
+};
+async function send(url, message, options) {
+	const _url = typeof url === "string" ? new URL(url) : url;
+	assert(SUPPORTED_PROTOCOLS.includes(_url.protocol), `Unsupported protocol ${_url.protocol}`);
+	const provider = providers[_url.protocol];
+	if (!provider) throw new Error(`Unsupported protocol ${_url.protocol}`);
+	await ofetch(await provider.buildRequest(_url.toString(), message), options);
+}
+
+//#endregion
+export { DEFAULT_EXTRACTOR, SUPPORTED_PROTOCOLS, defineProvider, jsonProvider, send, slackProvider };

package/dist/index-pwxPZaBo.d.ts

@@ -0,0 +1,50 @@
+//#region src/core/provider.d.ts
+interface ServiceProvider<Protocol extends string, Data = unknown, Options = unknown> {
+  readonly protocol: Protocol;
+  $infer: Data;
+  defaultOptions: Options | undefined;
+  buildRequest: (url: string, message: string, options?: Options) => Promise<Request>;
+}
+interface DefineProviderContext<Data = unknown> {
+  url: URL;
+  message: string;
+  data: Data;
+}
+interface DefineProviderOptions<Data = unknown, Options = unknown> {
+  defaultOptions?: Options;
+  extractor?: (url: URL) => Data;
+  createRequest: (this: DefineProviderContext<Data>, ctx: DefineProviderContext<Data>, Options: Options) => Request;
+}
+declare const DEFAULT_EXTRACTOR: (url: URL) => unknown;
+declare function defineProvider<const Protocol extends string, Data = unknown, Options = unknown>(protocol: Protocol, createOptions: DefineProviderOptions<Data, Options>): ServiceProvider<Protocol, Data, Options>;
+//#endregion
+//#region src/services/chat/slack/index.d.ts
+interface SlackData {
+  type: 'bot' | 'webhook';
+}
+interface SlackOptions {
+  /**
+   * The base URL for webhook services
+   *
+   * @default `https://hooks.slack.com/services`
+   */
+  hookBaseUrl?: string;
+  /**
+   * The base URL for bot API services
+   *
+   * @default `https://slack.com/api`
+   */
+  botApiBaseUrl?: string;
+  /**
+   * The body of the request
+   *
+   * NOTICE*: This will override the body of the request. You should known what you are doing.
+   */
+  body?: Record<string, any>;
+}
+declare const slackProvider: ServiceProvider<"slack:", SlackData, SlackOptions>;
+//#endregion
+//#region src/services/specialized/json/index.d.ts
+declare const jsonProvider: ServiceProvider<"json:", unknown, unknown>;
+//#endregion
+export { DEFAULT_EXTRACTOR as a, ServiceProvider as c, slackProvider as i, defineProvider as l, SlackData as n, DefineProviderContext as o, SlackOptions as r, DefineProviderOptions as s, jsonProvider as t };

package/dist/index.d.ts

@@ -1 +1,9 @@
-export { };
+import { a as DEFAULT_EXTRACTOR, c as ServiceProvider, i as slackProvider, l as defineProvider, n as SlackData, o as DefineProviderContext, r as SlackOptions, s as DefineProviderOptions, t as jsonProvider } from "./index-pwxPZaBo.js";
+import { FetchOptions } from "ofetch";
+
+//#region src/index.d.ts
+type Protocol = 'json:' | 'slack:';
+declare const SUPPORTED_PROTOCOLS: readonly ["json:", "slack:"];
+declare function send(url: string | URL, message: string, options?: FetchOptions): Promise<void>;
+//#endregion
+export { DEFAULT_EXTRACTOR, DefineProviderContext, DefineProviderOptions, Protocol, SUPPORTED_PROTOCOLS, ServiceProvider, SlackData, SlackOptions, defineProvider, jsonProvider, send, slackProvider };

package/dist/index.js

@@ -0,0 +1,19 @@
+import { a as assert, i as defineProvider, n as slackProvider, r as DEFAULT_EXTRACTOR, t as jsonProvider } from "./shared-DLVVDcdQ.js";
+import { ofetch } from "ofetch";
+
+//#region src/index.ts
+const SUPPORTED_PROTOCOLS = ["json:", "slack:"];
+const providers = {
+	"json:": jsonProvider,
+	"slack:": slackProvider
+};
+async function send(url, message, options) {
+	const _url = typeof url === "string" ? new URL(url) : url;
+	assert(SUPPORTED_PROTOCOLS.includes(_url.protocol), `Unsupported protocol ${_url.protocol}`);
+	const provider = providers[_url.protocol];
+	if (!provider) throw new Error(`Unsupported protocol ${_url.protocol}`);
+	await ofetch(await provider.buildRequest(_url.toString(), message), options);
+}
+
+//#endregion
+export { DEFAULT_EXTRACTOR, SUPPORTED_PROTOCOLS, defineProvider, jsonProvider, send, slackProvider };

package/dist/shared-DLVVDcdQ.js

@@ -0,0 +1,107 @@
+import defu from "defu";
+import { withProtocol, withoutLeadingSlash } from "ufo";
+
+//#region src/utils/assert.ts
+function assert(condition, message) {
+	if (!condition) throw typeof message === "string" ? new Error(message) : message;
+}
+
+//#endregion
+//#region src/core/provider.ts
+const DEFAULT_EXTRACTOR = (url) => Object.fromEntries(url.searchParams.entries());
+function defineProvider(protocol, createOptions) {
+	const createOpt = defu(createOptions, { extractor: DEFAULT_EXTRACTOR });
+	const buildRequest = async (protocolUrl, message, options) => {
+		const url = new URL(protocolUrl);
+		assert(url.protocol === protocol, `Unexpected protocol "${url.protocol}"`);
+		const ctx = {
+			data: createOpt.extractor(url),
+			url,
+			message
+		};
+		const opts = defu(createOptions.defaultOptions ?? {}, options ?? {});
+		return createOptions.createRequest.call(ctx, ctx, opts);
+	};
+	return {
+		get protocol() {
+			return protocol;
+		},
+		buildRequest,
+		get defaultOptions() {
+			return createOptions.defaultOptions;
+		},
+		$infer: {}
+	};
+}
+
+//#endregion
+//#region src/services/chat/slack/index.ts
+const slackProvider = defineProvider("slack:", {
+	extractor: (url) => {
+		assert(url.hostname === "bot" || url.hostname === "webhook", `Invalid slack URL: ${url.toString()}`);
+		if (url.hostname === "bot") {
+			assert(url.username, "Channel ID is required");
+			assert(url.password, "Bot token is required");
+		} else assert(url.pathname.split("/").filter(Boolean).length === 3, "Webhook URL is invalid");
+		return { type: url.hostname };
+	},
+	defaultOptions: {
+		hookBaseUrl: "https://hooks.slack.com/",
+		botApiBaseUrl: "https://slack.com/"
+	},
+	createRequest(_, options) {
+		const { type } = this.data;
+		let url;
+		const headers = new Headers([["Content-Type", "application/json"]]);
+		const body = { text: this.message };
+		if (type === "bot") {
+			const { username: channel, password: token, searchParams } = this.url;
+			url = new URL("/api/chat.postMessage", options.botApiBaseUrl);
+			searchParams.forEach((value, key) => {
+				url.searchParams.set(key, value);
+			});
+			headers.set("Authorization", `Bearer ${token}`);
+			body.channel = channel;
+		} else {
+			const { searchParams } = this.url;
+			url = new URL(`/services/${withoutLeadingSlash(this.url.pathname)}`, options.hookBaseUrl);
+			searchParams.forEach((value, key) => {
+				url.searchParams.set(key, value);
+			});
+		}
+		return new Request(url, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(options.body ?? body)
+		});
+	}
+});
+
+//#endregion
+//#region src/services/specialized/json/index.ts
+const jsonProvider = defineProvider("json:", { createRequest() {
+	const url = new URL(this.url);
+	const headers = new Headers([["Content-Type", "application/json"]]);
+	const body = { message: this.message };
+	Array.from(url.searchParams.entries()).forEach(([key, value]) => {
+		if (key.startsWith(" ")) {
+			url.searchParams.delete(key);
+			const headerKey = key.slice(1);
+			if (headers.has(headerKey)) headers.set(headerKey, value);
+			else headers.append(headerKey, value);
+		} else if (key.startsWith(":")) {
+			url.searchParams.delete(key);
+			const propertyKey = key.slice(1);
+			body[propertyKey] = value;
+		}
+	});
+	const requestUrl = withProtocol(url.toString(), "https:");
+	return new Request(requestUrl, {
+		method: "POST",
+		body: JSON.stringify(body),
+		headers
+	});
+} });
+
+//#endregion
+export { assert as a, defineProvider as i, slackProvider as n, DEFAULT_EXTRACTOR as r, jsonProvider as t };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "statocysts",
   "type": "module",
-  "version": "0.0.4",
+  "version": "0.1.0",
   "description": "Notification library for JavaScript",
   "license": "MIT",
   "homepage": "https://github.com/octoplorer/statocysts",
@@ -17,12 +17,20 @@
     "shoutrrr"
   ],
   "exports": {
-    ".": "./dist/index.js",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "import": "./dist/browser.js"
+    },
     "./package.json": "./package.json"
   },
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "browser": "./dist/browser.js",
   "files": [
     "dist"
   ],
@@ -32,8 +40,16 @@
   "engines": {
     "node": ">=24.12.0"
   },
+  "dependencies": {
+    "defu": "^6.1.4",
+    "ofetch": "^1.5.1",
+    "ufo": "^1.6.1",
+    "zod": "^4.2.1"
+  },
   "devDependencies": {
     "@antfu/eslint-config": "^6.7.1",
+    "@types/node": "^25.0.2",
+    "@vitest/coverage-v8": "4.0.15",
     "bumpp": "^10.3.2",
     "eslint": "^9.39.2",
     "eslint-plugin-format": "^1.1.0",