fauna-api 1.0.783 → 1.0.786

package/dist/src/ui/tokenized.js

@@ -49,6 +49,8 @@ export function createTokenizedInput(container, options = {}) {
             }
             else if (node.nodeType === Node.ELEMENT_NODE) {
                 const el = node;
+                if (el.classList.contains('tokenized-ghost'))
+                    return;
                 if (el.classList.contains('tokenized-token')) {
                     parts.push({
                         kind: 'token',
@@ -328,8 +330,49 @@ export function createTokenizedInput(container, options = {}) {
             clearTimeout(suggestTimer);
         suggestTimer = setTimeout(() => runSuggest(query), 120);
     }
+    // ── Suggested ending ──
+    let ghostEl = null;
+    function clearGhost() {
+        ghostEl?.remove();
+        ghostEl = null;
+    }
+    function caretAtEnd() {
+        const sel = window.getSelection();
+        if (!sel || sel.rangeCount === 0 || !editor.contains(sel.anchorNode))
+            return false;
+        const after = document.createRange();
+        after.selectNodeContents(editor);
+        after.setStart(sel.getRangeAt(0).endContainer, sel.getRangeAt(0).endOffset);
+        const rest = after.cloneContents();
+        rest.querySelectorAll('.tokenized-ghost').forEach((g) => g.remove());
+        return (rest.textContent ?? '').replace(/\u200B/g, '') === '';
+    }
+    function placeCaretAtEnd() {
+        const range = document.createRange();
+        range.selectNodeContents(editor);
+        range.collapse(false);
+        const sel = window.getSelection();
+        sel?.removeAllRanges();
+        sel?.addRange(range);
+    }
+    function acceptGhost() {
+        const text = ghostEl?.textContent ?? '';
+        clearGhost();
+        if (!text)
+            return;
+        const lines = text.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i])
+                editor.appendChild(document.createTextNode(lines[i]));
+            if (i < lines.length - 1)
+                editor.appendChild(document.createElement('br'));
+        }
+        placeCaretAtEnd();
+        fireInput();
+    }
     // ── Input events ──
     editor.addEventListener('input', () => {
+        clearGhost();
         fireInput();
         if (activeTrigger) {
             const query = getTriggerQuery();
@@ -342,6 +385,19 @@ export function createTokenizedInput(container, options = {}) {
         }
     });
     editor.addEventListener('keydown', (e) => {
+        // A suggested ending: Tab takes it, Shift+Tab or Escape drops it
+        if (ghostEl) {
+            if (e.key === 'Tab' && !e.shiftKey) {
+                e.preventDefault();
+                acceptGhost();
+                return;
+            }
+            if (e.key === 'Escape' || e.key === 'Tab') {
+                e.preventDefault();
+                clearGhost();
+                return;
+            }
+        }
         // Suggestion navigation
         if (suggestionsEl.style.display !== 'none' && suggestionItems.length > 0) {
             if (e.key === 'ArrowDown') {
@@ -435,6 +491,7 @@ export function createTokenizedInput(container, options = {}) {
         }
     });
     editor.addEventListener('blur', () => {
+        clearGhost();
         // Delay to allow mousedown on suggestions
         setTimeout(() => {
             if (!suggestionsEl.matches(':hover')) {
@@ -457,6 +514,20 @@ export function createTokenizedInput(container, options = {}) {
     });
     // ── Public API ──
     return {
+        setGhost(text) {
+            clearGhost();
+            if (!text || !caretAtEnd())
+                return;
+            ghostEl = document.createElement('span');
+            ghostEl.className = 'tokenized-ghost';
+            ghostEl.contentEditable = 'false';
+            ghostEl.textContent = text;
+            ghostEl.dataset.hint = 'Tab';
+            editor.appendChild(ghostEl);
+        },
+        atEnd() {
+            return caretAtEnd();
+        },
         getParts() {
             return parseParts();
         },
@@ -464,6 +535,7 @@ export function createTokenizedInput(container, options = {}) {
             return serializeText(parseParts());
         },
         setParts(parts) {
+            clearGhost();
             editor.innerHTML = '';
             for (const part of parts) {
                 if (part.kind === 'text') {
@@ -487,6 +559,7 @@ export function createTokenizedInput(container, options = {}) {
             insertTokenAtCaret(token);
         },
         clear() {
+            clearGhost();
             editor.innerHTML = '';
             hideSuggestions();
             fireInput();

package/dist/src/ui/ui.css

@@ -435,6 +435,25 @@
     color: var(--chat-text, inherit);
 }
 .chat-message-text > :first-child { margin-top: 0; }
+
+/* An HTML body (an email's), drawn as it is in a frame that runs no scripts. */
+.chat-message-html {
+    display: block;
+    width: 100%;
+    min-width: 280px;
+    min-height: 48px;
+    max-height: 640px;
+    border: 0;
+    border-radius: 10px;
+    background: #fff;
+}
+
+/* A line under a message, such as why it wasn't delivered. */
+.chat-message-note {
+    margin-top: 4px;
+    font-size: 12px;
+    color: var(--chat-note, #c0392b);
+}
 .chat-message-text > :last-child { margin-bottom: 0; }
 
 .chat-message-text table {
@@ -4992,3 +5011,20 @@ button.chat-message-file {
     padding: 6px 12px;
     cursor: pointer;
 }
+
+/* A suggested ending after the caret: Tab takes it. */
+.tokenized-ghost {
+    color: var(--chat-ghost, rgba(0, 0, 0, 0.35));
+    white-space: pre-wrap;
+    pointer-events: none;
+    user-select: none;
+}
+.tokenized-ghost::after {
+    content: attr(data-hint);
+    margin-left: 6px;
+    padding: 0 4px;
+    border: 1px solid currentColor;
+    border-radius: 4px;
+    font-size: 10px;
+    vertical-align: middle;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fauna-api",
-  "version": "1.0.783",
+  "version": "1.0.786",
   "description": "The Fauna SDK: accounts, Drive, groups, calendar, chats, payments and every Fauna app (Parrot, Marmot, Magpie, Cicada, Ant, Termite), plus React UI.",
   "homepage": "https://docs.faunakit.com",
   "repository": {

package/dist/src/cicada/conversations.d.ts

@@ -1,75 +0,0 @@
-import { Contact, Owner } from "./contacts.js";
-import { Platform } from "../integrations.js";
-import { Credentials, ApiKey } from "../authentification.js";
-import { File as FaunaFile } from "../drive.js";
-export type Conversation = {
-    id: string;
-    inboxId?: string;
-    participants: (Contact | Owner | string)[];
-    activeAt: Date;
-    unread: number;
-};
-export type Reminder = {
-    conversation: Conversation;
-    remindAt: Date;
-};
-export type ScheduledSend = {
-    id: string;
-    sendAt: Date;
-    createdAt: Date;
-    message: string;
-    context: {
-        conversation: string;
-        platform?: Platform;
-    } | {
-        recipients: (Contact | Owner | string)[];
-        mode: 'broadcast' | 'group';
-        platform: Platform;
-    };
-};
-export type Message = {
-    id: string;
-    author: Contact | Owner | string;
-    platform: Platform;
-    createdAt: Date;
-    message: string;
-    raw?: string;
-    attachments: FaunaFile[];
-    /** Sent by the inbox agent. */
-    agent: boolean;
-    /** Why it never reached them, when its carrier refused it or it failed to send. */
-    undelivered?: string;
-};
-export declare function listInbox(authorization: Credentials | ApiKey, inboxId?: string): Promise<Conversation[]>;
-export declare function listArchived(authorization: Credentials | ApiKey, inboxId?: string): Promise<Conversation[]>;
-export declare function listReminders(authorization: Credentials | ApiKey, inboxId?: string): Promise<Reminder[]>;
-export declare function get(authorization: Credentials | ApiKey, conversation: string): Promise<Conversation | null>;
-export declare function read(authorization: Credentials | ApiKey, conversation: string): Promise<Message[]>;
-export declare function autocomplete(authorization: Credentials | ApiKey, conversation: string, text: string): Promise<string>;
-export declare function markRead(authorization: Credentials | ApiKey, conversation: string): Promise<void>;
-export declare function remove(authorization: Credentials | ApiKey, conversation: string): Promise<void>;
-export declare function compose(authorization: Credentials | ApiKey, options: {
-    recipients: string[];
-    platform: Platform;
-    text: string;
-    mode: 'broadcast' | 'group';
-    inboxId?: string;
-    accountId?: string;
-}): Promise<string[]>;
-export declare function send(authorization: Credentials | ApiKey, conversation: string, text: string, platform?: Platform): Promise<string>;
-export declare function archive(authorization: Credentials | ApiKey, conversation: string, archived: boolean): Promise<void>;
-export declare function remind(authorization: Credentials | ApiKey, conversation: string, at: Date | null): Promise<void>;
-export declare function schedule(authorization: Credentials | ApiKey, options: {
-    sendAt: Date;
-    text: string;
-    platform?: Platform;
-    conversationId?: string;
-    compose?: {
-        recipients: string[];
-        mode: 'broadcast' | 'group';
-    };
-    inboxId?: string;
-    accountId?: string;
-}): Promise<string>;
-export declare function listScheduled(authorization: Credentials | ApiKey, inboxId?: string): Promise<ScheduledSend[]>;
-export declare function cancelScheduled(authorization: Credentials | ApiKey, scheduled: string): Promise<void>;

package/dist/src/cicada/conversations.js

@@ -1,236 +0,0 @@
-import { Cicada } from "./index.js";
-function wrapConversation(raw) {
-    return {
-        ...raw,
-        inboxId: raw.inboxId !== undefined ? String(raw.inboxId) : undefined,
-        activeAt: new Date(raw.activeAt)
-    };
-}
-function wrapMessage(raw) {
-    return {
-        ...raw,
-        createdAt: new Date(raw.createdAt),
-        attachments: raw.attachments ?? [],
-        agent: raw.agent === true,
-    };
-}
-async function listView(authorization, path, inboxId) {
-    const response = await fetch(`${Cicada.getURL()}${path}`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
-        },
-        body: JSON.stringify(inboxId ? { inboxId } : {})
-    });
-    if (!response.ok)
-        throw new Error(await response.text());
-    const json = await response.json();
-    return json.map(wrapConversation);
-}
-// The inbox working set: everything except archived threads and conversations
-// parked for a future reminder.
-export async function listInbox(authorization, inboxId) {
-    return listView(authorization, '/cicada/inbox', inboxId);
-}
-// The archive.
-export async function listArchived(authorization, inboxId) {
-    return listView(authorization, '/cicada/archived', inboxId);
-}
-// Threads with a pending (future) remindAt, each paired with its due time.
-export async function listReminders(authorization, inboxId) {
-    const response = await fetch(`${Cicada.getURL()}/cicada/reminders`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
-        },
-        body: JSON.stringify(inboxId ? { inboxId } : {})
-    });
-    if (!response.ok)
-        throw new Error(await response.text());
-    const json = await response.json();
-    return json.map((raw) => ({
-        conversation: wrapConversation(raw.conversation),
-        remindAt: new Date(raw.remindAt)
-    }));
-}
-// Fetch a single conversation's metadata by id (hydrated participants), or null
-// if it no longer exists.
-export async function get(authorization, conversation) {
-    const response = await fetch(`${Cicada.getURL()}/cicada/conversation/get`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
-        },
-        body: JSON.stringify({ conversation })
-    });
-    if (!response.ok)
-        throw new Error(await response.text());
-    const json = await response.json();
-    return json ? wrapConversation(json) : null;
-}
-export async function read(authorization, conversation) {
-    const response = await fetch(`${Cicada.getURL()}/cicada/conversation`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
-        },
-        body: JSON.stringify({ conversation })
-    });
-    if (!response.ok)
-        throw new Error(await response.text());
-    const json = await response.json();
-    return json.map(wrapMessage);
-}
-// Suggest a continuation of an in-progress reply for a conversation. Returns
-// the raw completion text (the part that should follow the current draft); an
-// empty string means no suggestion.
-export async function autocomplete(authorization, conversation, text) {
-    const response = await fetch(`${Cicada.getURL()}/cicada/autocomplete`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
-        },
-        body: JSON.stringify({ conversation, text })
-    });
-    if (!response.ok)
-        throw new Error(await response.text());
-    return await response.text();
-}
-export async function markRead(authorization, conversation) {
-    const response = await fetch(`${Cicada.getURL()}/cicada/conversation/mark-read`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
-        },
-        body: JSON.stringify({ conversation })
-    });
-    if (!response.ok)
-        throw new Error(await response.text());
-}
-// Permanently delete a conversation (index entry + stored messages). Backfill
-// won't repopulate it — it only runs on account link, and polling fetches
-// deltas, so old messages never re-arrive.
-export async function remove(authorization, conversation) {
-    const response = await fetch(`${Cicada.getURL()}/cicada/conversation/delete`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
-        },
-        body: JSON.stringify({ conversation })
-    });
-    if (!response.ok)
-        throw new Error(await response.text());
-}
-// Start (or append to) conversations with picked contacts on a platform.
-// `recipients` are contact keys (email/handle/phone). `broadcast` sends a
-// separate 1:1 to each; `group` sends one shared thread (collapsing to
-// broadcast on platforms without a real group path). Returns the affected
-// conversation ids — open the first to show the resulting thread.
-export async function compose(authorization, options) {
-    const response = await fetch(`${Cicada.getURL()}/cicada/compose`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
-        },
-        body: JSON.stringify(options)
-    });
-    if (!response.ok)
-        throw new Error(await response.text());
-    const json = await response.json();
-    return json.conversationIds;
-}
-export async function send(authorization, conversation, text, platform) {
-    const response = await fetch(`${Cicada.getURL()}/cicada/send`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
-        },
-        body: JSON.stringify({ conversation, text, platform })
-    });
-    if (!response.ok)
-        throw new Error(await response.text());
-    const json = await response.json();
-    return json.id;
-}
-// Move a conversation in/out of the archive.
-export async function archive(authorization, conversation, archived) {
-    const response = await fetch(`${Cicada.getURL()}/cicada/conversation/archive`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
-        },
-        body: JSON.stringify({ conversation, archived })
-    });
-    if (!response.ok)
-        throw new Error(await response.text());
-}
-// Set (or clear, with `at = null`) a reminder on a conversation. When the time
-// arrives the server re-surfaces the thread at the top of the inbox.
-export async function remind(authorization, conversation, at) {
-    const response = await fetch(`${Cicada.getURL()}/cicada/conversation/remind`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
-        },
-        body: JSON.stringify({ conversation, at: at ? at.toISOString() : null })
-    });
-    if (!response.ok)
-        throw new Error(await response.text());
-}
-// Queue an outbound message for later. Provide `conversationId` to reply into an
-// existing thread, or `compose` to start a fresh one. Returns the queue id.
-export async function schedule(authorization, options) {
-    const response = await fetch(`${Cicada.getURL()}/cicada/schedule`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
-        },
-        body: JSON.stringify({ ...options, sendAt: options.sendAt.toISOString() })
-    });
-    if (!response.ok)
-        throw new Error(await response.text());
-    const json = await response.json();
-    return json.id;
-}
-export async function listScheduled(authorization, inboxId) {
-    const response = await fetch(`${Cicada.getURL()}/cicada/scheduled/list`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
-        },
-        body: JSON.stringify(inboxId ? { inboxId } : {})
-    });
-    if (!response.ok)
-        throw new Error(await response.text());
-    const json = await response.json();
-    return json.map((raw) => ({
-        ...raw,
-        sendAt: new Date(raw.sendAt),
-        createdAt: new Date(raw.createdAt)
-    }));
-}
-export async function cancelScheduled(authorization, scheduled) {
-    const response = await fetch(`${Cicada.getURL()}/cicada/scheduled/cancel`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
-        },
-        body: JSON.stringify({ scheduled })
-    });
-    if (!response.ok)
-        throw new Error(await response.text());
-}