vicket 0.1.0 → 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,101 @@
+type TemplateOption = {
+    id: string;
+    label: string;
+    value: string;
+};
+type TemplateQuestion = {
+    id: string;
+    label: string;
+    type: "TEXT" | "TEXTAREA" | "SELECT" | "CHECKBOX" | "DATE" | "FILE";
+    required: boolean;
+    order: number;
+    options?: TemplateOption[];
+};
+type Template = {
+    id: string;
+    name: string;
+    description: string;
+    questions: TemplateQuestion[];
+};
+type Article = {
+    id: string;
+    title: string;
+    slug: string;
+    content: string;
+};
+type Faq = {
+    id: string;
+    question: string;
+    answer: string;
+};
+type SupportInitResponse = {
+    success: boolean;
+    data?: {
+        website?: {
+            name?: string;
+        };
+        templates: Template[];
+        articles?: Article[];
+        faqs?: Faq[];
+    };
+    error?: string;
+};
+type FormValues = {
+    email: string;
+    title: string;
+    answers: Record<string, unknown>;
+};
+type Attachment = {
+    id: string;
+    original_filename: string;
+    url: string;
+};
+type Message = {
+    id: string;
+    content: string;
+    author_type: "reporter" | "user" | "system";
+    created_at: string;
+    attachments?: Attachment[];
+};
+type TicketAnswer = {
+    id: string;
+    question_label: string;
+    answer: string;
+    attachments?: Attachment[];
+};
+type TicketThread = {
+    id: string;
+    title: string;
+    status?: {
+        label: string;
+    };
+    priority?: {
+        label: string;
+    };
+    messages: Message[];
+    answers?: TicketAnswer[];
+};
+declare const AUTHOR_LABELS: Record<string, string>;
+declare const initialFormValues: FormValues;
+declare function cn(...classes: (string | boolean | undefined | null)[]): string;
+declare function stripHtml(html: string): string;
+declare function sanitizeHtml(html: string): string;
+declare function formatDate(iso: string): string;
+declare function isFileAnswer(answer: string): boolean;
+declare function formatAnswerText(value: string): string;
+declare function fetchInit(): Promise<NonNullable<SupportInitResponse["data"]>>;
+declare function createTicket(body: {
+    email: string;
+    title: string;
+    templateId: string;
+    answers: Record<string, unknown>;
+    hasFiles: boolean;
+    fileQuestionIds: string[];
+}): Promise<{
+    emailLimitReached?: boolean;
+    warning?: string;
+}>;
+declare function fetchThread(token: string): Promise<TicketThread>;
+declare function sendReply(token: string, content: string, files: File[]): Promise<void>;
+
+export { AUTHOR_LABELS, type Article, type Attachment, type Faq, type FormValues, type Message, type SupportInitResponse, type Template, type TemplateOption, type TemplateQuestion, type TicketAnswer, type TicketThread, cn, createTicket, fetchInit, fetchThread, formatAnswerText, formatDate, initialFormValues, isFileAnswer, sanitizeHtml, sendReply, stripHtml };

package/dist/index.js

