talizen 0.1.3 → 0.1.4

package/README.md

@@ -14,78 +14,89 @@ The package is designed to hold the platform-level APIs that frontend projects u
 npm install talizen
 ```
 
+or use esm.sh
+
+```
+{
+  "imports": {
+    "talizen": "https://esm.sh/talizen@0.1.4"
+    "talizen/": "https://esm.sh/talizen@0.1.4/"
+  }
+}
+```
+
 ## Usage
 
 ### Configure the client
 
 ```ts
-import { setTalizenConfig } from "talizen/core"
+import { setTalizenConfig } from "talizen/core";
 
 setTalizenConfig({
   baseUrl: "https://www.talizen.com",
   onFileUploadProcess(key, process) {
-    console.log(key, process)
+    console.log(key, process);
   },
-})
+});
 ```
 
 ### List CMS content
 
 ```ts
-import { listContents, type BaseCmsItem } from "talizen/cms"
+import { listContents, type BaseCmsItem } from "talizen/cms";
 
 interface Blog extends BaseCmsItem {
-  readonly __cmsKey: "blogs"
+  readonly __cmsKey: "blogs";
   body: {
-    title?: string
-    content?: string
-  }
+    title?: string;
+    content?: string;
+  };
 }
 
 const result = await listContents<Blog>("blogs", {
   limit: 10,
   orderBy: "-created_at",
-})
+});
 
-console.log(result.list)
-console.log(result.total)
+console.log(result.list);
+console.log(result.total);
 ```
 
 ### Get a single CMS content item
 
 ```ts
-import { getContent, type BaseCmsItem } from "talizen/cms"
+import { getContent, type BaseCmsItem } from "talizen/cms";
 
 interface Blog extends BaseCmsItem {
-  readonly __cmsKey: "blogs"
+  readonly __cmsKey: "blogs";
   body: {
-    title?: string
-  }
+    title?: string;
+  };
 }
 
-const blog = await getContent<Blog>("blogs", "hello-world")
+const blog = await getContent<Blog>("blogs", "hello-world");
 ```
 
 ### Get CMS collection metadata
 
 ```ts
-import { getContentCollection } from "talizen/cms"
+import { getContentCollection } from "talizen/cms";
 
-const collection = await getContentCollection("blogs")
+const collection = await getContentCollection("blogs");
 
-console.log(collection?.title)
-console.log(collection?.jsonSchema)
+console.log(collection?.title);
+console.log(collection?.jsonSchema);
 ```
 
 ### Submit a form
 
 ```ts
-import { submitForm } from "talizen/form"
+import { submitForm } from "talizen/form";
 
 await submitForm("contact-form", {
   email: "hi@talizen.com",
   message: "Hello from the website",
-})
+});
 ```
 
 When a `File` object appears in the payload, `submitForm()` will:
@@ -118,3 +129,21 @@ git tag v0.0.8
 git push origin main
 git push origin v0.0.8
 ```
+
+## Development
+
+```bash
+bun run dev
+```
+
+This will build the package and start a development server at http://localhost:8787.
+
+Use the development server in your project:
+
+```json
+{
+  "imports": {
+    "talizen/form": "http://localhost:8787/form.js"
+  }
+}
+```

package/captcha-ui.d.ts

@@ -0,0 +1,37 @@
+export interface CaptchaChallenge {
+    token: string;
+    type: "slide";
+    master_img: string;
+    tile_img: string;
+    width: number;
+    height: number;
+    tile_width: number;
+    tile_height: number;
+    tile_x: number;
+    tile_y: number;
+}
+export interface CaptchaUiTheme {
+    zIndex?: number;
+    width?: number;
+    title?: string;
+    subtitle?: string;
+    cancelText?: string;
+    sliderText?: string;
+    retryText?: string;
+}
+export interface CaptchaVerifyResult {
+    token: string;
+    x: number;
+    y: number;
+}
+export interface CaptchaVerificationFlowOptions<T> {
+    initialCaptcha: CaptchaChallenge;
+    refreshCaptcha: () => Promise<CaptchaChallenge>;
+    signal?: AbortSignal;
+    shouldRetry: (error: unknown) => boolean;
+    theme?: CaptchaUiTheme;
+    verify: (result: CaptchaVerifyResult) => Promise<T>;
+}
+export declare function shouldRetryCaptchaSubmit(error: unknown, shouldTriggerCaptcha: (error: unknown) => boolean): boolean;
+export declare function buildCaptchaAnswer(x: number, y: number): string;
+export declare function runCaptchaVerification<T>(options: CaptchaVerificationFlowOptions<T>): Promise<T>;

