statocysts 0.0.4 → 0.0.5

package/dist/index.d.ts

@@ -1 +1,31 @@
-export { };
+import { FetchOptions } from "ofetch";
+import { z } from "zod";
+
+//#region src/sender.d.ts
+type Protocol = 'generic:' | 'slack:';
+declare const SUPPORTED_PROTOCOLS: string[];
+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 };

package/dist/index.js

@@ -0,0 +1,145 @@
+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:"];
+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);
+}
+
+//#endregion
+export { SUPPORTED_PROTOCOLS, buildGenericRequest, buildSlackRequest, send };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "statocysts",
   "type": "module",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "Notification library for JavaScript",
   "license": "MIT",
   "homepage": "https://github.com/octoplorer/statocysts",
@@ -32,8 +32,13 @@
   "engines": {
     "node": ">=24.12.0"
   },
+  "dependencies": {
+    "ofetch": "^1.5.1",
+    "zod": "^4.2.1"
+  },
   "devDependencies": {
     "@antfu/eslint-config": "^6.7.1",
+    "@types/node": "^25.0.2",
     "bumpp": "^10.3.2",
     "eslint": "^9.39.2",
     "eslint-plugin-format": "^1.1.0",