@@ -0,0 +1,141 @@
+// src/index.ts
+var PROXY_BASE = "/api/vicket";
+var AUTHOR_LABELS = {
+  reporter: "You",
+  user: "Support",
+  system: "System"
+};
+var initialFormValues = { email: "", title: "", answers: {} };
+function cn(...classes) {
+  return classes.filter(Boolean).join(" ");
+}
+function stripHtml(html) {
+  return html.replace(/<[^>]*>/g, "");
+}
+function sanitizeHtml(html) {
+  return html.replace(/<script[\s>][\s\S]*?<\/script>/gi, "").replace(/<iframe[\s>][\s\S]*?<\/iframe>/gi, "").replace(/on\w+\s*=\s*"[^"]*"/gi, "").replace(/on\w+\s*=\s*'[^']*'/gi, "").replace(/on\w+\s*=\s*[^\s>]*/gi, "").replace(/javascript\s*:/gi, "");
+}
+function formatDate(iso) {
+  try {
+    return new Intl.DateTimeFormat("en", {
+      month: "short",
+      day: "numeric",
+      hour: "numeric",
+      minute: "2-digit"
+    }).format(new Date(iso));
+  } catch {
+    return iso;
+  }
+}
+function isFileAnswer(answer) {
+  return answer?.includes("__isFile:true") || answer?.includes("map[__isFile");
+}
+function formatAnswerText(value) {
+  if (!value) return "";
+  const trimmed = value.trim();
+  if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    const rawItems = trimmed.slice(1, -1).trim();
+    return rawItems.length > 0 ? rawItems.split(/\s+/).join(", ") : "";
+  }
+  return value;
+}
+async function fetchInit() {
+  const response = await fetch(`${PROXY_BASE}/init`, {
+    method: "GET",
+    cache: "no-store",
+    headers: { "Content-Type": "application/json" }
+  });
+  const payload = await response.json();
+  if (!response.ok || !payload?.success || !payload?.data) {
+    throw new Error(payload?.error || "Failed to load support data.");
+  }
+  return payload.data;
+}
+async function createTicket(body) {
+  const payload = {
+    email: body.email,
+    title: body.title,
+    templateId: body.templateId,
+    answers: { ...body.answers }
+  };
+  let response;
+  if (body.hasFiles) {
+    const formData = new FormData();
+    const normalizedAnswers = {};
+    for (const [questionId, answer] of Object.entries(payload.answers)) {
+      if (answer instanceof File) {
+        formData.append(`files[${questionId}]`, answer);
+        normalizedAnswers[questionId] = "__isFile:true";
+      } else {
+        normalizedAnswers[questionId] = answer;
+      }
+    }
+    formData.append("data", JSON.stringify({ ...payload, answers: normalizedAnswers }));
+    response = await fetch(`${PROXY_BASE}/tickets`, { method: "POST", body: formData });
+  } else {
+    response = await fetch(`${PROXY_BASE}/tickets`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+  }
+  const responsePayload = await response.json();
+  if (!response.ok || !responsePayload?.success) {
+    throw new Error(responsePayload?.error || "Failed to create ticket.");
+  }
+  return {
+    emailLimitReached: responsePayload.data?.email_limit_reached ?? false,
+    warning: responsePayload.data?.warning
+  };
+}
+async function fetchThread(token) {
+  const response = await fetch(
+    `${PROXY_BASE}/ticket?token=${encodeURIComponent(token)}`,
+    { method: "GET", cache: "no-store", headers: { "Content-Type": "application/json" } }
+  );
+  const payload = await response.json();
+  if (!response.ok || !payload?.success || !payload?.data) {
+    if (payload?.error_code === "ticket-link-expired") {
+      throw new Error("This link has expired. A new secure link has been sent to your email.");
+    }
+    throw new Error(payload?.error || "Failed to load ticket.");
+  }
+  return payload.data;
+}
+async function sendReply(token, content, files) {
+  const url = `${PROXY_BASE}/ticket/messages?token=${encodeURIComponent(token)}`;
+  let response;
+  if (files.length > 0) {
+    const formData = new FormData();
+    formData.append("data", JSON.stringify({ content }));
+    for (const file of files) formData.append("files", file);
+    response = await fetch(url, { method: "POST", body: formData });
+  } else {
+    response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ content })
+    });
+  }
+  const payload = await response.json();
+  if (!response.ok || !payload?.success) {
+    if (payload?.error_code === "ticket-link-expired") {
+      throw new Error("This link has expired. A new secure link has been sent to your email.");
+    }
+    throw new Error(payload?.error || "Failed to send reply.");
+  }
+}
+export {
+  AUTHOR_LABELS,
+  cn,
+  createTicket,
+  fetchInit,
+  fetchThread,
+  formatAnswerText,
+  formatDate,
+  initialFormValues,
+  isFileAnswer,
+  sanitizeHtml,
+  sendReply,
+  stripHtml
+};

package/dist/next.d.ts

@@ -0,0 +1,10 @@
+declare function createVicketProxy(options?: {
+    apiUrl?: string;
+    apiKey?: string;
+}): (req: Request, context: {
+    params: Promise<{
+        path: string[];
+    }>;
+}) => Promise<Response>;
+
+export { createVicketProxy };

package/dist/next.js