package/captcha-ui.js

@@ -0,0 +1,404 @@
+import { TalizenHttpError } from "./core.js";
+export function shouldRetryCaptchaSubmit(error, shouldTriggerCaptcha) {
+    if (shouldTriggerCaptcha(error)) {
+        return true;
+    }
+    if (!(error instanceof TalizenHttpError)) {
+        return false;
+    }
+    if (isCaptchaErrorBody(error)) {
+        return true;
+    }
+    return error.status >= 400 && error.status < 500;
+}
+export function buildCaptchaAnswer(x, y) {
+    return JSON.stringify({ x, y });
+}
+export function runCaptchaVerification(options) {
+    if (typeof document === "undefined") {
+        throw new Error("Talizen captcha UI requires browser DOM support.");
+    }
+    if (options.signal?.aborted) {
+        throw createAbortError();
+    }
+    return new Promise((resolve, reject) => {
+        const dialogTheme = resolveCaptchaDialogTheme(options.initialCaptcha, options.theme);
+        const elements = createCaptchaDialogElements(options.initialCaptcha, dialogTheme);
+        const { host, tile, slider, errorText, cancelButton } = elements;
+        let currentCaptcha = options.initialCaptcha;
+        let settled = false;
+        let verifying = false;
+        document.body.append(host);
+        const cleanup = () => {
+            host.removeEventListener("click", handleBackdropClick);
+            document.removeEventListener("keydown", handleKeydown);
+            slider.removeEventListener("input", updateTilePosition);
+            slider.removeEventListener("change", submit);
+            cancelButton.removeEventListener("click", cancel);
+            options.signal?.removeEventListener("abort", abort);
+            host.remove();
+        };
+        const settle = (callback) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            cleanup();
+            callback();
+        };
+        const updateTilePosition = () => {
+            tile.style.left = `${getSliderValue(slider)}px`;
+            setCaptchaErrorText(errorText);
+        };
+        const submit = async () => {
+            if (verifying) {
+                return;
+            }
+            verifying = true;
+            const x = getSliderValue(slider);
+            setCaptchaDialogDisabled(elements, true);
+            try {
+                const result = await options.verify({ token: currentCaptcha.token, x, y: currentCaptcha.tile_y });
+                settle(() => resolve(result));
+            }
+            catch (error) {
+                if (!options.shouldRetry(error)) {
+                    settle(() => reject(error));
+                    return;
+                }
+                try {
+                    currentCaptcha = await options.refreshCaptcha();
+                    updateCaptchaDialogCaptcha(elements, currentCaptcha, dialogTheme);
+                    setCaptchaErrorText(errorText, dialogTheme.retryText);
+                }
+                catch (refreshError) {
+                    settle(() => reject(refreshError));
+                    return;
+                }
+            }
+            finally {
+                verifying = false;
+                if (!settled) {
+                    setCaptchaDialogDisabled(elements, false);
+                    slider.focus();
+                }
+            }
+        };
+        const cancel = () => {
+            settle(() => reject(new Error("Talizen captcha verification was cancelled by user.")));
+        };
+        const abort = () => {
+            settle(() => reject(createAbortError()));
+        };
+        const handleBackdropClick = (event) => {
+            if (event.target === host) {
+                cancel();
+            }
+        };
+        const handleKeydown = (event) => {
+            if (event.key === "Escape") {
+                cancel();
+            }
+        };
+        slider.addEventListener("input", updateTilePosition);
+        slider.addEventListener("change", submit);
+        host.addEventListener("click", handleBackdropClick);
+        document.addEventListener("keydown", handleKeydown);
+        cancelButton.addEventListener("click", cancel);
+        options.signal?.addEventListener("abort", abort, { once: true });
+        updateTilePosition();
+        slider.focus();
+    });
+}
+function isCaptchaErrorBody(error) {
+    const code = String(error.bodyJson?.code ?? "").toLowerCase();
+    const message = String(error.bodyJson?.message ?? "").toLowerCase();
+    const body = error.body.toLowerCase();
+    return code.includes("captcha")
+        || code.includes("verify")
+        || message.includes("captcha")
+        || message.includes("验证")
+        || body.includes("captcha")
+        || body.includes("验证");
+}
+function resolveCaptchaDialogTheme(captcha, theme) {
+    const localeText = getCaptchaLocaleText();
+    return {
+        zIndex: theme?.zIndex ?? 9999,
+        hasCustomWidth: theme?.width != null,
+        width: theme?.width ?? getDefaultCaptchaDialogWidth(captcha),
+        title: theme?.title ?? localeText.title,
+        subtitle: theme?.subtitle ?? localeText.subtitle,
+        cancelText: theme?.cancelText ?? localeText.cancelText,
+        sliderText: theme?.sliderText ?? localeText.sliderText,
+        retryText: theme?.retryText ?? localeText.retryText,
+    };
+}
+function createCaptchaDialogElements(captcha, theme) {
+    const host = createStyledElement("div", {
+        position: "fixed",
+        inset: "0",
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        background: "rgba(0, 0, 0, 0.4)",
+        zIndex: String(theme.zIndex),
+    });
+    const sliderClassName = "talizen-captcha-slider";
+    const sliderStyle = createCaptchaSliderStyle(sliderClassName);
+    const panel = createStyledElement("div", {
+        width: `${theme.width}px`,
+        maxWidth: "calc(100vw - 32px)",
+        background: "#ffffff",
+        borderRadius: "18px",
+        padding: "16px",
+        boxSizing: "border-box",
+        boxShadow: "0 24px 60px rgba(15,23,42,0.24)",
+        color: "#111827",
+    });
+    const title = createStyledElement("div", {
+        fontSize: "18px",
+        lineHeight: "26px",
+        fontWeight: "700",
+        marginBottom: "4px",
+    }, theme.title);
+    const subtitle = createStyledElement("div", {
+        fontSize: "14px",
+        lineHeight: "22px",
+        fontWeight: "600",
+        color: "#6b7280",
+        marginBottom: "12px",
+    }, theme.subtitle);
+    const stage = createCaptchaStage(captcha);
+    const sliderLabel = createStyledElement("div", {
+        fontSize: "14px",
+        lineHeight: "20px",
+        fontWeight: "600",
+        color: "#6b7280",
+        marginBottom: "8px",
+    }, theme.sliderText);
+    const slider = createCaptchaSlider(captcha, sliderClassName);
+    const errorText = createStyledElement("div", {
+        display: "none",
+        flex: "1",
+        fontSize: "13px",
+        lineHeight: "20px",
+        fontWeight: "500",
+        color: "#ef4444",
+    });
+    const actions = createStyledElement("div", {
+        display: "flex",
+        alignItems: "center",
+        gap: "12px",
+        justifyContent: "flex-start",
+        marginTop: "8px",
+    });
+    const cancelButton = createStyledElement("button", {
+        padding: "10px 18px",
+        border: "1px solid #e5e7eb",
+        background: "#ffffff",
+        borderRadius: "12px",
+        boxShadow: "0 1px 2px rgba(15,23,42,0.08)",
+        color: "#111827",
+        fontSize: "15px",
+        lineHeight: "20px",
+        fontWeight: "600",
+        cursor: "pointer",
+        marginLeft: "auto",
+    }, theme.cancelText);
+    cancelButton.type = "button";
+    actions.append(errorText, cancelButton);
+    panel.append(title, subtitle, stage.host, sliderLabel, slider, actions);
+    host.append(sliderStyle, panel);
+    return {
+        baseImage: stage.baseImage,
+        host,
+        panel,
+        stage: stage.host,
+        tile: stage.tile,
+        slider,
+        errorText,
+        cancelButton,
+    };
+}
+function createCaptchaStage(captcha) {
+    const host = createStyledElement("div", {
+        position: "relative",
+        width: `${captcha.width}px`,
+        height: `${captcha.height}px`,
+        maxWidth: "100%",
+        margin: "0 0 12px",
+        borderRadius: "12px",
+        overflow: "hidden",
+        background: "#f5f5f5",
+    });
+    const baseImage = createStyledElement("img", {
+        width: "100%",
+        height: "100%",
+        objectFit: "cover",
+    });
+    baseImage.src = captcha.master_img;
+    baseImage.draggable = false;
+    const tile = createStyledElement("img", {
+        position: "absolute",
+        top: `${captcha.tile_y}px`,
+        left: "0px",
+        width: `${captcha.tile_width}px`,
+        height: `${captcha.tile_height}px`,
+        pointerEvents: "none",
+    });
+    tile.src = captcha.tile_img;
+    tile.draggable = false;
+    host.append(baseImage, tile);
+    return { baseImage, host, tile };
+}
+function createCaptchaSlider(captcha, className) {
+    const slider = createStyledElement("input", {
+        width: "100%",
+        display: "block",
+        margin: "0",
+    });
+    slider.type = "range";
+    slider.className = className;
+    slider.min = "0";
+    slider.max = String(Math.max(0, captcha.width - captcha.tile_width));
+    slider.value = "0";
+    return slider;
+}
+function createCaptchaSliderStyle(className) {
+    const style = document.createElement("style");
+    style.textContent = `
+    .${className} {
+      appearance: none;
+      -webkit-appearance: none;
+      height: 40px;
+      background: transparent;
+      cursor: pointer;
+    }
+    .${className}:focus {
+      outline: none;
+    }
+    .${className}::-webkit-slider-runnable-track {
+      height: 12px;
+      border: 1px solid #d1d5db;
+      border-radius: 999px;
+      background: #f9fafb;
+      box-shadow: inset 0 1px 2px rgba(15,23,42,0.08);
+    }
+    .${className}::-webkit-slider-thumb {
+      -webkit-appearance: none;
+      width: 30px;
+      height: 30px;
+      margin-top: -10px;
+      border: 3px solid #ffffff;
+      border-radius: 999px;
+      background: #1677ff;
+      box-shadow: 0 4px 12px rgba(22,119,255,0.35);
+    }
+    .${className}::-moz-range-track {
+      height: 12px;
+      border: 1px solid #d1d5db;
+      border-radius: 999px;
+      background: #f9fafb;
+      box-shadow: inset 0 1px 2px rgba(15,23,42,0.08);
+    }
+    .${className}::-moz-range-thumb {
+      width: 24px;
+      height: 24px;
+      border: 3px solid #ffffff;
+      border-radius: 999px;
+      background: #1677ff;
+      box-shadow: 0 4px 12px rgba(22,119,255,0.35);
+    }
+    .${className}:disabled {
+      cursor: wait;
+      opacity: 0.72;
+    }
+  `;
+    return style;
+}
+function createStyledElement(tagName, styles, text) {
+    const element = document.createElement(tagName);
+    Object.assign(element.style, styles);
+    if (text != null) {
+        element.textContent = text;
+    }
+    return element;
+}
+function updateCaptchaDialogCaptcha(elements, captcha, theme) {
+    if (!theme.hasCustomWidth) {
+        elements.panel.style.width = `${getDefaultCaptchaDialogWidth(captcha)}px`;
+    }
+    elements.stage.style.width = `${captcha.width}px`;
+    elements.stage.style.height = `${captcha.height}px`;
+    elements.baseImage.src = captcha.master_img;
+    elements.tile.src = captcha.tile_img;
+    elements.tile.style.top = `${captcha.tile_y}px`;
+    elements.tile.style.left = "0px";
+    elements.tile.style.width = `${captcha.tile_width}px`;
+    elements.tile.style.height = `${captcha.tile_height}px`;
+    elements.slider.max = String(Math.max(0, captcha.width - captcha.tile_width));
+    elements.slider.value = "0";
+}
+function getDefaultCaptchaDialogWidth(captcha) {
+    return Math.max(captcha.width + 32, 320);
+}
+function setCaptchaDialogDisabled(elements, disabled) {
+    elements.slider.disabled = disabled;
+}
+function setCaptchaErrorText(element, message = "") {
+    element.textContent = message;
+    element.style.display = message === "" ? "none" : "block";
+}
+function getSliderValue(slider) {
+    return clampNumber(toSafeNumber(slider.value), toSafeNumber(slider.min), toSafeNumber(slider.max));
+}
+function toSafeNumber(value) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function clampNumber(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+function getCaptchaLocaleText() {
+    const languages = typeof navigator === "undefined"
+        ? []
+        : [navigator.language, ...(navigator.languages ?? [])]
+            .filter((item) => typeof item === "string" && item !== "")
+            .map((item) => item.toLowerCase());
+    for (const language of languages) {
+        if (language.startsWith("en")) {
+            return {
+                title: "Complete security verification",
+                subtitle: "Drag the slider to move the puzzle into place",
+                cancelText: "Cancel",
+                sliderText: "Drag the slider to complete the puzzle",
+                retryText: "Verification failed, please try again.",
+            };
+        }
+        if (language.startsWith("zh")) {
+            return {
+                title: "请完成安全验证",
+                subtitle: "拖动滑块，将拼图移动到正确位置",
+                cancelText: "取消",
+                sliderText: "向右拖动滑块完成拼图",
+                retryText: "验证失败，请重试。",
+            };
+        }
+    }
+    return {
+        title: "Complete security verification",
+        subtitle: "Drag the slider to move the puzzle into place",
+        cancelText: "Cancel",
+        sliderText: "Drag the slider to complete the puzzle",
+        retryText: "Verification failed, please try again.",
+    };
+}
+function createAbortError() {
+    if (typeof DOMException === "function") {
+        return new DOMException("The operation was aborted.", "AbortError");
+    }
+    const error = new Error("The operation was aborted.");
+    error.name = "AbortError";
+    return error;
+}

package/core.d.ts

@@ -21,10 +21,21 @@ export interface TalizenClientConfig {
 export interface TalizenRequestOptions extends TalizenClientConfig {
     signal?: AbortSignal;
 }
+export interface TalizenErrorBody {
+    code?: number | string;
+    message?: string;
+}
 export declare function setTalizenConfig(config: TalizenClientConfig): void;
 export declare function getTalizenConfig(): TalizenClientConfig;
 declare global {
     var TalizenConfig: TalizenClientConfig | undefined;
 }
 export declare function resolveTalizenConfig(config?: TalizenRequestOptions): Required<Pick<TalizenClientConfig, "baseUrl" | "fetch">> & TalizenRequestOptions;
+export declare class TalizenHttpError extends Error {
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: string;
+    readonly bodyJson: TalizenErrorBody | undefined;
+    constructor(status: number, statusText: string, body: string, bodyJson?: TalizenErrorBody);
+}
 export declare function requestJson<T>(path: string, init?: RequestInit, config?: TalizenRequestOptions): Promise<T>;

package/core.js

@@ -33,6 +33,20 @@ function buildTalizenUrl(path, config) {
     const resolved = resolveTalizenConfig(config);
     return joinUrl(resolved.baseUrl, path);
 }
+export class TalizenHttpError extends Error {
+    status;
+    statusText;
+    body;
+    bodyJson;
+    constructor(status, statusText, body, bodyJson) {
+        super(`Talizen request failed: ${status} ${statusText} ${body}`.trim());
+        this.name = "TalizenHttpError";
+        this.status = status;
+        this.statusText = statusText;
+        this.body = body;
+        this.bodyJson = bodyJson;
+    }
+}
 export async function requestJson(path, init, config) {
     const resolved = resolveTalizenConfig(config);
     const headers = new Headers(resolved.headers ?? {});
@@ -51,7 +65,8 @@ export async function requestJson(path, init, config) {
     });
     if (!response.ok) {
         const text = await response.text();
-        throw new Error(`Talizen request failed: ${response.status} ${response.statusText} ${text}`.trim());
+        const bodyJson = parseTalizenErrorBody(text);
+        throw new TalizenHttpError(response.status, response.statusText, text, bodyJson);
     }
     const text = await response.text();
     if (text === "") {
@@ -71,3 +86,29 @@ function getDefaultFetch() {
     }
     throw new Error("Talizen fetch implementation is required in the current runtime.");
 }
+function parseTalizenErrorBody(body) {
+    if (body === "") {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(body);
+        if (isTalizenErrorBody(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+function isTalizenErrorBody(value) {
+    if (typeof value !== "object" || value == null) {
+        return false;
+    }
+    const record = value;
+    const code = record.code;
+    const message = record.message;
+    const isCodeValid = code === undefined || typeof code === "number" || typeof code === "string";
+    const isMessageValid = message === undefined || typeof message === "string";
+    return isCodeValid && isMessageValid;
+}

package/form.d.ts

@@ -1,6 +1,19 @@
+import { type CaptchaChallenge, type CaptchaUiTheme } from "./captcha-ui.js";
 import { type TalizenRequestOptions } from "./core.js";
+export type { CaptchaChallenge as FormCaptcha, CaptchaUiTheme as FormCaptchaUiTheme } from "./captcha-ui.js";
 export interface FormRecord {
     readonly __formKey?: string;
     [key: string]: unknown;
 }
-export declare function submitForm<T extends FormRecord>(keyOrToken: T["__formKey"] | string, payload: T, options?: TalizenRequestOptions): Promise<"ok">;
+export interface SubmitFormOptions extends TalizenRequestOptions {
+    captchaToken?: string;
+    captchaAnswer?: string;
+    captchaX?: number;
+    captchaY?: number;
+}
+export interface SubmitFormWithCaptchaOptions extends SubmitFormOptions {
+    shouldTriggerCaptcha?: (error: unknown) => boolean;
+    captchaUiTheme?: CaptchaUiTheme;
+}
+export declare function submitForm<T extends FormRecord>(keyOrToken: T["__formKey"] | string, payload: T, options?: SubmitFormWithCaptchaOptions): Promise<"ok">;
+export declare function getFormCaptcha(keyOrToken: string, options?: TalizenRequestOptions): Promise<CaptchaChallenge>;

package/form.js

@@ -1,14 +1,58 @@
-import { requestJson, resolveTalizenConfig } from "./core.js";
+import { buildCaptchaAnswer, runCaptchaVerification, shouldRetryCaptchaSubmit, } from "./captcha-ui.js";
+import { requestJson, resolveTalizenConfig, TalizenHttpError } from "./core.js";
 export async function submitForm(keyOrToken, payload, options) {
     const formKey = getFormKey(keyOrToken);
     const data = await replaceFiles(formKey, payload, "", options);
+    try {
+        return await submitFormRequest(formKey, data, options);
+    }
+    catch (error) {
+        if (!shouldShowCaptcha(error, options)) {
+            throw error;
+        }
+    }
+    return runCaptchaVerification({
+        initialCaptcha: await getFormCaptcha(formKey, options),
+        signal: options?.signal,
+        theme: options?.captchaUiTheme,
+        refreshCaptcha: () => getFormCaptcha(formKey, options),
+        shouldRetry: (error) => shouldRetryCaptchaSubmit(error, (item) => shouldShowCaptcha(item, options)),
+        verify: (result) => submitFormRequest(formKey, data, {
+            ...options,
+            captchaToken: result.token,
+            captchaAnswer: buildCaptchaAnswer(result.x, result.y),
+            captchaX: result.x,
+            captchaY: result.y,
+        }),
+    });
+}
+function submitFormRequest(formKey, data, options) {
     return requestJson(`/form/${formKey}/submit`, {
         method: "POST",
         body: JSON.stringify({
             data,
+            captcha_token: options?.captchaToken,
+            captcha_answer: options?.captchaAnswer,
+            captcha_x: options?.captchaX,
+            captcha_y: options?.captchaY,
         }),
     }, options);
 }
+export async function getFormCaptcha(keyOrToken, options) {
+    const formKey = getFormKey(keyOrToken);
+    return requestJson(`/form/${formKey}/captcha`, {
+        method: "GET",
+    }, options);
+}
+function shouldShowCaptcha(error, options) {
+    return (options?.shouldTriggerCaptcha ?? isCaptchaRequiredError)(error);
+}
+function isCaptchaRequiredError(error) {
+    return error instanceof TalizenHttpError && isCaptchaRequiredCode(error.bodyJson?.code);
+}
+function isCaptchaRequiredCode(code) {
+    return code === 428 || code === "428";
+}
 function getFormKey(keyOrToken) {
     if (keyOrToken == null || keyOrToken === "") {
         throw new Error("Talizen form key is required.");

package/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./core.js";
 export * from "./cms.js";
+export * from "./captcha-ui.js";
 export * from "./form.js";
 type OneOrMany<T> = T | Array<T>;
 export interface MetadataTitle {

package/index.js

@@ -1,3 +1,4 @@
 export * from "./core.js";
 export * from "./cms.js";
+export * from "./captcha-ui.js";
 export * from "./form.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talizen",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Talizen frontend SDK types for cms, form and core.",
   "type": "module",
   "license": "MIT",
@@ -20,6 +20,10 @@
       "types": "./cms.d.ts",
       "import": "./cms.js"
     },
+    "./captcha-ui": {
+      "types": "./captcha-ui.d.ts",
+      "import": "./captcha-ui.js"
+    },
     "./form": {
       "types": "./form.d.ts",
       "import": "./form.js"