@vanzxysenpai/baileys 0.0.0-stage → 0.0.2

package/lib/Builders/A2UI.d.ts

@@ -0,0 +1,131 @@
+export class A2UI {
+    constructor(opts25?: { [key: string]: any; 
+        catalogId?: string;
+        version?: string;
+    });
+    _version: string;
+    _catalogId: string;
+    _components: Map<any, any>;
+    _counter: number;
+    _rootChildren: any[];
+    /** Set the A2UI spec version string. */
+    setVersion(version: any): this;
+    /** Set the component catalog url. */
+    setCatalogId(catalogId: any): this;
+    text(text: any, opts1?: { [key: string]: any; 
+        variant?: string;
+    }): any;
+    image(url: any, opts2?: { [key: string]: any; 
+        fit?: string;
+    }): any;
+    /** Merge extra props into an already-registered component (Go `a2uiComponent.Extra`). Returns the id. */
+    extend(id: any, extra?: {}): any;
+    /** Component tree as plain JSON (Go `MarshalJSON`): `{ version, catalogId, components }`, with the implicit root first when `root()` was called. */
+    toJSON(): {
+        version: string;
+        catalogId: string;
+        components: any[];
+    };
+    /** Image with an explicit fit (`cover` | `none`). Same as `image(url, { fit })`. */
+    imageFit(url: any, fit: any, opts3?: { [key: string]: any; }): any;
+    /** Header-variant image for card headers (`variant: "header"`, `fit: "none"`). */
+    imageHeader(url: any, opts4?: { [key: string]: any; }): any;
+    /** `text()` with the variant as a positional argument (Go `TextVariant`). */
+    textVariant(text: any, variant: any, opts5?: { [key: string]: any; }): any;
+    /** `textField()` with the variant as a positional argument (Go `TextFieldVariant`). */
+    textFieldVariant(label: any, variant: any, opts6?: { [key: string]: any; }): any;
+    /** `choicePicker()` with `filterable: true` (Go `ChoicePickerFilterable`). */
+    choicePickerFilterable(label: any, options: any, o?: {}): any;
+    video(url: any, opts7?: { [key: string]: any; }): any;
+    checkbox(label: any, opts8?: { [key: string]: any; 
+        value?: boolean;
+    }): any;
+    textField(label: any, opts9?: { [key: string]: any; 
+        variant?: string;
+    }): any;
+    button(childId: any, opts10?: { [key: string]: any; 
+        variant?: string;
+    }): any;
+    card(childId: any, opts11?: { [key: string]: any; }): any;
+    modal(triggerId: any, contentId: any, opts12?: { [key: string]: any; }): any;
+    raw(component: any, props?: {}, opts13?: { [key: string]: any; }): any;
+    column(children?: any[], opts14?: { [key: string]: any; }): any;
+    row(children?: any[], opts15?: { [key: string]: any; }): any;
+    divider(opts26?: { [key: string]: any; }): any;
+    slider(opts27?: { [key: string]: any; 
+        value?: number;
+        min?: number;
+        max?: number;
+        step?: number;
+    }): any;
+    dateTimeInput(label: any, opts16?: { [key: string]: any; 
+        value?: string;
+        enableDate?: boolean;
+        enableTime?: boolean;
+    }): any;
+    switch(label: any, opts17?: { [key: string]: any; 
+        value?: boolean;
+    }): any;
+    list(children?: any[], opts18?: { [key: string]: any; }): any;
+    progressBar(value: any, opts19?: { [key: string]: any; 
+        min?: number;
+        max?: number;
+        variant?: string;
+    }): any;
+    avatar(url: any, opts20?: { [key: string]: any; 
+        variant?: string;
+        size?: number;
+    }): any;
+    badge(childId: any, opts21?: { [key: string]: any; }): any;
+    spacer(opts28?: { [key: string]: any; 
+        height?: number;
+    }): any;
+    tabs(items?: any[], opts22?: { [key: string]: any; 
+        activeTab?: number;
+    }): any;
+    choicePicker(label: any, options: any, opts23?: { [key: string]: any; 
+        variant?: string;
+        displayStyle?: string;
+        filterable?: boolean;
+    }): any;
+    root(children: any): this;
+    listCard(opts29?: { [key: string]: any; 
+        uuid?: any;
+    }): this;
+    _listCardPayload: {
+        uuid: any;
+        data: string;
+        type: string;
+        fallback: any;
+    };
+    send(client: any, jid: any, opts?: {}): Promise<import("../../WAProto/index.js").proto.WebMessageInfo>;
+    build(opts30?: { [key: string]: any; 
+        uuid?: any;
+        type?: string;
+        wrapped?: boolean;
+    }): {
+        uuid: any;
+        data: string;
+        type: string;
+        fallback: any;
+    } | {
+        uuid: any;
+        data: string;
+        type: string;
+    };
+    #private;
+}
+/**
+ * Build + send an A2UI/Bloks widget as an interactiveMessage.
+ * @param {import('../../WAProto/index.js').WASocket} client Active Baileys socket.
+ * @param {string} jid Destination chat/group jid.
+ */
+export function sendA2UIWidget(client: any, jid: string, opts24?: { [key: string]: any; 
+    bodyText?: string;
+    footer?: string;
+    buttons?: any[];
+    contextInfo?: {};
+    type?: string;
+    wrapped?: boolean;
+    singleScreen?: boolean;
+}): Promise<import("../../WAProto/index.js").proto.WebMessageInfo>;

