statocysts 0.0.5 → 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,31 +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";
-import { z } from "zod";
 
-//#region src/sender.d.ts
-type Protocol = 'generic:' | 'slack:';
-declare const SUPPORTED_PROTOCOLS: string[];
+//#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
-//#region src/services/chat/slack.d.ts
-declare const slackOptionsSchema: z.ZodObject<{
-  botname: z.ZodOptional<z.ZodString>;
-  icon: z.ZodOptional<z.ZodString>;
-  color: z.ZodOptional<z.ZodString>;
-  title: z.ZodOptional<z.ZodString>;
-  thread_ts: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-type SlackOptions = z.infer<typeof slackOptionsSchema>;
-declare function buildSlackRequest(url: URL, message: string): Request;
-//#endregion
-//#region src/services/specialized/generic.d.ts
-declare const genericOptionsSchema: z.ZodObject<{
-  template: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-    json: "json";
-    plaintext: "plaintext";
-  }>>>;
-  method: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-}, z.core.$strip>;
-type GenericOptions = z.infer<typeof genericOptionsSchema>;
-declare function buildGenericRequest(url: URL, message: string): Request;
-//#endregion
-export { GenericOptions, Protocol, SUPPORTED_PROTOCOLS, SlackOptions, buildGenericRequest, buildSlackRequest, send };
+export { DEFAULT_EXTRACTOR, DefineProviderContext, DefineProviderOptions, Protocol, SUPPORTED_PROTOCOLS, ServiceProvider, SlackData, SlackOptions, defineProvider, jsonProvider, send, slackProvider };

package/dist/index.js

@@ -1,145 +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";
-import { z } from "zod";
 
-//#region src/utils/assert.ts
-function assert(condition, message) {
-	if (!condition) throw typeof message === "string" ? new Error(message) : message;
-}
-
-//#endregion
-//#region src/services/chat/slack.ts
-const slackOptionsSchema = z.object({
-	botname: z.string().optional(),
-	icon: z.string().optional(),
-	color: z.string().optional(),
-	title: z.string().optional(),
-	thread_ts: z.string().optional()
-});
-function isBotApiFormat(url) {
-	return url.username === "xoxb";
-}
-function isWebhookFormat(url) {
-	return url.username === "hook";
-}
-function parseBotToken(url) {
-	assert(url.password, "Bot token is required");
-	return url.password;
-}
-function parseWebhookToken(url) {
-	assert(url.password, "Webhook token is required");
-	const parts = url.password.split("-");
-	assert(parts.length === 3, "Invalid webhook token format");
-	return {
-		id: parts[0],
-		token: parts[1],
-		secret: parts[2]
-	};
-}
-function buildBotApiRequest(url, message, options) {
-	const token = parseBotToken(url);
-	const body = {
-		channel: url.hostname,
-		text: message
-	};
-	if (options.botname) body.username = options.botname;
-	if (options.icon) if (options.icon.startsWith(":") && options.icon.endsWith(":")) body.icon_emoji = options.icon;
-	else body.icon_url = options.icon;
-	if (options.thread_ts) body.thread_ts = options.thread_ts;
-	const attachments = [];
-	if (options.color || options.title) {
-		const attachment = {};
-		if (options.color) attachment.color = options.color.startsWith("%23") ? decodeURIComponent(options.color) : options.color;
-		if (options.title) attachment.title = options.title;
-		attachments.push(attachment);
-	}
-	if (attachments.length > 0) body.attachments = attachments;
-	return new Request("https://slack.com/api/chat.postMessage", {
-		method: "POST",
-		headers: {
-			"Authorization": `Bearer xoxb-${token}`,
-			"Content-Type": "application/json"
-		},
-		body: JSON.stringify(body)
-	});
-}
-function buildWebhookRequest(url, message, options) {
-	const { id, token, secret } = parseWebhookToken(url);
-	const body = { text: message };
-	if (options.botname) body.username = options.botname;
-	if (options.icon) if (options.icon.startsWith(":") && options.icon.endsWith(":")) body.icon_emoji = options.icon;
-	else body.icon_url = options.icon;
-	const attachments = [];
-	if (options.color || options.title) {
-		const attachment = {};
-		if (options.color) attachment.color = options.color.startsWith("%23") ? decodeURIComponent(options.color) : options.color;
-		if (options.title) attachment.title = options.title;
-		attachments.push(attachment);
-	}
-	if (attachments.length > 0) body.attachments = attachments;
-	return new Request(`https://hooks.slack.com/services/${id}/${token}/${secret}`, {
-		method: "POST",
-		headers: { "Content-Type": "application/json" },
-		body: JSON.stringify(body)
-	});
-}
-function buildSlackRequest(url, message) {
-	assert(url.protocol === "slack:", `Unexpected protocol ${url.protocol}`);
-	const params = new URLSearchParams(url.search);
-	const options = slackOptionsSchema.parse(Object.fromEntries(params.entries()));
-	if (isBotApiFormat(url)) return buildBotApiRequest(url, message, options);
-	if (isWebhookFormat(url)) return buildWebhookRequest(url, message, options);
-	throw new Error(`Unsupported Slack URL format: ${url.toString()}`);
-}
-
-//#endregion
-//#region src/services/specialized/generic.ts
-const genericOptionsSchema = z.object({
-	template: z.enum(["json", "plaintext"]).optional().default("json"),
-	method: z.string().optional().default("POST")
-});
-function isOptionParam(key) {
-	return !key.startsWith("@") && !key.startsWith("$");
-}
-function buildGenericRequest(url, message) {
-	assert(url.protocol === "generic:", `Unexpected protocol ${url.protocol}`);
-	const params = new URLSearchParams(url.hash.slice(1));
-	const allParamsEntries = Array.from(params.entries());
-	const optionsParams = Object.fromEntries(allParamsEntries.filter(([key]) => isOptionParam(key)));
-	const options = genericOptionsSchema.parse(optionsParams);
-	const headers = Object.fromEntries(allParamsEntries.filter(([key]) => key.startsWith("@")).map(([key, value]) => [key.slice(1), value]));
-	const dataProperties = Object.fromEntries(allParamsEntries.filter(([key]) => key.startsWith("$")).map(([key, value]) => [key.slice(1), value]));
-	const targetUrl = new URL(url.host + url.pathname);
-	return new Request(targetUrl.toString(), {
-		method: options.method,
-		headers: {
-			"Content-Type": options.template === "json" ? "application/json" : "text/plain",
-			...headers
-		},
-		body: options.template === "json" ? JSON.stringify({
-			...dataProperties,
-			message
-		}) : message
-	});
-}
-
-//#endregion
-//#region src/sender.ts
-const SUPPORTED_PROTOCOLS = ["generic:", "slack:"];
+//#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}`);
-	let req;
-	switch (_url.protocol) {
-		case "generic:":
-			req = buildGenericRequest(_url, message);
-			break;
-		case "slack:":
-			req = buildSlackRequest(_url, message);
-			break;
-		default: throw new Error(`Unsupported protocol ${_url.protocol}`);
-	}
-	await ofetch(req, options);
+	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 { SUPPORTED_PROTOCOLS, buildGenericRequest, buildSlackRequest, send };
+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.5",
+  "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"
   ],
@@ -33,12 +41,15 @@
     "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",