@@ -0,0 +1,39 @@
+// src/next.ts
+function createVicketProxy(options) {
+  return async function proxy(req, context) {
+    const apiUrl = (options?.apiUrl || process.env.VICKET_API_URL || "").replace(/\/+$/, "");
+    const apiKey = options?.apiKey || process.env.VICKET_API_KEY || "";
+    if (!apiUrl || !apiKey) {
+      return Response.json(
+        { error: "Missing VICKET_API_URL or VICKET_API_KEY server environment variables." },
+        { status: 500 }
+      );
+    }
+    const { path } = await context.params;
+    const subpath = path.join("/");
+    const url = new URL(`${apiUrl}/public/support/${subpath}`);
+    const reqUrl = new URL(req.url);
+    reqUrl.searchParams.forEach((value, key) => url.searchParams.set(key, value));
+    const headers = { "X-Api-Key": apiKey };
+    const contentType = req.headers.get("content-type") || "";
+    let body = null;
+    if (req.method !== "GET" && req.method !== "HEAD") {
+      if (contentType.includes("multipart/form-data")) {
+        body = await req.blob();
+        headers["Content-Type"] = contentType;
+      } else {
+        body = await req.text();
+        headers["Content-Type"] = contentType || "application/json";
+      }
+    }
+    const upstream = await fetch(url.toString(), { method: req.method, headers, body });
+    const responseBody = await upstream.arrayBuffer();
+    return new Response(responseBody, {
+      status: upstream.status,
+      headers: { "Content-Type": upstream.headers.get("Content-Type") || "application/json" }
+    });
+  };
+}
+export {
+  createVicketProxy
+};

package/dist/server.d.ts

@@ -0,0 +1,11 @@
+import { SupportInitResponse, TicketThread } from './index.js';
+
+declare function createServerClient(options?: {
+    apiUrl?: string;
+    apiKey?: string;
+}): {
+    fetchInit: () => Promise<NonNullable<SupportInitResponse["data"]>>;
+    fetchThread: (token: string) => Promise<TicketThread>;
+};
+
+export { createServerClient };

package/dist/server.js

@@ -0,0 +1,41 @@
+// src/server.ts
+function createServerClient(options) {
+  const apiUrl = (options?.apiUrl || process.env.VICKET_API_URL || "").replace(/\/+$/, "");
+  const apiKey = options?.apiKey || process.env.VICKET_API_KEY || "";
+  async function fetchInit() {
+    if (!apiUrl || !apiKey) throw new Error("Missing VICKET_API_URL or VICKET_API_KEY.");
+    const res = await fetch(`${apiUrl}/public/support/init`, {
+      method: "GET",
+      cache: "no-store",
+      headers: { "X-Api-Key": apiKey, "Content-Type": "application/json" }
+    });
+    const payload = await res.json();
+    if (!res.ok || !payload?.success || !payload?.data) {
+      throw new Error(payload?.error || "Failed to load support data.");
+    }
+    return payload.data;
+  }
+  async function fetchThread(token) {
+    if (!apiUrl || !apiKey) throw new Error("Missing VICKET_API_URL or VICKET_API_KEY.");
+    const res = await fetch(
+      `${apiUrl}/public/support/ticket?token=${encodeURIComponent(token)}`,
+      {
+        method: "GET",
+        cache: "no-store",
+        headers: { "X-Api-Key": apiKey, "Content-Type": "application/json" }
+      }
+    );
+    const payload = await res.json();
+    if (!res.ok || !payload?.success || !payload?.data) {
+      if (payload?.error_code === "ticket-link-expired") {
+        throw new Error("This link has expired. A new secure link has been sent to your email.");
+      }
+      throw new Error(payload?.error || "Failed to load ticket.");
+    }
+    return payload.data;
+  }
+  return { fetchInit, fetchThread };
+}
+export {
+  createServerClient
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vicket",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Vicket support widget SDK",
   "type": "module",
   "exports": {
@@ -17,12 +17,15 @@
       "types": "./dist/next.d.ts"
     }
   },
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build": "tsup",
     "dev": "tsup --watch"
   },
   "devDependencies": {
+    "@types/node": "^22.0.0",
     "tsup": "^8.0.0",
     "typescript": "^5.9.0"
   },