package/lib/Builders/A2UI.js

@@ -0,0 +1,343 @@
+/**
+ * lib/Builders/A2UI.js — A2UI (Bloks) widget builder + sender
+ *
+ * Part of @vanzxysenpai/baileys. Builds the flat `components` array A2UI/Bloks
+ * expects (id-referencing tree: Column/Row hold `children`, Card/Button hold
+ * `child`, Modal holds `trigger`/`content`) and sends it as an
+ * `interactiveMessage.bloksWidget` via the same `getBizBinaryNode()` path
+ * Button/ButtonV2 use, so the wire-level <biz>/<native_flow> node always
+ * matches the actual button names sent — no more hand-rolled duplicate of
+ * that logic living outside the library.
+ *
+ * See Button.js's `Button.setBloksWidget()` for the declarative
+ * (nested-tree) alternative to this imperative (id-returning-factory) API;
+ * both produce the same wire format and can be mixed freely.
+ */
+"use strict";
+
+import crypto from "crypto";
+import { generateWAMessageFromContent, prepareWAMessageMedia } from "../Utils/messages.js";
+import { getBizBinaryNode } from "../WABinary/index.js";
+
+class A2UI {
+	constructor({ catalogId = "https://a2ui.org/specification/v0_9/catalogs/basic/catalog.json", version = "v0.9" } = {}) {
+		this._version = version;
+		this._catalogId = catalogId;
+		this._components = new Map();
+		this._counter = 0;
+		this._rootChildren = [];
+	}
+	/** Set the A2UI spec version string. */
+	setVersion(version) {
+		if (typeof version !== "string" || !version) throw new TypeError("setVersion(version) requires a non-empty string");
+		this._version = version;
+		return this;
+	}
+	/** Set the component catalog url. */
+	setCatalogId(catalogId) {
+		if (typeof catalogId !== "string" || !catalogId) throw new TypeError("setCatalogId(catalogId) requires a non-empty string");
+		this._catalogId = catalogId;
+		return this;
+	}
+	#nextId(prefix) {
+		return `${prefix}_${(this._counter++).toString(36)}`;
+	}
+	#reg(id, component, extra = {}) {
+		id ??= this.#nextId(component.toLowerCase());
+		if (id === "root") throw new Error(`Component id "root" is reserved for the implicit root wrapper`);
+		if (this._components.has(id)) throw new Error(`Component id "${id}" already used`);
+		this._components.set(id, { id, component, ...extra });
+		return id;
+	}
+	text(text, { id, variant = "body" } = {}) {
+		return this.#reg(id, "Text", { text, variant });
+	}
+	image(url, { id, variant, fit = "cover" } = {}) {
+		return this.#reg(id, "Image", { url, ...(variant ? { variant } : {}), fit });
+	}
+	/** Merge extra props into an already-registered component (Go `a2uiComponent.Extra`). Returns the id. */
+	extend(id, extra = {}) {
+		const c = this._components.get(id);
+		if (!c) throw new Error(`A2UI: no component registered with id "${id}"`);
+		if (!extra || typeof extra !== "object" || Array.isArray(extra)) throw new TypeError("extend(id, extra) requires a plain object");
+		Object.assign(c, extra, { id: c.id, component: c.component });
+		return id;
+	}
+	/** Component tree as plain JSON (Go `MarshalJSON`): `{ version, catalogId, components }`, with the implicit root first when `root()` was called. */
+	toJSON() {
+		const root = this._rootChildren.length ? [{ id: "root", component: "Column", children: this._rootChildren }] : [];
+		return { version: this._version, catalogId: this._catalogId, components: [...root, ...this._components.values()] };
+	}
+	/** Image with an explicit fit (`cover` | `none`). Same as `image(url, { fit })`. */
+	imageFit(url, fit, { id } = {}) {
+		return this.image(url, { id, fit });
+	}
+	/** Header-variant image for card headers (`variant: "header"`, `fit: "none"`). */
+	imageHeader(url, { id } = {}) {
+		return this.image(url, { id, variant: "header", fit: "none" });
+	}
+	/** `text()` with the variant as a positional argument (Go `TextVariant`). */
+	textVariant(text, variant, { id } = {}) {
+		return this.text(text, { id, variant });
+	}
+	/** `textField()` with the variant as a positional argument (Go `TextFieldVariant`). */
+	textFieldVariant(label, variant, { id } = {}) {
+		return this.textField(label, { id, variant });
+	}
+	/** `choicePicker()` with `filterable: true` (Go `ChoicePickerFilterable`). */
+	choicePickerFilterable(label, options, o = {}) {
+		return this.choicePicker(label, options, { ...o, filterable: true });
+	}
+	video(url, { id } = {}) {
+		return this.#reg(id, "Video", { url });
+	}
+	checkbox(label, { id, value = false } = {}) {
+		return this.#reg(id, "CheckBox", { label, value });
+	}
+	textField(label, { id, variant = "text" } = {}) {
+		return this.#reg(id, "TextField", { label, variant });
+	}
+	button(childId, { id, variant = "primary", action } = {}) {
+		if (!childId) throw new TypeError("button(childId) requires the id of a child component (e.g. from .text())");
+		return this.#reg(id, "Button", { child: childId, variant, ...(action ? { action } : {}) });
+	}
+	card(childId, { id } = {}) {
+		return this.#reg(id, "Card", { child: childId });
+	}
+	// trigger: id of the component that opens the modal (e.g. a Button); content: id of the
+	// component shown inside it. Both are ids of already-registered SIBLING components, not
+	// nested children — that's how the wire format expects Modal to reference them.
+	modal(triggerId, contentId, { id } = {}) {
+		if (!triggerId) throw new TypeError("modal(triggerId, contentId) requires the id of the trigger component");
+		if (!contentId) throw new TypeError("modal(triggerId, contentId) requires the id of the content component");
+		return this.#reg(id, "Modal", { trigger: triggerId, content: contentId });
+	}
+	// Escape hatch for any catalog component without a dedicated method yet (Divider, Slider,
+	// Switch, List, etc). props is merged as-is into the registered node.
+	raw(component, props = {}, { id } = {}) {
+		if (typeof component !== "string" || !component) throw new TypeError("raw(component, props) requires a non-empty component type string");
+		return this.#reg(id, component, props);
+	}
+	column(children = [], { id } = {}) {
+		if (!children.length) throw new TypeError("column(children) requires at least one child id");
+		return this.#reg(id, "Column", { children });
+	}
+	row(children = [], { id } = {}) {
+		if (!children.length) throw new TypeError("row(children) requires at least one child id");
+		return this.#reg(id, "Row", { children });
+	}
+	divider({ id } = {}) {
+		return this.#reg(id, "Divider", {});
+	}
+	slider({ id, value = 0, min = 0, max = 100, step = 1, label } = {}) {
+		return this.#reg(id, "Slider", { value, min, max, step, ...(label !== undefined ? { label } : {}) });
+	}
+	dateTimeInput(label, { id, value = "", enableDate = true, enableTime = false } = {}) {
+		if (typeof label !== "string" || !label) throw new TypeError("dateTimeInput(label) requires a non-empty string");
+		if (!enableDate && !enableTime) throw new TypeError("dateTimeInput needs enableDate and/or enableTime");
+		return this.#reg(id, "DateTimeInput", { label, value, enableDate, enableTime });
+	}
+	switch(label, { id, value = false } = {}) {
+		return this.#reg(id, "Switch", { label, value });
+	}
+	list(children = [], { id } = {}) {
+		if (!children.length) throw new TypeError("list(children) requires at least one child id");
+		return this.#reg(id, "List", { children });
+	}
+	progressBar(value, { id, min = 0, max = 100, variant = "linear" } = {}) {
+		if (typeof value !== "number") throw new TypeError("progressBar(value) requires a number");
+		return this.#reg(id, "ProgressBar", { value, min, max, variant });
+	}
+	avatar(url, { id, variant = "circle", size = 40 } = {}) {
+		if (!url) throw new TypeError("avatar(url) requires an image url");
+		return this.#reg(id, "Avatar", { url, variant, size });
+	}
+	badge(childId, { id, label } = {}) {
+		if (!childId) throw new TypeError("badge(childId) requires the id of a child component");
+		return this.#reg(id, "Badge", { child: childId, ...(label !== undefined ? { label } : {}) });
+	}
+	spacer({ id, height = 16 } = {}) {
+		return this.#reg(id, "Spacer", { height });
+	}
+	// tabs([{ title, child }]) -> official `tabItems` shape; tabs(["id1","id2"]) -> japofc `children` shape.
+	tabs(items = [], { id, activeTab = 0 } = {}) {
+		if (!items.length) throw new TypeError("tabs(items) requires at least one tab");
+		if (typeof items[0] === "object") {
+			for (const it of items) if (!it?.title || !it?.child) throw new TypeError("tabs(items): each item needs { title, child }");
+			return this.#reg(id, "Tabs", { tabItems: items.map(({ title, child }) => ({ title, child })) });
+		}
+		return this.#reg(id, "Tabs", { children: items, activeTab });
+	}
+	choicePicker(label, options, { id, variant = "mutuallyExclusive", value, displayStyle = "checkbox", filterable = false } = {}) {
+		if (!Array.isArray(options) || !options.length) {
+			throw new TypeError("choicePicker(label, options) requires a non-empty options array of {label, value}");
+		}
+		return this.#reg(id, "ChoicePicker", {
+			label,
+			variant,
+			...(value !== undefined ? { value } : {}),
+			options,
+			displayStyle,
+			filterable
+		});
+	}
+	root(children) {
+		if (!Array.isArray(children) || !children.length) {
+			throw new TypeError("root(children) requires a non-empty array of top-level component ids");
+		}
+		this._rootChildren = children;
+		return this;
+	}
+	listCard({ title, items, fallbackText, uuid = crypto.randomUUID() } = {}) {
+		if (!title) throw new TypeError("listCard requires a title");
+		if (!Array.isArray(items) || !items.length) {
+			throw new TypeError("listCard requires a non-empty items array");
+		}
+		this._listCardPayload = {
+			uuid,
+			data: JSON.stringify({
+				type: "list_card",
+				title,
+				fallback_text: fallbackText ?? "",
+				items: items.map((it) => ({
+					asset_id: it.assetId ?? crypto.randomUUID().replace(/-/g, "").slice(0, 17),
+					asset_type: it.assetType ?? "PRODUCT_ITEM",
+					title: it.title,
+					trailing_label: it.price ?? it.trailingLabel ?? "",
+					trailing_emphasis: it.emphasis ?? "strong"
+				}))
+			}),
+			type: "im_a2ui",
+			fallback: fallbackText ?? ""
+		};
+		return this;
+	}
+	async send(client, jid, opts = {}) {
+		return sendA2UIWidget(client, jid, { ...opts, a2ui: this });
+	}
+	#validateRefs(components) {
+		const validIds = new Set(components.map((c) => c.id));
+		for (const c of components) {
+			for (const key of ["child", "trigger", "content"]) {
+				if (c[key] !== undefined && !validIds.has(c[key])) {
+					throw new Error(`A2UI: component "${c.id}" (${c.component}) references unknown id "${c[key]}" via "${key}"`);
+				}
+			}
+			if (Array.isArray(c.tabItems)) {
+				for (const t of c.tabItems) {
+					if (!validIds.has(t.child)) throw new Error(`A2UI: component "${c.id}" (${c.component}) references unknown id "${t.child}" in "tabItems"`);
+				}
+			}
+			if (Array.isArray(c.children)) {
+				for (const childId of c.children) {
+					if (!validIds.has(childId)) {
+						throw new Error(`A2UI: component "${c.id}" (${c.component}) references unknown id "${childId}" in "children"`);
+					}
+				}
+			}
+		}
+	}
+	build({ uuid = crypto.randomUUID(), surfaceId, type = "im_a2ui", wrapped = true } = {}) {
+		if (this._listCardPayload) return this._listCardPayload;
+		if (!this._rootChildren.length) throw new Error("Call root([...ids]) before build()");
+		const root = { id: "root", component: "Column", children: this._rootChildren };
+		const components = [root, ...this._components.values()];
+		this.#validateRefs(components);
+		const data = wrapped
+			? {
+					version: this._version,
+					createSurface: {
+						surfaceId: surfaceId ?? `starcore-widget=${uuid}`,
+						catalogId: this._catalogId,
+						components
+					}
+				}
+			: { components };
+		return {
+			uuid,
+			data: JSON.stringify(data),
+			type
+		};
+	}
+}
+
+/**
+ * Build + send an A2UI/Bloks widget as an interactiveMessage.
+ * @param {import('../../WAProto/index.js').WASocket} client Active Baileys socket.
+ * @param {string} jid Destination chat/group jid.
+ */
+async function sendA2UIWidget(client, jid, {
+	a2ui,
+	bodyText = "",
+	footer = "",
+	buttons = [],
+	contextInfo = {},
+	expiration,
+	quoted,
+	type = "im_a2ui",
+	wrapped = true,
+	singleScreen = false,
+	header
+} = {}) {
+	if (!client) throw new Error("Socket is required");
+	if (!(a2ui instanceof A2UI)) throw new TypeError("a2ui must be an A2UI instance");
+
+	const nativeFlowMessage = buttons && buttons.length
+		? {
+				buttons: buttons.map((b) => ({
+					name: b.name ?? "cta_url",
+					buttonParamsJson: typeof b.params === "string" ? b.params : JSON.stringify(b.params ?? {}),
+				})),
+				messageParamsJson: "{}",
+				messageVersion: 1
+			}
+		: { messageParamsJson: "" };
+
+	const headerMediaData = header?.image
+		? { image: header.image }
+		: header?.video
+			? { video: header.video }
+			: header?.document
+				? { document: header.document }
+				: null;
+
+	const headerBlock = {
+		...(header?.title !== undefined ? { title: header.title } : {}),
+		...(header?.subtitle !== undefined ? { subtitle: header.subtitle } : {}),
+		hasMediaAttachment: !!headerMediaData,
+		...(headerMediaData
+			? await prepareWAMessageMedia(headerMediaData, { upload: client.waUploadToServer }).catch((e) => {
+					if (String(e).includes("Invalid media type")) return headerMediaData;
+					throw e;
+				})
+			: {})
+	};
+
+	const interactiveMessage = singleScreen
+		? {
+				nativeFlowMessage,
+				bloksWidget: a2ui.build({ type, wrapped }),
+				...(expiration || Object.keys(contextInfo).length ? { contextInfo: { ...(expiration ? { expiration } : {}), ...contextInfo } } : {})
+			}
+		: {
+				header: headerBlock,
+				body: { text: bodyText },
+				...(footer ? { footer: { text: footer } } : {}),
+				nativeFlowMessage,
+				bloksWidget: a2ui.build({ type, wrapped }),
+				...(expiration || Object.keys(contextInfo).length ? { contextInfo: { ...(expiration ? { expiration } : {}), ...contextInfo } } : {})
+			};
+
+	const msg = generateWAMessageFromContent(jid, {
+		messageContextInfo: { messageSecret: crypto.randomBytes(32) },
+		interactiveMessage
+	}, { quoted });
+
+	await client.relayMessage(msg.key.remoteJid, msg.message, {
+		messageId: msg.key.id,
+		additionalNodes: [getBizBinaryNode(msg.message)]
+	});
+	return msg;
+}
+
+export { A2UI, sendA2UIWidget };